Michael Freno
7c684a42cc
- Consolidated duplicate UndoManagers to single instance - Fixed connection promise to only resolve on 'connected' status - Fixed WebSocketProvider import (WebsocketProvider) - Added proper doc.destroy() cleanup - Renamed isPresenceInitialized property to avoid conflict Co-Authored-By: Paperclip <noreply@paperclip.ing>
618 lines
19 KiB
TypeScript
618 lines
19 KiB
TypeScript
import * as AbiParameters from '../core/AbiParameters.js'
|
|
import type * as Address from '../core/Address.js'
|
|
import type * as Errors from '../core/Errors.js'
|
|
import * as Hash from '../core/Hash.js'
|
|
import * as Hex from '../core/Hex.js'
|
|
import * as Signature from '../core/Signature.js'
|
|
import type { Assign, Compute, OneOf } from '../core/internal/types.js'
|
|
import type * as EntryPoint from './EntryPoint.js'
|
|
|
|
/** User Operation. */
|
|
export type UserOperation<
|
|
entryPointVersion extends EntryPoint.Version = EntryPoint.Version,
|
|
signed extends boolean = boolean,
|
|
bigintType = bigint,
|
|
> = OneOf<
|
|
| (entryPointVersion extends '0.6' ? V06<signed, bigintType> : never)
|
|
| (entryPointVersion extends '0.7' ? V07<signed, bigintType> : never)
|
|
>
|
|
|
|
/**
|
|
* Packed User Operation.
|
|
*
|
|
* @see https://eips.ethereum.org/EIPS/eip-4337#entrypoint-definition
|
|
*/
|
|
export type Packed = {
|
|
/** Concatenation of `verificationGasLimit` (16 bytes) and `callGasLimit` (16 bytes) */
|
|
accountGasLimits: Hex.Hex
|
|
/** The data to pass to the `sender` during the main execution call. */
|
|
callData: Hex.Hex
|
|
/** Concatenation of `factory` and `factoryData`. */
|
|
initCode: Hex.Hex
|
|
/** Concatenation of `maxPriorityFee` (16 bytes) and `maxFeePerGas` (16 bytes) */
|
|
gasFees: Hex.Hex
|
|
/** Anti-replay parameter. */
|
|
nonce: bigint
|
|
/** Concatenation of paymaster fields (or empty). */
|
|
paymasterAndData: Hex.Hex
|
|
/** Extra gas to pay the Bundler. */
|
|
preVerificationGas: bigint
|
|
/** The account making the operation. */
|
|
sender: Address.Address
|
|
/** Data passed into the account to verify authorization. */
|
|
signature: Hex.Hex
|
|
}
|
|
|
|
/** RPC User Operation type. */
|
|
export type Rpc<
|
|
entryPointVersion extends EntryPoint.Version = EntryPoint.Version,
|
|
signed extends boolean = true,
|
|
> = OneOf<
|
|
| (entryPointVersion extends '0.6' ? V06<signed, Hex.Hex> : never)
|
|
| (entryPointVersion extends '0.7' ? V07<signed, Hex.Hex> : never)
|
|
>
|
|
|
|
/** Transaction Info. */
|
|
export type TransactionInfo<
|
|
entryPointVersion extends EntryPoint.Version = EntryPoint.Version,
|
|
bigintType = bigint,
|
|
> = {
|
|
blockHash: Hex.Hex
|
|
blockNumber: bigintType
|
|
entryPoint: Address.Address
|
|
transactionHash: Hex.Hex
|
|
userOperation: UserOperation<entryPointVersion, true, bigintType>
|
|
}
|
|
|
|
/** RPC Transaction Info. */
|
|
export type RpcTransactionInfo<
|
|
entryPointVersion extends EntryPoint.Version = EntryPoint.Version,
|
|
> = TransactionInfo<entryPointVersion, Hex.Hex>
|
|
|
|
/** Type for User Operation on EntryPoint 0.6 */
|
|
export type V06<signed extends boolean = boolean, bigintType = bigint> = {
|
|
/** The data to pass to the `sender` during the main execution call. */
|
|
callData: Hex.Hex
|
|
/** The amount of gas to allocate the main execution call */
|
|
callGasLimit: bigintType
|
|
/** Account init code. Only for new accounts. */
|
|
initCode?: Hex.Hex | undefined
|
|
/** Maximum fee per gas. */
|
|
maxFeePerGas: bigintType
|
|
/** Maximum priority fee per gas. */
|
|
maxPriorityFeePerGas: bigintType
|
|
/** Anti-replay parameter. */
|
|
nonce: bigintType
|
|
/** Paymaster address with calldata. */
|
|
paymasterAndData?: Hex.Hex | undefined
|
|
/** Extra gas to pay the Bundler. */
|
|
preVerificationGas: bigintType
|
|
/** The account making the operation. */
|
|
sender: Address.Address
|
|
/** Data passed into the account to verify authorization. */
|
|
signature?: Hex.Hex | undefined
|
|
/** The amount of gas to allocate for the verification step. */
|
|
verificationGasLimit: bigintType
|
|
} & (signed extends true ? { signature: Hex.Hex } : {})
|
|
|
|
/** RPC User Operation on EntryPoint 0.6 */
|
|
export type RpcV06<signed extends boolean = true> = V06<signed, Hex.Hex>
|
|
|
|
/** Type for User Operation on EntryPoint 0.7 */
|
|
export type V07<signed extends boolean = boolean, bigintType = bigint> = {
|
|
/** The data to pass to the `sender` during the main execution call. */
|
|
callData: Hex.Hex
|
|
/** The amount of gas to allocate the main execution call */
|
|
callGasLimit: bigintType
|
|
/** Account factory. Only for new accounts. */
|
|
factory?: Address.Address | undefined
|
|
/** Data for account factory. */
|
|
factoryData?: Hex.Hex | undefined
|
|
/** Maximum fee per gas. */
|
|
maxFeePerGas: bigintType
|
|
/** Maximum priority fee per gas. */
|
|
maxPriorityFeePerGas: bigintType
|
|
/** Anti-replay parameter. */
|
|
nonce: bigintType
|
|
/** Address of paymaster contract. */
|
|
paymaster?: Address.Address | undefined
|
|
/** Data for paymaster. */
|
|
paymasterData?: Hex.Hex | undefined
|
|
/** The amount of gas to allocate for the paymaster post-operation code. */
|
|
paymasterPostOpGasLimit?: bigintType | undefined
|
|
/** The amount of gas to allocate for the paymaster validation code. */
|
|
paymasterVerificationGasLimit?: bigintType | undefined
|
|
/** Extra gas to pay the Bundler. */
|
|
preVerificationGas: bigintType
|
|
/** The account making the operation. */
|
|
sender: Address.Address
|
|
/** Data passed into the account to verify authorization. */
|
|
signature?: Hex.Hex | undefined
|
|
/** The amount of gas to allocate for the verification step. */
|
|
verificationGasLimit: bigintType
|
|
} & (signed extends true ? { signature: Hex.Hex } : {})
|
|
|
|
/** RPC User Operation on EntryPoint 0.7 */
|
|
export type RpcV07<signed extends boolean = true> = V07<signed, Hex.Hex>
|
|
|
|
/**
|
|
* Instantiates a {@link ox#UserOperation.UserOperation} from a provided input.
|
|
*
|
|
* @example
|
|
* ```ts twoslash
|
|
* import { Value } from 'ox'
|
|
* import { UserOperation } from 'ox/erc4337'
|
|
*
|
|
* const userOperation = UserOperation.from({
|
|
* callData: '0xdeadbeef',
|
|
* callGasLimit: 300_000n,
|
|
* maxFeePerGas: Value.fromGwei('20'),
|
|
* maxPriorityFeePerGas: Value.fromGwei('2'),
|
|
* nonce: 69n,
|
|
* preVerificationGas: 100_000n,
|
|
* sender: '0x9f1fdab6458c5fc642fa0f4c5af7473c46837357',
|
|
* verificationGasLimit: 100_000n,
|
|
* })
|
|
* ```
|
|
*
|
|
* @example
|
|
* ### Attaching Signatures
|
|
*
|
|
* ```ts twoslash
|
|
* import { Secp256k1, Value } from 'ox'
|
|
* import { UserOperation } from 'ox/erc4337'
|
|
*
|
|
* const userOperation = UserOperation.from({
|
|
* callData: '0xdeadbeef',
|
|
* callGasLimit: 300_000n,
|
|
* maxFeePerGas: Value.fromGwei('20'),
|
|
* maxPriorityFeePerGas: Value.fromGwei('2'),
|
|
* nonce: 69n,
|
|
* preVerificationGas: 100_000n,
|
|
* sender: '0x9f1fdab6458c5fc642fa0f4c5af7473c46837357',
|
|
* verificationGasLimit: 100_000n,
|
|
* })
|
|
*
|
|
* const payload = UserOperation.getSignPayload(userOperation, {
|
|
* chainId: 1,
|
|
* entryPointAddress: '0x1234567890123456789012345678901234567890',
|
|
* entryPointVersion: '0.7',
|
|
* })
|
|
*
|
|
* const signature = Secp256k1.sign({ payload, privateKey: '0x...' })
|
|
*
|
|
* const userOperation_signed = UserOperation.from(userOperation, { signature }) // [!code focus]
|
|
* ```
|
|
*
|
|
* @param userOperation - The user operation to instantiate.
|
|
* @returns User Operation.
|
|
*/
|
|
export function from<
|
|
const userOperation extends UserOperation,
|
|
const signature extends Hex.Hex | undefined = undefined,
|
|
>(
|
|
userOperation: userOperation | UserOperation,
|
|
options: from.Options<signature> = {},
|
|
): from.ReturnType<userOperation, signature> {
|
|
const signature = (() => {
|
|
if (!options.signature) return undefined
|
|
if (typeof options.signature === 'string') return options.signature
|
|
return Signature.toHex(options.signature)
|
|
})()
|
|
return { ...userOperation, signature } as never
|
|
}
|
|
|
|
export declare namespace from {
|
|
export type Options<
|
|
signature extends Signature.Signature | Hex.Hex | undefined = undefined,
|
|
> = {
|
|
signature?: signature | Signature.Signature | Hex.Hex | undefined
|
|
}
|
|
|
|
export type ReturnType<
|
|
userOperation extends UserOperation = UserOperation,
|
|
signature extends Signature.Signature | Hex.Hex | undefined = undefined,
|
|
> = Compute<
|
|
Assign<
|
|
userOperation,
|
|
signature extends Signature.Signature | Hex.Hex
|
|
? Readonly<{ signature: Hex.Hex }>
|
|
: {}
|
|
>
|
|
>
|
|
|
|
export type ErrorType = Errors.GlobalErrorType
|
|
}
|
|
|
|
/**
|
|
* Converts an {@link ox#UserOperation.Rpc} to an {@link ox#UserOperation.UserOperation}.
|
|
*
|
|
* @example
|
|
* ```ts twoslash
|
|
* import { UserOperation } from 'ox/erc4337'
|
|
*
|
|
* const userOperation = UserOperation.fromRpc({
|
|
* callData: '0xdeadbeef',
|
|
* callGasLimit: '0x69420',
|
|
* maxFeePerGas: '0x2ca6ae494',
|
|
* maxPriorityFeePerGas: '0x41cc3c0',
|
|
* nonce: '0x357',
|
|
* preVerificationGas: '0x69420',
|
|
* signature: '0x',
|
|
* sender: '0x1234567890123456789012345678901234567890',
|
|
* verificationGasLimit: '0x69420',
|
|
* })
|
|
* ```
|
|
*
|
|
* @param rpc - The RPC user operation to convert.
|
|
* @returns An instantiated {@link ox#UserOperation.UserOperation}.
|
|
*/
|
|
export function fromRpc(rpc: Rpc): UserOperation {
|
|
return {
|
|
...rpc,
|
|
callGasLimit: BigInt(rpc.callGasLimit),
|
|
maxFeePerGas: BigInt(rpc.maxFeePerGas),
|
|
maxPriorityFeePerGas: BigInt(rpc.maxPriorityFeePerGas),
|
|
nonce: BigInt(rpc.nonce),
|
|
preVerificationGas: BigInt(rpc.preVerificationGas),
|
|
verificationGasLimit: BigInt(rpc.verificationGasLimit),
|
|
...(rpc.paymasterPostOpGasLimit && {
|
|
paymasterPostOpGasLimit: BigInt(rpc.paymasterPostOpGasLimit),
|
|
}),
|
|
...(rpc.paymasterVerificationGasLimit && {
|
|
paymasterVerificationGasLimit: BigInt(rpc.paymasterVerificationGasLimit),
|
|
}),
|
|
} as UserOperation
|
|
}
|
|
|
|
export declare namespace fromRpc {
|
|
type ErrorType = Errors.GlobalErrorType
|
|
}
|
|
|
|
/**
|
|
* Obtains the signing payload for a {@link ox#UserOperation.UserOperation}.
|
|
*
|
|
* @example
|
|
* ```ts twoslash
|
|
* import { Secp256k1, Value } from 'ox'
|
|
* import { UserOperation } from 'ox/erc4337'
|
|
*
|
|
* const userOperation = UserOperation.from({
|
|
* callData: '0xdeadbeef',
|
|
* callGasLimit: 300_000n,
|
|
* maxFeePerGas: Value.fromGwei('20'),
|
|
* maxPriorityFeePerGas: Value.fromGwei('2'),
|
|
* nonce: 69n,
|
|
* preVerificationGas: 100_000n,
|
|
* sender: '0x9f1fdab6458c5fc642fa0f4c5af7473c46837357',
|
|
* verificationGasLimit: 100_000n,
|
|
* })
|
|
*
|
|
* const payload = UserOperation.getSignPayload(userOperation, { // [!code focus]
|
|
* chainId: 1, // [!code focus]
|
|
* entryPointAddress: '0x1234567890123456789012345678901234567890', // [!code focus]
|
|
* entryPointVersion: '0.6', // [!code focus]
|
|
* }) // [!code focus]
|
|
*
|
|
* const signature = Secp256k1.sign({ payload, privateKey: '0x...' })
|
|
* ```
|
|
*
|
|
* @param userOperation - The user operation to get the sign payload for.
|
|
* @returns The signing payload for the user operation.
|
|
*/
|
|
export function getSignPayload<
|
|
entrypointVersion extends EntryPoint.Version = EntryPoint.Version,
|
|
>(
|
|
userOperation: UserOperation<entrypointVersion>,
|
|
options: getSignPayload.Options<entrypointVersion>,
|
|
): Hex.Hex {
|
|
return hash(userOperation, options)
|
|
}
|
|
|
|
export declare namespace getSignPayload {
|
|
type Options<
|
|
entrypointVersion extends EntryPoint.Version = EntryPoint.Version,
|
|
> = hash.Options<entrypointVersion>
|
|
|
|
type ErrorType = hash.ErrorType | Errors.GlobalErrorType
|
|
}
|
|
|
|
/**
|
|
* Hashes a {@link ox#UserOperation.UserOperation}. This is the "user operation hash".
|
|
*
|
|
* @example
|
|
* ```ts twoslash
|
|
* import { Value } from 'ox'
|
|
* import { UserOperation } from 'ox/erc4337'
|
|
*
|
|
* const userOperation = UserOperation.hash({
|
|
* callData: '0xdeadbeef',
|
|
* callGasLimit: 300_000n,
|
|
* maxFeePerGas: Value.fromGwei('20'),
|
|
* maxPriorityFeePerGas: Value.fromGwei('2'),
|
|
* nonce: 69n,
|
|
* preVerificationGas: 100_000n,
|
|
* sender: '0x9f1fdab6458c5fc642fa0f4c5af7473c46837357',
|
|
* verificationGasLimit: 100_000n,
|
|
* }, {
|
|
* chainId: 1,
|
|
* entryPointAddress: '0x1234567890123456789012345678901234567890',
|
|
* entryPointVersion: '0.6',
|
|
* })
|
|
* ```
|
|
*
|
|
* @param userOperation - The user operation to hash.
|
|
* @returns The hash of the user operation.
|
|
*/
|
|
export function hash<
|
|
entrypointVersion extends EntryPoint.Version = EntryPoint.Version,
|
|
>(
|
|
userOperation: UserOperation<entrypointVersion>,
|
|
options: hash.Options<entrypointVersion>,
|
|
): Hex.Hex {
|
|
const { chainId, entryPointAddress, entryPointVersion } = options
|
|
const {
|
|
callData,
|
|
callGasLimit,
|
|
initCode,
|
|
factory,
|
|
factoryData,
|
|
maxFeePerGas,
|
|
maxPriorityFeePerGas,
|
|
nonce,
|
|
paymaster,
|
|
paymasterAndData,
|
|
paymasterData,
|
|
paymasterPostOpGasLimit,
|
|
paymasterVerificationGasLimit,
|
|
preVerificationGas,
|
|
sender,
|
|
verificationGasLimit,
|
|
} = userOperation as UserOperation
|
|
|
|
const packedUserOp = (() => {
|
|
if (entryPointVersion === '0.6') {
|
|
return AbiParameters.encode(
|
|
[
|
|
{ type: 'address' },
|
|
{ type: 'uint256' },
|
|
{ type: 'bytes32' },
|
|
{ type: 'bytes32' },
|
|
{ type: 'uint256' },
|
|
{ type: 'uint256' },
|
|
{ type: 'uint256' },
|
|
{ type: 'uint256' },
|
|
{ type: 'uint256' },
|
|
{ type: 'bytes32' },
|
|
],
|
|
[
|
|
sender,
|
|
nonce,
|
|
Hash.keccak256(initCode ?? '0x'),
|
|
Hash.keccak256(callData),
|
|
callGasLimit,
|
|
verificationGasLimit,
|
|
preVerificationGas,
|
|
maxFeePerGas,
|
|
maxPriorityFeePerGas,
|
|
Hash.keccak256(paymasterAndData ?? '0x'),
|
|
],
|
|
)
|
|
}
|
|
|
|
if (entryPointVersion === '0.7') {
|
|
const accountGasLimits = Hex.concat(
|
|
Hex.padLeft(Hex.fromNumber(verificationGasLimit), 16),
|
|
Hex.padLeft(Hex.fromNumber(callGasLimit), 16),
|
|
)
|
|
const gasFees = Hex.concat(
|
|
Hex.padLeft(Hex.fromNumber(maxPriorityFeePerGas), 16),
|
|
Hex.padLeft(Hex.fromNumber(maxFeePerGas), 16),
|
|
)
|
|
const initCode_hashed = Hash.keccak256(
|
|
factory && factoryData ? Hex.concat(factory, factoryData) : '0x',
|
|
)
|
|
const paymasterAndData_hashed = Hash.keccak256(
|
|
paymaster
|
|
? Hex.concat(
|
|
paymaster,
|
|
Hex.padLeft(
|
|
Hex.fromNumber(paymasterVerificationGasLimit || 0),
|
|
16,
|
|
),
|
|
Hex.padLeft(Hex.fromNumber(paymasterPostOpGasLimit || 0), 16),
|
|
paymasterData || '0x',
|
|
)
|
|
: '0x',
|
|
)
|
|
|
|
return AbiParameters.encode(
|
|
[
|
|
{ type: 'address' },
|
|
{ type: 'uint256' },
|
|
{ type: 'bytes32' },
|
|
{ type: 'bytes32' },
|
|
{ type: 'bytes32' },
|
|
{ type: 'uint256' },
|
|
{ type: 'bytes32' },
|
|
{ type: 'bytes32' },
|
|
],
|
|
[
|
|
sender,
|
|
nonce,
|
|
initCode_hashed,
|
|
Hash.keccak256(callData),
|
|
accountGasLimits,
|
|
preVerificationGas,
|
|
gasFees,
|
|
paymasterAndData_hashed,
|
|
],
|
|
)
|
|
}
|
|
|
|
throw new Error(`entryPointVersion "${entryPointVersion}" not supported.`)
|
|
})()
|
|
|
|
return Hash.keccak256(
|
|
AbiParameters.encode(
|
|
[{ type: 'bytes32' }, { type: 'address' }, { type: 'uint256' }],
|
|
[Hash.keccak256(packedUserOp), entryPointAddress, BigInt(chainId)],
|
|
),
|
|
)
|
|
}
|
|
|
|
export declare namespace hash {
|
|
type Options<
|
|
entrypointVersion extends EntryPoint.Version = EntryPoint.Version,
|
|
> = {
|
|
chainId: number
|
|
entryPointAddress: Address.Address
|
|
entryPointVersion: entrypointVersion | EntryPoint.Version
|
|
}
|
|
|
|
type ErrorType =
|
|
| AbiParameters.encode.ErrorType
|
|
| Hash.keccak256.ErrorType
|
|
| Hex.concat.ErrorType
|
|
| Hex.fromNumber.ErrorType
|
|
| Hex.padLeft.ErrorType
|
|
| Errors.GlobalErrorType
|
|
}
|
|
|
|
/**
|
|
* Transforms a User Operation into "packed" format.
|
|
*
|
|
* @example
|
|
* ```ts twoslash
|
|
* import { Value } from 'ox'
|
|
* import { UserOperation } from 'ox/erc4337'
|
|
*
|
|
* const packed = UserOperation.toPacked({
|
|
* callData: '0xdeadbeef',
|
|
* callGasLimit: 300_000n,
|
|
* maxFeePerGas: Value.fromGwei('20'),
|
|
* maxPriorityFeePerGas: Value.fromGwei('2'),
|
|
* nonce: 69n,
|
|
* preVerificationGas: 100_000n,
|
|
* sender: '0x9f1fdab6458c5fc642fa0f4c5af7473c46837357',
|
|
* signature: '0x...',
|
|
* verificationGasLimit: 100_000n,
|
|
* })
|
|
* ```
|
|
*
|
|
* @param userOperation - The user operation to transform.
|
|
* @returns The packed user operation.
|
|
*/
|
|
export function toPacked(userOperation: UserOperation<'0.7', true>): Packed {
|
|
const {
|
|
callGasLimit,
|
|
callData,
|
|
factory,
|
|
factoryData,
|
|
maxPriorityFeePerGas,
|
|
maxFeePerGas,
|
|
nonce,
|
|
paymaster,
|
|
paymasterData,
|
|
paymasterPostOpGasLimit,
|
|
paymasterVerificationGasLimit,
|
|
sender,
|
|
signature,
|
|
verificationGasLimit,
|
|
} = userOperation
|
|
|
|
const accountGasLimits = Hex.concat(
|
|
Hex.padLeft(Hex.fromNumber(verificationGasLimit || 0n), 16),
|
|
Hex.padLeft(Hex.fromNumber(callGasLimit || 0n), 16),
|
|
)
|
|
const initCode =
|
|
factory && factoryData ? Hex.concat(factory, factoryData) : '0x'
|
|
const gasFees = Hex.concat(
|
|
Hex.padLeft(Hex.fromNumber(maxPriorityFeePerGas || 0n), 16),
|
|
Hex.padLeft(Hex.fromNumber(maxFeePerGas || 0n), 16),
|
|
)
|
|
const paymasterAndData = paymaster
|
|
? Hex.concat(
|
|
paymaster,
|
|
Hex.padLeft(Hex.fromNumber(paymasterVerificationGasLimit || 0n), 16),
|
|
Hex.padLeft(Hex.fromNumber(paymasterPostOpGasLimit || 0n), 16),
|
|
paymasterData || '0x',
|
|
)
|
|
: '0x'
|
|
const preVerificationGas = userOperation.preVerificationGas ?? 0n
|
|
|
|
return {
|
|
accountGasLimits,
|
|
callData,
|
|
initCode,
|
|
gasFees,
|
|
nonce,
|
|
paymasterAndData,
|
|
preVerificationGas,
|
|
sender,
|
|
signature,
|
|
}
|
|
}
|
|
|
|
export declare namespace toPacked {
|
|
export type ErrorType = Errors.GlobalErrorType
|
|
}
|
|
|
|
/**
|
|
* Converts a {@link ox#UserOperation.UserOperation} to a {@link ox#UserOperation.Rpc}.
|
|
*
|
|
* @example
|
|
* ```ts twoslash
|
|
* import { Value } from 'ox'
|
|
* import { UserOperation } from 'ox/erc4337'
|
|
*
|
|
* const userOperation = UserOperation.toRpc({
|
|
* callData: '0xdeadbeef',
|
|
* callGasLimit: 300_000n,
|
|
* maxFeePerGas: Value.fromGwei('20'),
|
|
* maxPriorityFeePerGas: Value.fromGwei('2'),
|
|
* nonce: 69n,
|
|
* preVerificationGas: 100_000n,
|
|
* sender: '0x9f1fdab6458c5fc642fa0f4c5af7473c46837357',
|
|
* verificationGasLimit: 100_000n,
|
|
* })
|
|
* ```
|
|
*
|
|
* @param userOperation - The user operation to convert.
|
|
* @returns An RPC-formatted user operation.
|
|
*/
|
|
export function toRpc(userOperation: UserOperation): Rpc {
|
|
const rpc = {} as Rpc
|
|
|
|
rpc.callData = userOperation.callData
|
|
rpc.callGasLimit = Hex.fromNumber(userOperation.callGasLimit)
|
|
rpc.maxFeePerGas = Hex.fromNumber(userOperation.maxFeePerGas)
|
|
rpc.maxPriorityFeePerGas = Hex.fromNumber(userOperation.maxPriorityFeePerGas)
|
|
rpc.nonce = Hex.fromNumber(userOperation.nonce)
|
|
rpc.preVerificationGas = Hex.fromNumber(userOperation.preVerificationGas)
|
|
rpc.sender = userOperation.sender
|
|
rpc.verificationGasLimit = Hex.fromNumber(userOperation.verificationGasLimit)
|
|
|
|
if (userOperation.factory) rpc.factory = userOperation.factory
|
|
if (userOperation.factoryData) rpc.factoryData = userOperation.factoryData
|
|
if (userOperation.initCode) rpc.initCode = userOperation.initCode
|
|
if (userOperation.paymaster) rpc.paymaster = userOperation.paymaster
|
|
if (userOperation.paymasterData)
|
|
rpc.paymasterData = userOperation.paymasterData
|
|
if (typeof userOperation.paymasterPostOpGasLimit === 'bigint')
|
|
rpc.paymasterPostOpGasLimit = Hex.fromNumber(
|
|
userOperation.paymasterPostOpGasLimit,
|
|
)
|
|
if (typeof userOperation.paymasterVerificationGasLimit === 'bigint')
|
|
rpc.paymasterVerificationGasLimit = Hex.fromNumber(
|
|
userOperation.paymasterVerificationGasLimit,
|
|
)
|
|
if (userOperation.signature) rpc.signature = userOperation.signature
|
|
|
|
return rpc
|
|
}
|
|
|
|
export declare namespace toRpc {
|
|
export type ErrorType = Hex.fromNumber.ErrorType | Errors.GlobalErrorType
|
|
}
|