rise-wallet 0.1.4-beta.2 → 0.2.29-1

package/dist/core/Porto.d.ts

@@ -0,0 +1,1882 @@
+import type * as Mipd from 'mipd';
+import type * as Address from 'ox/Address';
+import type * as Hex from 'ox/Hex';
+import type * as RpcRequest from 'ox/RpcRequest';
+import type * as RpcResponse from 'ox/RpcResponse';
+import { type Transport } from 'viem';
+import { type Mutate, type StoreApi } from 'zustand/vanilla';
+import type * as Account from '../viem/Account.js';
+import * as Chains from './Chains.js';
+import type * as Mode from './internal/mode.js';
+import { dialog } from './internal/modes/dialog.js';
+import { relay } from './internal/modes/relay.js';
+import type * as internal from './internal/porto.js';
+import * as Provider from './internal/provider.js';
+import type * as Token from './internal/schema/token.js';
+import type * as Siwe from './internal/siwe.js';
+import type { ExactPartial, OneOf } from './internal/types.js';
+import * as Storage from './Storage.js';
+export declare const defaultConfig: {
+    readonly announceProvider: true;
+    readonly chains: [{
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Blockscout";
+                readonly url: "https://explorer.testnet.riselabs.xyz/";
+                readonly apiUrl: "https://explorer.testnet.riselabs.xyz/api";
+            };
+        };
+        blockTime?: number | undefined | undefined;
+        contracts: {
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 11155931;
+        name: "RISE Testnet";
+        nativeCurrency: {
+            readonly name: "RISE Testnet Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://testnet.riselabs.xyz"];
+                readonly webSocket: readonly ["wss://testnet.riselabs.xyz/ws"];
+            };
+        };
+        sourceId?: number | undefined | undefined;
+        testnet: true;
+        custom?: Record<string, unknown> | undefined;
+        fees?: import("viem").ChainFees<undefined> | undefined;
+        formatters?: undefined;
+        serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    }, ...{
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Basescan";
+                readonly url: "https://sepolia.basescan.org";
+                readonly apiUrl: "https://api-sepolia.basescan.org/api";
+            };
+        };
+        blockTime: 2000;
+        contracts: {
+            readonly disputeGameFactory: {
+                readonly 11155111: {
+                    readonly address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1";
+                };
+            };
+            readonly l2OutputOracle: {
+                readonly 11155111: {
+                    readonly address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254";
+                };
+            };
+            readonly portal: {
+                readonly 11155111: {
+                    readonly address: "0x49f53e41452c74589e85ca1677426ba426459e85";
+                    readonly blockCreated: 4446677;
+                };
+            };
+            readonly l1StandardBridge: {
+                readonly 11155111: {
+                    readonly address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120";
+                    readonly blockCreated: 4446677;
+                };
+            };
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 1059647;
+            };
+            readonly gasPriceOracle: {
+                readonly address: "0x420000000000000000000000000000000000000F";
+            };
+            readonly l1Block: {
+                readonly address: "0x4200000000000000000000000000000000000015";
+            };
+            readonly l2CrossDomainMessenger: {
+                readonly address: "0x4200000000000000000000000000000000000007";
+            };
+            readonly l2Erc721Bridge: {
+                readonly address: "0x4200000000000000000000000000000000000014";
+            };
+            readonly l2StandardBridge: {
+                readonly address: "0x4200000000000000000000000000000000000010";
+            };
+            readonly l2ToL1MessagePasser: {
+                readonly address: "0x4200000000000000000000000000000000000016";
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 84532;
+        name: "Base Sepolia";
+        nativeCurrency: {
+            readonly name: "Sepolia Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://sepolia.base.org"];
+            };
+        };
+        sourceId: 11155111;
+        testnet: true;
+        custom?: Record<string, unknown> | undefined;
+        fees?: import("viem").ChainFees<undefined> | undefined;
+        formatters: {
+            readonly block: {
+                exclude: [] | undefined;
+                format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => {
+                    baseFeePerGas: bigint | null;
+                    blobGasUsed: bigint;
+                    difficulty: bigint;
+                    excessBlobGas: bigint;
+                    extraData: import("viem").Hex;
+                    gasLimit: bigint;
+                    gasUsed: bigint;
+                    hash: `0x${string}` | null;
+                    logsBloom: `0x${string}` | null;
+                    miner: import("viem").Address;
+                    mixHash: import("viem").Hash;
+                    nonce: `0x${string}` | null;
+                    number: bigint | null;
+                    parentBeaconBlockRoot?: `0x${string}` | undefined;
+                    parentHash: import("viem").Hash;
+                    receiptsRoot: import("viem").Hex;
+                    sealFields: import("viem").Hex[];
+                    sha3Uncles: import("viem").Hash;
+                    size: bigint;
+                    stateRoot: import("viem").Hash;
+                    timestamp: bigint;
+                    totalDifficulty: bigint | null;
+                    transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
+                    transactionsRoot: import("viem").Hash;
+                    uncles: import("viem").Hash[];
+                    withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
+                    withdrawalsRoot?: `0x${string}` | undefined;
+                } & {};
+                type: "block";
+            };
+            readonly transaction: {
+                exclude: [] | undefined;
+                format: (args: import("viem/chains").OpStackRpcTransaction, action?: string | undefined) => ({
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: import("viem").Address;
+                    gas: bigint;
+                    hash: import("viem").Hash;
+                    input: import("viem").Hex;
+                    nonce: number;
+                    r: import("viem").Hex;
+                    s: import("viem").Hex;
+                    to: import("viem").Address | null;
+                    transactionIndex: number | null;
+                    typeHex: import("viem").Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: boolean;
+                    mint?: bigint | undefined | undefined;
+                    sourceHash: import("viem").Hex;
+                    type: "deposit";
+                } | {
+                    r: import("viem").Hex;
+                    s: import("viem").Hex;
+                    v: bigint;
+                    value: bigint;
+                    gas: bigint;
+                    to: import("viem").Address | null;
+                    from: import("viem").Address;
+                    nonce: number;
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    transactionIndex: number | null;
+                    hash: import("viem").Hash;
+                    input: import("viem").Hex;
+                    typeHex: import("viem").Hex | null;
+                    accessList?: undefined | undefined;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId?: number | undefined;
+                    yParity?: undefined | undefined;
+                    type: "legacy";
+                    gasPrice: bigint;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas?: undefined | undefined;
+                    maxPriorityFeePerGas?: undefined | undefined;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: import("viem").Address;
+                    gas: bigint;
+                    hash: import("viem").Hash;
+                    input: import("viem").Hex;
+                    nonce: number;
+                    r: import("viem").Hex;
+                    s: import("viem").Hex;
+                    to: import("viem").Address | null;
+                    transactionIndex: number | null;
+                    typeHex: import("viem").Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: import("viem").AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip2930";
+                    gasPrice: bigint;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas?: undefined | undefined;
+                    maxPriorityFeePerGas?: undefined | undefined;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: import("viem").Address;
+                    gas: bigint;
+                    hash: import("viem").Hash;
+                    input: import("viem").Hex;
+                    nonce: number;
+                    r: import("viem").Hex;
+                    s: import("viem").Hex;
+                    to: import("viem").Address | null;
+                    transactionIndex: number | null;
+                    typeHex: import("viem").Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: import("viem").AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip1559";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: import("viem").Address;
+                    gas: bigint;
+                    hash: import("viem").Hash;
+                    input: import("viem").Hex;
+                    nonce: number;
+                    r: import("viem").Hex;
+                    s: import("viem").Hex;
+                    to: import("viem").Address | null;
+                    transactionIndex: number | null;
+                    typeHex: import("viem").Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: import("viem").AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes: readonly import("viem").Hex[];
+                    chainId: number;
+                    type: "eip4844";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas: bigint;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: import("viem").Address;
+                    gas: bigint;
+                    hash: import("viem").Hash;
+                    input: import("viem").Hex;
+                    nonce: number;
+                    r: import("viem").Hex;
+                    s: import("viem").Hex;
+                    to: import("viem").Address | null;
+                    transactionIndex: number | null;
+                    typeHex: import("viem").Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: import("viem").AccessList;
+                    authorizationList: import("viem").SignedAuthorizationList;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip7702";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                }) & {};
+                type: "transaction";
+            };
+            readonly transactionReceipt: {
+                exclude: [] | undefined;
+                format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
+                    blobGasPrice?: bigint | undefined;
+                    blobGasUsed?: bigint | undefined;
+                    blockHash: import("viem").Hash;
+                    blockNumber: bigint;
+                    contractAddress: import("viem").Address | null | undefined;
+                    cumulativeGasUsed: bigint;
+                    effectiveGasPrice: bigint;
+                    from: import("viem").Address;
+                    gasUsed: bigint;
+                    logs: import("viem").Log<bigint, number, false>[];
+                    logsBloom: import("viem").Hex;
+                    root?: `0x${string}` | undefined;
+                    status: "success" | "reverted";
+                    to: import("viem").Address | null;
+                    transactionHash: import("viem").Hash;
+                    transactionIndex: number;
+                    type: import("viem").TransactionType;
+                    l1GasPrice: bigint | null;
+                    l1GasUsed: bigint | null;
+                    l1Fee: bigint | null;
+                    l1FeeScalar: number | null;
+                } & {};
+                type: "transactionReceipt";
+            };
+        };
+        serializers: {
+            readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
+        };
+        readonly network: "base-sepolia";
+    }[]];
+    readonly mode: import("./internal/types.js").Assign<Mode.Mode, {
+        readonly actions: {
+            readonly addFunds: () => Promise<never>;
+            readonly createAccount: (parameters: {
+                admins?: readonly Pick<import("../viem/Key.js").Key, "publicKey" | "type">[] | undefined;
+                email?: boolean | undefined;
+                internal: Mode.ActionsInternal;
+                label?: string | undefined;
+                permissions?: import("./internal/permissionsRequest.js").PermissionsRequest | undefined;
+                signInWithEthereum?: import("./internal/schema/capabilities.js").signInWithEthereum.Request | undefined;
+            }) => Promise<{
+                account: {
+                    signInWithEthereum: {
+                        message: string;
+                        signature: `0x${string}`;
+                    } | undefined;
+                    address: import("viem").Address;
+                    publicKey: import("viem").Hex;
+                    type: "local";
+                    nonceManager?: import("viem").NonceManager | undefined;
+                    sign: (parameters: {
+                        hash: import("viem").Hash;
+                    }) => Promise<import("viem").Hex>;
+                    signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
+                    signMessage: ({ message }: {
+                        message: import("viem").SignableMessage;
+                    }) => Promise<import("viem").Hex>;
+                    signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+                        serializer?: serializer | undefined;
+                    } | undefined) => Promise<import("viem").Hex>;
+                    signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
+                    source: "porto" | "privateKey";
+                    keys: readonly import("../viem/Key.js").Key[];
+                };
+            }>;
+            readonly getAccountVersion: (parameters: {
+                address: Address.Address;
+                internal: Mode.ActionsInternal;
+            }) => Promise<{
+                current: string;
+                latest: string;
+            }>;
+            readonly getAssets: (parameters: {
+                account: `0x${string}`;
+                assetFilter?: Record<`0x${string}`, readonly {
+                    address: `0x${string}` | "native";
+                    type: string;
+                }[]> | undefined;
+                assetTypeFilter?: readonly string[] | undefined;
+                chainFilter?: readonly number[] | undefined;
+            } & {
+                internal: Mode.ActionsInternal;
+            }) => Promise<Record<string, readonly ({
+                address: `0x${string}`;
+                balance: bigint;
+                metadata: {
+                    decimals: number;
+                    name: string;
+                    symbol: string;
+                    fiat?: {
+                        currency: string;
+                        value: number;
+                    } | null | undefined;
+                } | null;
+                type: "erc20";
+            } | {
+                address: "native" | null;
+                balance: bigint;
+                metadata: {
+                    decimals: number;
+                    fiat?: {
+                        currency: string;
+                        value: number;
+                    } | null | undefined;
+                    name?: string | undefined;
+                    symbol?: string | undefined;
+                } | null;
+                type: "native";
+            })[]>>;
+            readonly getCallsStatus: (parameters: {
+                id: Hex.Hex;
+                internal: Mode.ActionsInternal;
+            }) => Promise<{
+                atomic: true;
+                chainId: `0x${string}`;
+                id: `0x${string}`;
+                receipts: {
+                    blockHash: `0x${string}`;
+                    blockNumber: `0x${string}`;
+                    gasUsed: `0x${string}`;
+                    logs: readonly {
+                        address: `0x${string}`;
+                        data: `0x${string}`;
+                        topics: readonly `0x${string}`[];
+                    }[];
+                    status: `0x${string}`;
+                    transactionHash: `0x${string}`;
+                }[] | undefined;
+                status: number;
+                version: string;
+            }>;
+            readonly getCapabilities: (parameters: {
+                chainIds?: readonly Hex.Hex[] | undefined;
+                internal: Mode.ActionsInternal;
+            }) => Promise<Record<`0x${string}`, {
+                readonly atomic: {
+                    readonly status: "supported";
+                };
+                readonly atomicBatch: {
+                    readonly supported: true;
+                };
+                readonly feeToken: {
+                    readonly supported: true;
+                    readonly tokens: readonly [];
+                };
+                readonly merchant: {
+                    readonly supported: true;
+                };
+                readonly permissions: {
+                    readonly supported: true;
+                };
+                readonly requiredFunds: {
+                    readonly supported: boolean;
+                    readonly tokens: readonly [];
+                };
+            }>>;
+            readonly getKeys: (parameters: {
+                account: Account.Account;
+                chainIds?: readonly number[] | undefined;
+                internal: Mode.ActionsInternal;
+            }) => Promise<import("../viem/Key.js").Key[]>;
+            readonly grantAdmin: (parameters: {
+                account: Account.Account;
+                internal: Mode.ActionsInternal;
+                feeToken?: Token.Symbol | Address.Address | undefined;
+                key: import("../viem/Key.js").from.Value;
+            }) => Promise<{
+                key: {
+                    expiry: number;
+                    hash: `0x${string}`;
+                    id: `0x${string}`;
+                    publicKey: `0x${string}`;
+                    role: "admin" | "session";
+                    type: "address";
+                    feeToken?: {
+                        limit: `${number}` | `${number}.${number}`;
+                        symbol?: string | undefined;
+                    } | null | undefined;
+                    permissions?: {
+                        calls?: readonly ({
+                            signature: string;
+                            to: `0x${string}`;
+                        } | {
+                            signature: string;
+                            to?: undefined;
+                        } | {
+                            to: `0x${string}`;
+                            signature?: undefined;
+                        })[] | undefined;
+                        signatureVerification?: {
+                            addresses: readonly `0x${string}`[];
+                        } | undefined;
+                        spend?: readonly {
+                            limit: bigint;
+                            period: "minute" | "hour" | "day" | "week" | "month" | "year";
+                            token?: `0x${string}` | undefined;
+                        }[] | undefined;
+                    } | undefined;
+                    chainId?: number | undefined;
+                    prehash?: boolean | undefined | undefined;
+                    privateKey?: unknown;
+                } | {
+                    expiry: number;
+                    hash: `0x${string}`;
+                    id: `0x${string}`;
+                    publicKey: `0x${string}`;
+                    role: "admin" | "session";
+                    type: "p256";
+                    feeToken?: {
+                        limit: `${number}` | `${number}.${number}`;
+                        symbol?: string | undefined;
+                    } | null | undefined;
+                    permissions?: {
+                        calls?: readonly ({
+                            signature: string;
+                            to: `0x${string}`;
+                        } | {
+                            signature: string;
+                            to?: undefined;
+                        } | {
+                            to: `0x${string}`;
+                            signature?: undefined;
+                        })[] | undefined;
+                        signatureVerification?: {
+                            addresses: readonly `0x${string}`[];
+                        } | undefined;
+                        spend?: readonly {
+                            limit: bigint;
+                            period: "minute" | "hour" | "day" | "week" | "month" | "year";
+                            token?: `0x${string}` | undefined;
+                        }[] | undefined;
+                    } | undefined;
+                    chainId?: number | undefined;
+                    prehash?: boolean | undefined | undefined;
+                    privateKey?: (() => Hex.Hex) | undefined;
+                } | {
+                    expiry: number;
+                    hash: `0x${string}`;
+                    id: `0x${string}`;
+                    publicKey: `0x${string}`;
+                    role: "admin" | "session";
+                    type: "secp256k1";
+                    feeToken?: {
+                        limit: `${number}` | `${number}.${number}`;
+                        symbol?: string | undefined;
+                    } | null | undefined;
+                    permissions?: {
+                        calls?: readonly ({
+                            signature: string;
+                            to: `0x${string}`;
+                        } | {
+                            signature: string;
+                            to?: undefined;
+                        } | {
+                            to: `0x${string}`;
+                            signature?: undefined;
+                        })[] | undefined;
+                        signatureVerification?: {
+                            addresses: readonly `0x${string}`[];
+                        } | undefined;
+                        spend?: readonly {
+                            limit: bigint;
+                            period: "minute" | "hour" | "day" | "week" | "month" | "year";
+                            token?: `0x${string}` | undefined;
+                        }[] | undefined;
+                    } | undefined;
+                    chainId?: number | undefined;
+                    prehash?: boolean | undefined | undefined;
+                    privateKey?: (() => Hex.Hex) | undefined;
+                } | {
+                    expiry: number;
+                    hash: `0x${string}`;
+                    id: `0x${string}`;
+                    publicKey: `0x${string}`;
+                    role: "admin" | "session";
+                    type: "p256";
+                    feeToken?: {
+                        limit: `${number}` | `${number}.${number}`;
+                        symbol?: string | undefined;
+                    } | null | undefined;
+                    permissions?: {
+                        calls?: readonly ({
+                            signature: string;
+                            to: `0x${string}`;
+                        } | {
+                            signature: string;
+                            to?: undefined;
+                        } | {
+                            to: `0x${string}`;
+                            signature?: undefined;
+                        })[] | undefined;
+                        signatureVerification?: {
+                            addresses: readonly `0x${string}`[];
+                        } | undefined;
+                        spend?: readonly {
+                            limit: bigint;
+                            period: "minute" | "hour" | "day" | "week" | "month" | "year";
+                            token?: `0x${string}` | undefined;
+                        }[] | undefined;
+                    } | undefined;
+                    chainId?: number | undefined;
+                    prehash?: boolean | undefined | undefined;
+                    privateKey?: CryptoKey | undefined;
+                } | {
+                    expiry: number;
+                    hash: `0x${string}`;
+                    id: `0x${string}`;
+                    publicKey: `0x${string}`;
+                    role: "admin" | "session";
+                    type: "webauthn-p256";
+                    feeToken?: {
+                        limit: `${number}` | `${number}.${number}`;
+                        symbol?: string | undefined;
+                    } | null | undefined;
+                    permissions?: {
+                        calls?: readonly ({
+                            signature: string;
+                            to: `0x${string}`;
+                        } | {
+                            signature: string;
+                            to?: undefined;
+                        } | {
+                            to: `0x${string}`;
+                            signature?: undefined;
+                        })[] | undefined;
+                        signatureVerification?: {
+                            addresses: readonly `0x${string}`[];
+                        } | undefined;
+                        spend?: readonly {
+                            limit: bigint;
+                            period: "minute" | "hour" | "day" | "week" | "month" | "year";
+                            token?: `0x${string}` | undefined;
+                        }[] | undefined;
+                    } | undefined;
+                    chainId?: number | undefined;
+                    prehash?: boolean | undefined | undefined;
+                    privateKey?: OneOf<{
+                        credential: Pick<import("ox/WebAuthnP256").P256Credential, "id" | "publicKey">;
+                        rpId: string | undefined;
+                    } | {
+                        privateKey: () => Hex.Hex;
+                    }> | undefined;
+                };
+            }>;
+            readonly grantPermissions: (parameters: {
+                account: Account.Account;
+                internal: Mode.ActionsInternal;
+                permissions?: import("./internal/permissionsRequest.js").PermissionsRequest | undefined;
+            }) => Promise<{
+                key: import("../viem/Key.js").Key;
+            }>;
+            readonly loadAccounts: (parameters: {
+                address?: Hex.Hex | undefined;
+                key?: {
+                    credentialId?: string | undefined;
+                    publicKey: Hex.Hex;
+                } | undefined;
+                internal: Mode.ActionsInternal;
+                permissions?: import("./internal/permissionsRequest.js").PermissionsRequest | undefined;
+                signInWithEthereum?: import("./internal/schema/capabilities.js").signInWithEthereum.Request | undefined;
+            }) => Promise<{
+                accounts: {
+                    signInWithEthereum: {
+                        message: string;
+                        signature: `0x${string}`;
+                    } | undefined;
+                    address: import("viem").Address;
+                    nonceManager?: import("viem").NonceManager | undefined;
+                    sign: (parameters: {
+                        hash: import("viem").Hash;
+                    }) => Promise<import("viem").Hex>;
+                    signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined;
+                    signMessage: ({ message }: {
+                        message: import("viem").SignableMessage;
+                    }) => Promise<import("viem").Hex>;
+                    signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+                        serializer?: serializer | undefined;
+                    } | undefined) => Promise<import("viem").Hex>;
+                    signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
+                    publicKey: import("viem").Hex;
+                    source: "porto";
+                    type: "local";
+                    keys: import("../viem/Key.js").Key[];
+                }[];
+            }>;
+            readonly prepareCalls: (parameters: {
+                account: Account.Account;
+                calls: readonly import("./internal/call.js").Call[];
+                key?: Pick<import("../viem/Key.js").Key, "prehash" | "publicKey" | "type"> | undefined;
+                feeToken?: Token.Symbol | Address.Address | undefined;
+                internal: Mode.ActionsInternal;
+                merchantUrl?: string | undefined;
+                requiredFunds?: import("./RpcSchema.js").wallet_prepareCalls.Capabilities["requiredFunds"] | undefined;
+            }) => Promise<{
+                account: Account.Account<"porto" | "privateKey">;
+                capabilities: {
+                    quote: any;
+                    assetDiffs?: Record<`0x${string}`, readonly (readonly [`0x${string}`, readonly ({
+                        direction: "incoming" | "outgoing";
+                        symbol: string;
+                        type: "erc20";
+                        value: bigint;
+                        address?: `0x${string}` | null | undefined;
+                        decimals?: number | null | undefined;
+                        fiat?: {
+                            currency: string;
+                            value: number;
+                        } | undefined;
+                        name?: string | null | undefined;
+                    } | {
+                        direction: "incoming" | "outgoing";
+                        symbol: string;
+                        type: "erc721";
+                        uri: string;
+                        value: bigint;
+                        address?: `0x${string}` | null | undefined;
+                        fiat?: {
+                            currency: string;
+                            value: number;
+                        } | undefined;
+                        name?: string | null | undefined;
+                    } | {
+                        address: null;
+                        direction: "incoming" | "outgoing";
+                        symbol: string;
+                        type: null;
+                        value: bigint;
+                        decimals?: number | null | undefined;
+                        fiat?: {
+                            currency: string;
+                            value: number;
+                        } | undefined;
+                    })[]])[]> | undefined;
+                    authorizeKeys?: readonly {
+                        hash: `0x${string}`;
+                        permissions: readonly ({
+                            selector: `0x${string}`;
+                            to: `0x${string}`;
+                            type: "call";
+                        } | {
+                            limit: bigint;
+                            period: "minute" | "hour" | "day" | "week" | "month" | "year";
+                            type: "spend";
+                            token?: `0x${string}` | null | undefined;
+                        })[];
+                        expiry: number;
+                        publicKey: `0x${string}`;
+                        role: "admin" | "normal";
+                        type: "p256" | "secp256k1" | "webauthnp256";
+                        prehash?: boolean | undefined;
+                    }[] | null | undefined;
+                    feePayerDigest?: `0x${string}` | undefined;
+                    feeSignature?: `0x${string}` | undefined;
+                    feeTotals?: Record<`0x${string}`, {
+                        currency: string;
+                        value: string;
+                    }> | undefined;
+                    revokeKeys?: readonly {
+                        hash: `0x${string}`;
+                    }[] | null | undefined;
+                };
+                chainId: number;
+                context: {
+                    account: Account.Account<"porto" | "privateKey">;
+                    calls: readonly import("./internal/call.js").Call[];
+                    nonce: bigint | undefined;
+                    preCall?: {
+                        chainId?: number | undefined;
+                        eoa?: `0x${string}` | undefined;
+                        executionData?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        signature?: `0x${string}` | undefined;
+                    } | undefined;
+                    quote?: {
+                        hash?: `0x${string}` | undefined;
+                        r?: `0x${string}` | undefined;
+                        s?: `0x${string}` | undefined;
+                        v?: `0x${string}` | undefined;
+                        yParity?: `0x${string}` | undefined;
+                        multiChainRoot?: `0x${string}` | null | undefined;
+                        quotes?: readonly {
+                            chainId: number;
+                            ethPrice: bigint;
+                            extraPayment: bigint;
+                            feeTokenDeficit: bigint;
+                            intent: {
+                                combinedGas: bigint;
+                                encodedFundTransfers: readonly `0x${string}`[];
+                                encodedPreCalls: readonly `0x${string}`[];
+                                eoa: `0x${string}`;
+                                executionData: `0x${string}`;
+                                expiry: bigint;
+                                funder: `0x${string}`;
+                                funderSignature: `0x${string}`;
+                                isMultichain: boolean;
+                                nonce: bigint;
+                                payer: `0x${string}`;
+                                paymentAmount: bigint;
+                                paymentMaxAmount: bigint;
+                                paymentRecipient: `0x${string}`;
+                                paymentSignature: `0x${string}`;
+                                paymentToken: `0x${string}`;
+                                settler: `0x${string}`;
+                                settlerContext: `0x${string}`;
+                                signature: `0x${string}`;
+                                supportedAccountImplementation: `0x${string}`;
+                            } | {
+                                combinedGas: bigint;
+                                encodedFundTransfers: readonly `0x${string}`[];
+                                encodedPreCalls: readonly `0x${string}`[];
+                                eoa: `0x${string}`;
+                                executionData: `0x${string}`;
+                                expiry: bigint;
+                                funder: `0x${string}`;
+                                funderSignature: `0x${string}`;
+                                isMultichain: boolean;
+                                nonce: bigint;
+                                payer: `0x${string}`;
+                                paymentRecipient: `0x${string}`;
+                                paymentSignature: `0x${string}`;
+                                paymentToken: `0x${string}`;
+                                prePaymentAmount: bigint;
+                                prePaymentMaxAmount: bigint;
+                                settler: `0x${string}`;
+                                settlerContext: `0x${string}`;
+                                signature: `0x${string}`;
+                                supportedAccountImplementation: `0x${string}`;
+                                totalPaymentAmount: bigint;
+                                totalPaymentMaxAmount: bigint;
+                            };
+                            nativeFeeEstimate: {
+                                maxFeePerGas: bigint;
+                                maxPriorityFeePerGas: bigint;
+                            };
+                            orchestrator: `0x${string}`;
+                            paymentTokenDecimals: number;
+                            txGas: bigint;
+                            additionalAuthorization?: {
+                                address: `0x${string}`;
+                                chainId: number;
+                                nonce: number;
+                                r: `0x${string}`;
+                                s: `0x${string}`;
+                                yParity: number;
+                            } | null | undefined;
+                            assetDeficits?: {
+                                address: `0x${string}` | null;
+                                deficit: bigint;
+                                required: bigint;
+                                decimals?: number | undefined;
+                                fiat?: {
+                                    currency: string;
+                                    value: string;
+                                } | undefined;
+                                name?: string | undefined;
+                                symbol?: string | undefined;
+                            }[] | undefined;
+                            authorizationAddress?: `0x${string}` | null | undefined;
+                        }[] | undefined;
+                        ttl?: number | undefined;
+                    } | undefined;
+                };
+                digest: `0x${string}`;
+                key: Pick<import("../viem/Key.js").Key, "publicKey" | "type" | "prehash">;
+                typedData: {
+                    domain: Record<string, never> | {
+                        chainId: number;
+                        name: string;
+                        verifyingContract: `0x${string}`;
+                        version: string;
+                    };
+                    message: Record<string, unknown>;
+                    primaryType: string;
+                    types: Record<string, unknown>;
+                };
+            }>;
+            readonly prepareUpgradeAccount: (parameters: {
+                address: Address.Address;
+                email?: boolean | undefined;
+                label?: string | undefined;
+                internal: Mode.ActionsInternal;
+                permissions?: import("./internal/permissionsRequest.js").PermissionsRequest | undefined;
+            }) => Promise<{
+                context: {
+                    address: `0x${string}`;
+                    authorization: {
+                        address: `0x${string}`;
+                        chainId: number;
+                        nonce: number;
+                    };
+                    chainId: number;
+                    preCall: {
+                        eoa: `0x${string}`;
+                        executionData: `0x${string}`;
+                        nonce: `0x${string}`;
+                        signature: `0x${string}`;
+                    };
+                } & {
+                    account: Account.Account;
+                };
+                digests: {
+                    auth: `0x${string}`;
+                    exec: `0x${string}`;
+                };
+            }>;
+            readonly revokeAdmin: (parameters: {
+                account: Account.Account;
+                feeToken?: Token.Symbol | Address.Address | undefined;
+                id: Hex.Hex;
+                internal: Mode.ActionsInternal;
+            }) => Promise<void>;
+            readonly revokePermissions: (parameters: {
+                account: Account.Account;
+                feeToken?: Token.Symbol | Address.Address | undefined;
+                id: Hex.Hex;
+                internal: Mode.ActionsInternal;
+            }) => Promise<void>;
+            readonly sendCalls: (parameters: {
+                account: Account.Account;
+                asTxHash?: boolean | undefined;
+                calls: readonly import("./internal/call.js").Call[];
+                feeToken?: Token.Symbol | Address.Address | undefined;
+                internal: Mode.ActionsInternal;
+                requiredFunds?: import("./RpcSchema.js").wallet_prepareCalls.Capabilities["requiredFunds"] | undefined;
+                permissionsId?: Hex.Hex | null | undefined;
+                merchantUrl?: string | undefined;
+            }) => Promise<{
+                id: `0x${string}`;
+            }>;
+            readonly sendPreparedCalls: (parameters: {
+                account: Account.Account;
+                context: {
+                    [key: string]: unknown;
+                    calls?: readonly import("./internal/call.js").Call[] | undefined;
+                    nonce?: bigint | undefined;
+                };
+                key: Pick<import("../viem/Key.js").Key, "prehash" | "publicKey" | "type">;
+                signature: Hex.Hex;
+                internal: Mode.ActionsInternal;
+            }) => Promise<`0x${string}`>;
+            readonly signPersonalMessage: (parameters: {
+                account: Account.Account;
+                data: Hex.Hex;
+                internal: Mode.ActionsInternal;
+            }) => Promise<`0x${string}`>;
+            readonly signTypedData: (parameters: {
+                account: Account.Account;
+                data: string;
+                internal: Mode.ActionsInternal;
+            }) => Promise<`0x${string}`>;
+            readonly upgradeAccount: (parameters: {
+                account: Account.Account;
+                context: unknown;
+                internal: Mode.ActionsInternal;
+                signatures: {
+                    auth: Hex.Hex;
+                    exec: Hex.Hex;
+                };
+            }) => Promise<{
+                account: Account.Account<"porto" | "privateKey">;
+            }>;
+            readonly verifyEmail: (parameters: {
+                account: Account.Account;
+                chainId: number;
+                email: string;
+                token: string;
+                walletAddress: Address.Address;
+                internal: Mode.ActionsInternal;
+            }) => Promise<null>;
+        };
+        readonly config: relay.Parameters;
+        readonly name: "rpc";
+    }> | import("./internal/types.js").Assign<Mode.Mode, {
+        readonly actions: {
+            readonly addFunds: (parameters: {
+                address: Address.Address;
+                internal: Mode.ActionsInternal;
+                token?: Address.Address | undefined;
+                value?: string | undefined;
+            }) => Promise<{
+                id: `0x${string}`;
+            }>;
+            readonly createAccount: (parameters: {
+                admins?: readonly Pick<import("../viem/Key.js").Key, "publicKey" | "type">[] | undefined;
+                email?: boolean | undefined;
+                internal: Mode.ActionsInternal;
+                label?: string | undefined;
+                permissions?: import("./internal/permissionsRequest.js").PermissionsRequest | undefined;
+                signInWithEthereum?: import("./internal/schema/capabilities.js").signInWithEthereum.Request | undefined;
+            }) => Promise<{
+                account: {
+                    signInWithEthereum: {
+                        message: string;
+                        signature: `0x${string}`;
+                        token?: never;
+                    } | {
+                        message: string;
+                        signature: `0x${string}`;
+                        token: string | undefined;
+                    } | undefined;
+                    address: import("viem").Address;
+                    nonceManager?: import("viem").NonceManager | undefined;
+                    sign: (parameters: {
+                        hash: import("viem").Hash;
+                    }) => Promise<import("viem").Hex>;
+                    signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined;
+                    signMessage: ({ message }: {
+                        message: import("viem").SignableMessage;
+                    }) => Promise<import("viem").Hex>;
+                    signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+                        serializer?: serializer | undefined;
+                    } | undefined) => Promise<import("viem").Hex>;
+                    signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
+                    publicKey: import("viem").Hex;
+                    source: "porto";
+                    type: "local";
+                    keys: readonly import("../viem/Key.js").Key[];
+                };
+            }>;
+            readonly disconnect: (parameters: {
+                internal: Mode.ActionsInternal;
+            }) => Promise<void>;
+            readonly getAccountVersion: (parameters: {
+                address: Address.Address;
+                internal: Mode.ActionsInternal;
+            }) => Promise<{
+                current: string;
+                latest: string;
+            }>;
+            readonly getAssets: (parameters: {
+                account: `0x${string}`;
+                assetFilter?: Record<`0x${string}`, readonly {
+                    address: `0x${string}` | "native";
+                    type: string;
+                }[]> | undefined;
+                assetTypeFilter?: readonly string[] | undefined;
+                chainFilter?: readonly number[] | undefined;
+            } & {
+                internal: Mode.ActionsInternal;
+            }) => Promise<Record<string, readonly ({
+                address: `0x${string}`;
+                balance: bigint;
+                metadata: {
+                    decimals: number;
+                    name: string;
+                    symbol: string;
+                    fiat?: {
+                        currency: string;
+                        value: number;
+                    } | null | undefined;
+                } | null;
+                type: "erc20";
+            } | {
+                address: "native" | null;
+                balance: bigint;
+                metadata: {
+                    decimals: number;
+                    fiat?: {
+                        currency: string;
+                        value: number;
+                    } | null | undefined;
+                    name?: string | undefined;
+                    symbol?: string | undefined;
+                } | null;
+                type: "native";
+            })[]>>;
+            readonly getCallsStatus: (parameters: {
+                id: Hex.Hex;
+                internal: Mode.ActionsInternal;
+            }) => Promise<{
+                atomic: boolean;
+                chainId: `0x${string}`;
+                id: string;
+                status: number;
+                version: string;
+                receipts?: readonly {
+                    blockHash: `0x${string}`;
+                    blockNumber: `0x${string}`;
+                    gasUsed: `0x${string}`;
+                    logs: readonly {
+                        address: `0x${string}`;
+                        data: `0x${string}`;
+                        topics: readonly `0x${string}`[];
+                    }[];
+                    status: `0x${string}`;
+                    transactionHash: `0x${string}`;
+                }[] | undefined;
+            }>;
+            readonly getCapabilities: (parameters: {
+                chainIds?: readonly Hex.Hex[] | undefined;
+                internal: Mode.ActionsInternal;
+            }) => Promise<Record<`0x${string}`, {
+                atomic: {
+                    status: "supported" | "unsupported";
+                };
+                feeToken: {
+                    supported: boolean;
+                    tokens: readonly {
+                        address: `0x${string}`;
+                        decimals: number;
+                        symbol: string;
+                        uid: string;
+                        feeToken?: boolean | undefined;
+                        interop?: boolean | undefined;
+                        nativeRate?: `0x${string}` | undefined;
+                    }[];
+                };
+                merchant: {
+                    supported: boolean;
+                };
+                permissions: {
+                    supported: boolean;
+                };
+                requiredFunds: {
+                    supported: boolean;
+                    tokens: readonly {
+                        address: `0x${string}`;
+                        decimals: number;
+                        symbol: string;
+                        uid: string;
+                        feeToken?: boolean | undefined;
+                        interop?: boolean | undefined;
+                        nativeRate?: `0x${string}` | undefined;
+                    }[];
+                };
+            }> | Record<`0x${string}`, {
+                readonly atomic: {
+                    readonly status: "supported";
+                };
+                readonly atomicBatch: {
+                    readonly supported: true;
+                };
+                readonly feeToken: {
+                    readonly supported: true;
+                    readonly tokens: readonly [];
+                };
+                readonly merchant: {
+                    readonly supported: true;
+                };
+                readonly permissions: {
+                    readonly supported: true;
+                };
+                readonly requiredFunds: {
+                    readonly supported: boolean;
+                    readonly tokens: readonly [];
+                };
+            }>>;
+            readonly getKeys: (parameters: {
+                account: Account.Account;
+                chainIds?: readonly number[] | undefined;
+                internal: Mode.ActionsInternal;
+            }) => Promise<{
+                expiry: number;
+                hash: `0x${string}`;
+                id: `0x${string}`;
+                publicKey: `0x${string}`;
+                role: "admin" | "session";
+                type: "address" | "p256" | "secp256k1" | "webauthn-p256";
+                feeToken?: {
+                    limit: `${number}` | `${number}.${number}`;
+                    symbol?: string | undefined;
+                } | null | undefined;
+                permissions?: {
+                    calls?: readonly ({
+                        signature: string;
+                        to: `0x${string}`;
+                    } | {
+                        signature: string;
+                        to?: undefined;
+                    } | {
+                        to: `0x${string}`;
+                        signature?: undefined;
+                    })[] | undefined;
+                    signatureVerification?: {
+                        addresses: readonly `0x${string}`[];
+                    } | undefined;
+                    spend?: readonly {
+                        limit: bigint;
+                        period: "minute" | "hour" | "day" | "week" | "month" | "year";
+                        token?: `0x${string}` | undefined;
+                    }[] | undefined;
+                } | undefined;
+                chainId?: number | undefined;
+                prehash?: boolean | undefined;
+            }[]>;
+            readonly grantAdmin: (parameters: {
+                account: Account.Account;
+                internal: Mode.ActionsInternal;
+                feeToken?: Token.Symbol | Address.Address | undefined;
+                key: import("../viem/Key.js").from.Value;
+            }) => Promise<{
+                key: {
+                    expiry: number;
+                    hash: `0x${string}`;
+                    id: `0x${string}`;
+                    publicKey: `0x${string}`;
+                    role: "admin" | "session";
+                    type: "address";
+                    feeToken?: {
+                        limit: `${number}` | `${number}.${number}`;
+                        symbol?: string | undefined;
+                    } | null | undefined;
+                    permissions?: {
+                        calls?: readonly ({
+                            signature: string;
+                            to: `0x${string}`;
+                        } | {
+                            signature: string;
+                            to?: undefined;
+                        } | {
+                            to: `0x${string}`;
+                            signature?: undefined;
+                        })[] | undefined;
+                        signatureVerification?: {
+                            addresses: readonly `0x${string}`[];
+                        } | undefined;
+                        spend?: readonly {
+                            limit: bigint;
+                            period: "minute" | "hour" | "day" | "week" | "month" | "year";
+                            token?: `0x${string}` | undefined;
+                        }[] | undefined;
+                    } | undefined;
+                    chainId?: number | undefined;
+                    prehash?: boolean | undefined | undefined;
+                    privateKey?: unknown;
+                } | {
+                    expiry: number;
+                    hash: `0x${string}`;
+                    id: `0x${string}`;
+                    publicKey: `0x${string}`;
+                    role: "admin" | "session";
+                    type: "p256";
+                    feeToken?: {
+                        limit: `${number}` | `${number}.${number}`;
+                        symbol?: string | undefined;
+                    } | null | undefined;
+                    permissions?: {
+                        calls?: readonly ({
+                            signature: string;
+                            to: `0x${string}`;
+                        } | {
+                            signature: string;
+                            to?: undefined;
+                        } | {
+                            to: `0x${string}`;
+                            signature?: undefined;
+                        })[] | undefined;
+                        signatureVerification?: {
+                            addresses: readonly `0x${string}`[];
+                        } | undefined;
+                        spend?: readonly {
+                            limit: bigint;
+                            period: "minute" | "hour" | "day" | "week" | "month" | "year";
+                            token?: `0x${string}` | undefined;
+                        }[] | undefined;
+                    } | undefined;
+                    chainId?: number | undefined;
+                    prehash?: boolean | undefined | undefined;
+                    privateKey?: (() => Hex.Hex) | undefined;
+                } | {
+                    expiry: number;
+                    hash: `0x${string}`;
+                    id: `0x${string}`;
+                    publicKey: `0x${string}`;
+                    role: "admin" | "session";
+                    type: "secp256k1";
+                    feeToken?: {
+                        limit: `${number}` | `${number}.${number}`;
+                        symbol?: string | undefined;
+                    } | null | undefined;
+                    permissions?: {
+                        calls?: readonly ({
+                            signature: string;
+                            to: `0x${string}`;
+                        } | {
+                            signature: string;
+                            to?: undefined;
+                        } | {
+                            to: `0x${string}`;
+                            signature?: undefined;
+                        })[] | undefined;
+                        signatureVerification?: {
+                            addresses: readonly `0x${string}`[];
+                        } | undefined;
+                        spend?: readonly {
+                            limit: bigint;
+                            period: "minute" | "hour" | "day" | "week" | "month" | "year";
+                            token?: `0x${string}` | undefined;
+                        }[] | undefined;
+                    } | undefined;
+                    chainId?: number | undefined;
+                    prehash?: boolean | undefined | undefined;
+                    privateKey?: (() => Hex.Hex) | undefined;
+                } | {
+                    expiry: number;
+                    hash: `0x${string}`;
+                    id: `0x${string}`;
+                    publicKey: `0x${string}`;
+                    role: "admin" | "session";
+                    type: "p256";
+                    feeToken?: {
+                        limit: `${number}` | `${number}.${number}`;
+                        symbol?: string | undefined;
+                    } | null | undefined;
+                    permissions?: {
+                        calls?: readonly ({
+                            signature: string;
+                            to: `0x${string}`;
+                        } | {
+                            signature: string;
+                            to?: undefined;
+                        } | {
+                            to: `0x${string}`;
+                            signature?: undefined;
+                        })[] | undefined;
+                        signatureVerification?: {
+                            addresses: readonly `0x${string}`[];
+                        } | undefined;
+                        spend?: readonly {
+                            limit: bigint;
+                            period: "minute" | "hour" | "day" | "week" | "month" | "year";
+                            token?: `0x${string}` | undefined;
+                        }[] | undefined;
+                    } | undefined;
+                    chainId?: number | undefined;
+                    prehash?: boolean | undefined | undefined;
+                    privateKey?: CryptoKey | undefined;
+                } | {
+                    expiry: number;
+                    hash: `0x${string}`;
+                    id: `0x${string}`;
+                    publicKey: `0x${string}`;
+                    role: "admin" | "session";
+                    type: "webauthn-p256";
+                    feeToken?: {
+                        limit: `${number}` | `${number}.${number}`;
+                        symbol?: string | undefined;
+                    } | null | undefined;
+                    permissions?: {
+                        calls?: readonly ({
+                            signature: string;
+                            to: `0x${string}`;
+                        } | {
+                            signature: string;
+                            to?: undefined;
+                        } | {
+                            to: `0x${string}`;
+                            signature?: undefined;
+                        })[] | undefined;
+                        signatureVerification?: {
+                            addresses: readonly `0x${string}`[];
+                        } | undefined;
+                        spend?: readonly {
+                            limit: bigint;
+                            period: "minute" | "hour" | "day" | "week" | "month" | "year";
+                            token?: `0x${string}` | undefined;
+                        }[] | undefined;
+                    } | undefined;
+                    chainId?: number | undefined;
+                    prehash?: boolean | undefined | undefined;
+                    privateKey?: OneOf<{
+                        credential: Pick<import("ox/WebAuthnP256").P256Credential, "id" | "publicKey">;
+                        rpId: string | undefined;
+                    } | {
+                        privateKey: () => Hex.Hex;
+                    }> | undefined;
+                };
+            }>;
+            readonly grantPermissions: (parameters: {
+                account: Account.Account;
+                internal: Mode.ActionsInternal;
+                permissions?: import("./internal/permissionsRequest.js").PermissionsRequest | undefined;
+            }) => Promise<{
+                key: import("../viem/Key.js").Key;
+            }>;
+            readonly loadAccounts: (parameters: {
+                address?: Hex.Hex | undefined;
+                key?: {
+                    credentialId?: string | undefined;
+                    publicKey: Hex.Hex;
+                } | undefined;
+                internal: Mode.ActionsInternal;
+                permissions?: import("./internal/permissionsRequest.js").PermissionsRequest | undefined;
+                signInWithEthereum?: import("./internal/schema/capabilities.js").signInWithEthereum.Request | undefined;
+            }) => Promise<{
+                accounts: {
+                    readonly signInWithEthereum: {
+                        message: string;
+                        signature: `0x${string}`;
+                        token?: never;
+                    } | {
+                        message: string;
+                        signature: `0x${string}`;
+                        token: string | undefined;
+                    } | undefined;
+                    readonly address: import("viem").Address;
+                    readonly nonceManager?: import("viem").NonceManager | undefined;
+                    readonly sign: (parameters: {
+                        hash: import("viem").Hash;
+                    }) => Promise<import("viem").Hex>;
+                    readonly signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
+                    readonly signMessage: ({ message }: {
+                        message: import("viem").SignableMessage;
+                    }) => Promise<import("viem").Hex>;
+                    readonly signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+                        serializer?: serializer | undefined;
+                    } | undefined) => Promise<import("viem").Hex>;
+                    readonly signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
+                    readonly publicKey: import("viem").Hex;
+                    readonly source: "porto";
+                    readonly type: "local";
+                    readonly keys: readonly import("../viem/Key.js").Key[];
+                }[];
+            }>;
+            readonly prepareCalls: (parameters: {
+                account: Account.Account;
+                calls: readonly import("./internal/call.js").Call[];
+                key?: Pick<import("../viem/Key.js").Key, "prehash" | "publicKey" | "type"> | undefined;
+                feeToken?: Token.Symbol | Address.Address | undefined;
+                internal: Mode.ActionsInternal;
+                merchantUrl?: string | undefined;
+                requiredFunds?: import("./RpcSchema.js").wallet_prepareCalls.Capabilities["requiredFunds"] | undefined;
+            }) => Promise<{
+                account: Account.Account;
+                chainId?: number | undefined;
+                capabilities?: import("./RpcSchema.js").wallet_prepareCalls.Response["capabilities"] | undefined;
+                context: {
+                    [key: string]: unknown;
+                    calls?: readonly import("./internal/call.js").Call[] | undefined;
+                    nonce?: bigint | undefined;
+                };
+                digest: Hex.Hex;
+                key: Pick<import("../viem/Key.js").Key, "prehash" | "publicKey" | "type">;
+                typedData: import("./RpcSchema.js").wallet_prepareCalls.Response["typedData"];
+            } | {
+                account: Account.Account<"porto" | "privateKey">;
+                capabilities: {
+                    quote: any;
+                    assetDiffs?: Record<`0x${string}`, readonly (readonly [`0x${string}`, readonly ({
+                        direction: "incoming" | "outgoing";
+                        symbol: string;
+                        type: "erc20";
+                        value: bigint;
+                        address?: `0x${string}` | null | undefined;
+                        decimals?: number | null | undefined;
+                        fiat?: {
+                            currency: string;
+                            value: number;
+                        } | undefined;
+                        name?: string | null | undefined;
+                    } | {
+                        direction: "incoming" | "outgoing";
+                        symbol: string;
+                        type: "erc721";
+                        uri: string;
+                        value: bigint;
+                        address?: `0x${string}` | null | undefined;
+                        fiat?: {
+                            currency: string;
+                            value: number;
+                        } | undefined;
+                        name?: string | null | undefined;
+                    } | {
+                        address: null;
+                        direction: "incoming" | "outgoing";
+                        symbol: string;
+                        type: null;
+                        value: bigint;
+                        decimals?: number | null | undefined;
+                        fiat?: {
+                            currency: string;
+                            value: number;
+                        } | undefined;
+                    })[]])[]> | undefined;
+                    authorizeKeys?: readonly {
+                        hash: `0x${string}`;
+                        permissions: readonly ({
+                            selector: `0x${string}`;
+                            to: `0x${string}`;
+                            type: "call";
+                        } | {
+                            limit: bigint;
+                            period: "minute" | "hour" | "day" | "week" | "month" | "year";
+                            type: "spend";
+                            token?: `0x${string}` | null | undefined;
+                        })[];
+                        expiry: number;
+                        publicKey: `0x${string}`;
+                        role: "admin" | "normal";
+                        type: "p256" | "secp256k1" | "webauthnp256";
+                        prehash?: boolean | undefined;
+                    }[] | null | undefined;
+                    feePayerDigest?: `0x${string}` | undefined;
+                    feeSignature?: `0x${string}` | undefined;
+                    feeTotals?: Record<`0x${string}`, {
+                        currency: string;
+                        value: string;
+                    }> | undefined;
+                    revokeKeys?: readonly {
+                        hash: `0x${string}`;
+                    }[] | null | undefined;
+                };
+                chainId: number;
+                context: {
+                    account: Account.Account<"porto" | "privateKey">;
+                    calls: readonly import("./internal/call.js").Call[];
+                    nonce: bigint | undefined;
+                    preCall?: {
+                        chainId?: number | undefined;
+                        eoa?: `0x${string}` | undefined;
+                        executionData?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        signature?: `0x${string}` | undefined;
+                    } | undefined;
+                    quote?: {
+                        hash?: `0x${string}` | undefined;
+                        r?: `0x${string}` | undefined;
+                        s?: `0x${string}` | undefined;
+                        v?: `0x${string}` | undefined;
+                        yParity?: `0x${string}` | undefined;
+                        multiChainRoot?: `0x${string}` | null | undefined;
+                        quotes?: readonly {
+                            chainId: number;
+                            ethPrice: bigint;
+                            extraPayment: bigint;
+                            feeTokenDeficit: bigint;
+                            intent: {
+                                combinedGas: bigint;
+                                encodedFundTransfers: readonly `0x${string}`[];
+                                encodedPreCalls: readonly `0x${string}`[];
+                                eoa: `0x${string}`;
+                                executionData: `0x${string}`;
+                                expiry: bigint;
+                                funder: `0x${string}`;
+                                funderSignature: `0x${string}`;
+                                isMultichain: boolean;
+                                nonce: bigint;
+                                payer: `0x${string}`;
+                                paymentAmount: bigint;
+                                paymentMaxAmount: bigint;
+                                paymentRecipient: `0x${string}`;
+                                paymentSignature: `0x${string}`;
+                                paymentToken: `0x${string}`;
+                                settler: `0x${string}`;
+                                settlerContext: `0x${string}`;
+                                signature: `0x${string}`;
+                                supportedAccountImplementation: `0x${string}`;
+                            } | {
+                                combinedGas: bigint;
+                                encodedFundTransfers: readonly `0x${string}`[];
+                                encodedPreCalls: readonly `0x${string}`[];
+                                eoa: `0x${string}`;
+                                executionData: `0x${string}`;
+                                expiry: bigint;
+                                funder: `0x${string}`;
+                                funderSignature: `0x${string}`;
+                                isMultichain: boolean;
+                                nonce: bigint;
+                                payer: `0x${string}`;
+                                paymentRecipient: `0x${string}`;
+                                paymentSignature: `0x${string}`;
+                                paymentToken: `0x${string}`;
+                                prePaymentAmount: bigint;
+                                prePaymentMaxAmount: bigint;
+                                settler: `0x${string}`;
+                                settlerContext: `0x${string}`;
+                                signature: `0x${string}`;
+                                supportedAccountImplementation: `0x${string}`;
+                                totalPaymentAmount: bigint;
+                                totalPaymentMaxAmount: bigint;
+                            };
+                            nativeFeeEstimate: {
+                                maxFeePerGas: bigint;
+                                maxPriorityFeePerGas: bigint;
+                            };
+                            orchestrator: `0x${string}`;
+                            paymentTokenDecimals: number;
+                            txGas: bigint;
+                            additionalAuthorization?: {
+                                address: `0x${string}`;
+                                chainId: number;
+                                nonce: number;
+                                r: `0x${string}`;
+                                s: `0x${string}`;
+                                yParity: number;
+                            } | null | undefined;
+                            assetDeficits?: {
+                                address: `0x${string}` | null;
+                                deficit: bigint;
+                                required: bigint;
+                                decimals?: number | undefined;
+                                fiat?: {
+                                    currency: string;
+                                    value: string;
+                                } | undefined;
+                                name?: string | undefined;
+                                symbol?: string | undefined;
+                            }[] | undefined;
+                            authorizationAddress?: `0x${string}` | null | undefined;
+                        }[] | undefined;
+                        ttl?: number | undefined;
+                    } | undefined;
+                };
+                digest: `0x${string}`;
+                key: Pick<import("../viem/Key.js").Key, "publicKey" | "type" | "prehash">;
+                typedData: {
+                    domain: Record<string, never> | {
+                        chainId: number;
+                        name: string;
+                        verifyingContract: `0x${string}`;
+                        version: string;
+                    };
+                    message: Record<string, unknown>;
+                    primaryType: string;
+                    types: Record<string, unknown>;
+                };
+            } | {
+                account: Account.Account<"porto" | "privateKey">;
+                chainId: number;
+                context: any;
+                digest: `0x${string}`;
+                key: {
+                    publicKey: `0x${string}`;
+                    type: "address" | "p256" | "secp256k1" | "webauthn-p256";
+                    prehash?: boolean | undefined;
+                };
+                typedData: {
+                    domain: {
+                        chainId: number;
+                        name: string;
+                        verifyingContract: `0x${string}`;
+                        version: string;
+                    } | Record<string, never>;
+                    message: Record<string, unknown>;
+                    primaryType: string;
+                    types: Record<string, unknown>;
+                };
+            }>;
+            readonly prepareUpgradeAccount: (parameters: {
+                address: Address.Address;
+                email?: boolean | undefined;
+                label?: string | undefined;
+                internal: Mode.ActionsInternal;
+                permissions?: import("./internal/permissionsRequest.js").PermissionsRequest | undefined;
+            }) => Promise<{
+                digests: {
+                    auth: Hex.Hex;
+                    exec: Hex.Hex;
+                };
+                context: unknown;
+            }>;
+            readonly revokeAdmin: (parameters: {
+                account: Account.Account;
+                feeToken?: Token.Symbol | Address.Address | undefined;
+                id: Hex.Hex;
+                internal: Mode.ActionsInternal;
+            }) => Promise<undefined>;
+            readonly revokePermissions: (parameters: {
+                account: Account.Account;
+                feeToken?: Token.Symbol | Address.Address | undefined;
+                id: Hex.Hex;
+                internal: Mode.ActionsInternal;
+            }) => Promise<undefined>;
+            readonly sendCalls: (parameters: {
+                account: Account.Account;
+                asTxHash?: boolean | undefined;
+                calls: readonly import("./internal/call.js").Call[];
+                feeToken?: Token.Symbol | Address.Address | undefined;
+                internal: Mode.ActionsInternal;
+                requiredFunds?: import("./RpcSchema.js").wallet_prepareCalls.Capabilities["requiredFunds"] | undefined;
+                permissionsId?: Hex.Hex | null | undefined;
+                merchantUrl?: string | undefined;
+            }) => Promise<{
+                id: `0x${string}`;
+            }>;
+            readonly sendPreparedCalls: (parameters: {
+                account: Account.Account;
+                context: {
+                    [key: string]: unknown;
+                    calls?: readonly import("./internal/call.js").Call[] | undefined;
+                    nonce?: bigint | undefined;
+                };
+                key: Pick<import("../viem/Key.js").Key, "prehash" | "publicKey" | "type">;
+                signature: Hex.Hex;
+                internal: Mode.ActionsInternal;
+            }) => Promise<`0x${string}`>;
+            readonly signPersonalMessage: (parameters: {
+                account: Account.Account;
+                data: Hex.Hex;
+                internal: Mode.ActionsInternal;
+            }) => Promise<`0x${string}`>;
+            readonly signTypedData: (parameters: {
+                account: Account.Account;
+                data: string;
+                internal: Mode.ActionsInternal;
+            }) => Promise<`0x${string}`>;
+            readonly switchChain: (parameters: {
+                chainId: number;
+                internal: Mode.ActionsInternal;
+            }) => Promise<undefined>;
+            readonly upgradeAccount: (parameters: {
+                account: Account.Account;
+                context: unknown;
+                internal: Mode.ActionsInternal;
+                signatures: {
+                    auth: Hex.Hex;
+                    exec: Hex.Hex;
+                };
+            }) => Promise<{
+                account: Account.Account<"porto" | "privateKey">;
+            }>;
+            readonly verifyEmail: (parameters: {
+                account: Account.Account;
+                chainId: number;
+                email: string;
+                token: string;
+                walletAddress: Address.Address;
+                internal: Mode.ActionsInternal;
+            }) => Promise<null>;
+        };
+        readonly config: dialog.Parameters;
+        readonly name: "dialog";
+        readonly setup: (parameters: {
+            internal: internal.Internal;
+        }) => () => void;
+    }>;
+    readonly relay: import("viem").HttpTransport<undefined, false>;
+    readonly storage: Storage.Storage;
+    readonly storageKey: "porto.store";
+};
+/**
+ * Instantiates an Porto instance.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Porto } from 'rise-wallet'
+ *
+ * const porto = Porto.create()
+ *
+ * const blockNumber = await porto.provider.request({ method: 'eth_blockNumber' })
+ * ```
+ */
+export declare function create<const chains extends readonly [Chains.Chain, ...Chains.Chain[]]>(parameters?: ExactPartial<Config<chains>> | undefined): RiseWallet<chains>;
+export type Config<chains extends readonly [Chains.Chain, ...Chains.Chain[]] = readonly [
+    Chains.Chain,
+    ...Chains.Chain[]
+]> = {
+    /**
+     * Whether to announce the provider via EIP-6963.
+     * Also accepts EIP-6963 provider info.
+     * @default true
+     */
+    announceProvider: boolean | Partial<Mipd.EIP6963ProviderInfo>;
+    /**
+     * API URL(s) to use for offchain SIWE authentication.
+     */
+    authUrl?: string | Siwe.AuthUrl | undefined;
+    /**
+     * List of supported chains.
+     */
+    chains: chains;
+    /**
+     * Token to use to pay for fees.
+     * @default 'native'
+     */
+    feeToken?: State['feeToken'] | undefined;
+    /**
+     * Mode to use.
+     * @default Mode.dialog()
+     */
+    mode: Mode.Mode | null;
+    /**
+     * URL to use for merchant server.
+     */
+    merchantUrl?: string | undefined;
+    /**
+     * Relay RPC Transport override.
+     */
+    relay: Transport;
+    /**
+     * Storage to use.
+     * @default Storage.idb()
+     */
+    storage: Storage.Storage;
+    /**
+     * Key to use for store.
+     */
+    storageKey?: string | undefined;
+    /**
+     * Public RPC Transport overrides to use for each chain.
+     */
+    transports: Record<chains[number]['id'], Transport>;
+};
+export type RiseWallet<chains extends readonly [Chains.Chain, ...Chains.Chain[]] = readonly [
+    Chains.Chain,
+    ...Chains.Chain[]
+]> = {
+    config: Config<chains>;
+    destroy: () => void;
+    provider: Provider.Provider;
+    /**
+     * Not part of versioned API, proceed with caution.
+     * @deprecated
+     */
+    _internal: internal.Internal<chains>;
+};
+export type State<chains extends readonly [Chains.Chain, ...Chains.Chain[]] = readonly [
+    Chains.Chain,
+    ...Chains.Chain[]
+]> = {
+    accounts: readonly Account.Account[];
+    chainIds: readonly [chains[number]['id'], ...chains[number]['id'][]];
+    feeToken: Token.Symbol | undefined;
+    requestQueue: readonly QueuedRequest[];
+};
+export type Store<chains extends readonly [Chains.Chain, ...Chains.Chain[]] = readonly [
+    Chains.Chain,
+    ...Chains.Chain[]
+]> = Mutate<StoreApi<State<chains>>, [
+    ['zustand/subscribeWithSelector', never],
+    ['zustand/persist', any]
+]>;
+export type QueuedRequest<result = unknown> = {
+    /** Account to assert the request for, and sync if neccessary. */
+    account: {
+        /** Address of the account. */
+        address: Address.Address;
+        /** Active key of the account. */
+        key?: {
+            /** Credential ID. May be `undefined` when the key is not a WebAuthn credential. */
+            credentialId?: string | undefined;
+            /** Public key */
+            publicKey: Hex.Hex;
+        } | undefined;
+    } | undefined;
+    request: RpcRequest.RpcRequest & {
+        _internal?: unknown;
+    };
+} & OneOf<{
+    status: 'pending';
+} | {
+    result: result;
+    status: 'success';
+} | {
+    error: RpcResponse.ErrorObject;
+    status: 'error';
+}>;
+//# sourceMappingURL=Porto.d.ts.map