rise-wallet 0.1.4-beta.2 → 0.2.29

package/dist/remote/Porto.d.ts

@@ -0,0 +1,858 @@
+import type * as RpcRequest from 'ox/RpcRequest';
+import { type StoreApi } from 'zustand/vanilla';
+import type * as Chains from '../core/Chains.js';
+import type { ExactPartial, OneOf } from '../core/internal/types.js';
+import * as Messenger from '../core/Messenger.js';
+import * as Mode from '../core/Mode.js';
+import * as Porto_ from '../core/Porto.js';
+import type * as RpcSchema from '../core/RpcSchema.js';
+import * as Storage from '../core/Storage.js';
+import * as MethodPolicies from './internal/methodPolicies.js';
+export declare const defaultConfig: {
+    readonly messenger: Messenger.Messenger | Messenger.Bridge;
+    readonly methodPolicies: readonly [{
+        readonly method: "eth_requestAccounts";
+        readonly modes: {
+            readonly dialog: true;
+            readonly headless: {
+                readonly sameOrigin: true;
+            };
+        };
+        readonly requireConnection: false;
+    }, {
+        readonly method: "wallet_getAccountVersion";
+        readonly modes: {
+            readonly headless: true;
+        };
+    }, {
+        readonly method: "wallet_getKeys";
+        readonly modes: {
+            readonly headless: true;
+        };
+    }, {
+        readonly method: "wallet_getPermissions";
+        readonly modes: {
+            readonly headless: true;
+        };
+    }, {
+        readonly method: "wallet_grantAdmin";
+        readonly modes: {
+            readonly dialog: {
+                readonly sameOrigin: true;
+            };
+        };
+    }, {
+        readonly method: "wallet_revokeAdmin";
+        readonly modes: {
+            readonly dialog: {
+                readonly sameOrigin: true;
+            };
+        };
+    }, {
+        readonly method: "wallet_upgradeAccount";
+        readonly modes: {
+            readonly headless: true;
+        };
+    }, {
+        readonly method: "wallet_connect";
+        readonly modes: {
+            readonly dialog: true;
+            readonly headless: {
+                sameOrigin: true;
+            } | undefined;
+        };
+        readonly requireConnection: false;
+    }, {
+        readonly method: "wallet_getAssets";
+        readonly modes: {
+            readonly headless: true;
+        };
+    }, {
+        readonly method: "wallet_getCallsStatus";
+        readonly modes: {
+            readonly headless: true;
+        };
+    }, {
+        readonly method: "wallet_getCapabilities";
+        readonly modes: {
+            readonly headless: true;
+        };
+    }, {
+        readonly method: "wallet_prepareCalls";
+        readonly modes: {
+            readonly headless: true;
+        };
+    }, {
+        readonly method: "wallet_sendPreparedCalls";
+        readonly modes: {
+            readonly headless: true;
+        };
+    }, {
+        readonly method: "wallet_switchEthereumChain";
+        readonly modes: {
+            readonly headless: true;
+        };
+    }];
+    readonly mode: import("../core/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: import("../core/internal/mode.js").ActionsInternal;
+                label?: string | undefined;
+                permissions?: import("../core/internal/permissionsRequest.js").PermissionsRequest | undefined;
+                signInWithEthereum?: import("../core/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: import("ox/Address").Address;
+                internal: import("../core/internal/mode.js").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: import("../core/internal/mode.js").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: import("ox/Hex").Hex;
+                internal: import("../core/internal/mode.js").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 import("ox/Hex").Hex[] | undefined;
+                internal: import("../core/internal/mode.js").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: import("../viem/Account.js").Account;
+                chainIds?: readonly number[] | undefined;
+                internal: import("../core/internal/mode.js").ActionsInternal;
+            }) => Promise<import("../viem/Key.js").Key[]>;
+            readonly grantAdmin: (parameters: {
+                account: import("../viem/Account.js").Account;
+                internal: import("../core/internal/mode.js").ActionsInternal;
+                feeToken?: import("../core/internal/schema/token.js").Symbol | import("ox/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?: (() => import("ox/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?: (() => import("ox/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: () => import("ox/Hex").Hex;
+                    }> | undefined;
+                };
+            }>;
+            readonly grantPermissions: (parameters: {
+                account: import("../viem/Account.js").Account;
+                internal: import("../core/internal/mode.js").ActionsInternal;
+                permissions?: import("../core/internal/permissionsRequest.js").PermissionsRequest | undefined;
+            }) => Promise<{
+                key: import("../viem/Key.js").Key;
+            }>;
+            readonly loadAccounts: (parameters: {
+                address?: import("ox/Hex").Hex | undefined;
+                key?: {
+                    credentialId?: string | undefined;
+                    publicKey: import("ox/Hex").Hex;
+                } | undefined;
+                internal: import("../core/internal/mode.js").ActionsInternal;
+                permissions?: import("../core/internal/permissionsRequest.js").PermissionsRequest | undefined;
+                signInWithEthereum?: import("../core/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: import("../viem/Account.js").Account;
+                calls: readonly import("../core/internal/call.js").Call[];
+                key?: Pick<import("../viem/Key.js").Key, "prehash" | "publicKey" | "type"> | undefined;
+                feeToken?: import("../core/internal/schema/token.js").Symbol | import("ox/Address").Address | undefined;
+                internal: import("../core/internal/mode.js").ActionsInternal;
+                merchantUrl?: string | undefined;
+                requiredFunds?: RpcSchema.wallet_prepareCalls.Capabilities["requiredFunds"] | undefined;
+            }) => Promise<{
+                account: import("../viem/Account.js").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: import("../viem/Account.js").Account<"porto" | "privateKey">;
+                    calls: readonly import("../core/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: import("ox/Address").Address;
+                email?: boolean | undefined;
+                label?: string | undefined;
+                internal: import("../core/internal/mode.js").ActionsInternal;
+                permissions?: import("../core/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: import("../viem/Account.js").Account;
+                };
+                digests: {
+                    auth: `0x${string}`;
+                    exec: `0x${string}`;
+                };
+            }>;
+            readonly revokeAdmin: (parameters: {
+                account: import("../viem/Account.js").Account;
+                feeToken?: import("../core/internal/schema/token.js").Symbol | import("ox/Address").Address | undefined;
+                id: import("ox/Hex").Hex;
+                internal: import("../core/internal/mode.js").ActionsInternal;
+            }) => Promise<void>;
+            readonly revokePermissions: (parameters: {
+                account: import("../viem/Account.js").Account;
+                feeToken?: import("../core/internal/schema/token.js").Symbol | import("ox/Address").Address | undefined;
+                id: import("ox/Hex").Hex;
+                internal: import("../core/internal/mode.js").ActionsInternal;
+            }) => Promise<void>;
+            readonly sendCalls: (parameters: {
+                account: import("../viem/Account.js").Account;
+                asTxHash?: boolean | undefined;
+                calls: readonly import("../core/internal/call.js").Call[];
+                feeToken?: import("../core/internal/schema/token.js").Symbol | import("ox/Address").Address | undefined;
+                internal: import("../core/internal/mode.js").ActionsInternal;
+                requiredFunds?: RpcSchema.wallet_prepareCalls.Capabilities["requiredFunds"] | undefined;
+                permissionsId?: import("ox/Hex").Hex | null | undefined;
+                merchantUrl?: string | undefined;
+            }) => Promise<{
+                id: `0x${string}`;
+            }>;
+            readonly sendPreparedCalls: (parameters: {
+                account: import("../viem/Account.js").Account;
+                context: {
+                    [key: string]: unknown;
+                    calls?: readonly import("../core/internal/call.js").Call[] | undefined;
+                    nonce?: bigint | undefined;
+                };
+                key: Pick<import("../viem/Key.js").Key, "prehash" | "publicKey" | "type">;
+                signature: import("ox/Hex").Hex;
+                internal: import("../core/internal/mode.js").ActionsInternal;
+            }) => Promise<`0x${string}`>;
+            readonly signPersonalMessage: (parameters: {
+                account: import("../viem/Account.js").Account;
+                data: import("ox/Hex").Hex;
+                internal: import("../core/internal/mode.js").ActionsInternal;
+            }) => Promise<`0x${string}`>;
+            readonly signTypedData: (parameters: {
+                account: import("../viem/Account.js").Account;
+                data: string;
+                internal: import("../core/internal/mode.js").ActionsInternal;
+            }) => Promise<`0x${string}`>;
+            readonly upgradeAccount: (parameters: {
+                account: import("../viem/Account.js").Account;
+                context: unknown;
+                internal: import("../core/internal/mode.js").ActionsInternal;
+                signatures: {
+                    auth: import("ox/Hex").Hex;
+                    exec: import("ox/Hex").Hex;
+                };
+            }) => Promise<{
+                account: import("../viem/Account.js").Account<"porto" | "privateKey">;
+            }>;
+            readonly verifyEmail: (parameters: {
+                account: import("../viem/Account.js").Account;
+                chainId: number;
+                email: string;
+                token: string;
+                walletAddress: import("ox/Address").Address;
+                internal: import("../core/internal/mode.js").ActionsInternal;
+            }) => Promise<null>;
+        };
+        readonly config: Mode.relay.Parameters;
+        readonly name: "rpc";
+    }>;
+    readonly storage: Storage.Storage;
+    readonly trustedHosts: string[];
+    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: "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;
+    }[]];
+    readonly relay: import("viem").HttpTransport<undefined, false>;
+    readonly storageKey: "porto.store";
+};
+/**
+ * Instantiates an Porto instance to be used in a remote context (e.g. an iframe or popup).
+ *
+ * @example
+ * ```ts twoslash
+ * import { Porto } from 'porto/remote'
+ * const porto = Porto.create()
+ * ```
+ */
+export declare function create<const chains extends readonly [
+    Chains.Chain,
+    ...Chains.Chain[]
+] = typeof defaultConfig.chains>(parameters?: ExactPartial<Config<chains>> | undefined): Porto<chains>;
+export type Porto<chains extends readonly [Chains.Chain, ...Chains.Chain[]] = readonly [
+    Chains.Chain,
+    ...Chains.Chain[]
+]> = Porto_.Porto<chains> & {
+    mode: Mode.Mode;
+    messenger: OneOf<Messenger.WithReady | Messenger.Messenger>;
+    methodPolicies?: MethodPolicies.MethodPolicies | undefined;
+    ready: () => Promise<void>;
+    _internal: Porto_.Porto<chains>['_internal'] & {
+        remoteStore: StoreApi<RemoteState>;
+    };
+};
+export type Config<chains extends readonly [Chains.Chain, ...Chains.Chain[]] = readonly [
+    Chains.Chain,
+    ...Chains.Chain[]
+]> = Porto_.Config<chains> & {
+    messenger?: OneOf<Messenger.Bridge | Messenger.Messenger> | undefined;
+    methodPolicies?: MethodPolicies.MethodPolicies | undefined;
+    trustedHosts?: string[] | undefined;
+};
+export type State<chains extends readonly [Chains.Chain, ...Chains.Chain[]] = readonly [
+    Chains.Chain,
+    ...Chains.Chain[]
+]> = Porto_.State<chains>;
+export type RemoteState = {
+    requests: readonly (Porto_.QueuedRequest & {
+        request: RpcRequest.RpcRequest<RpcSchema.Schema>;
+    })[];
+};
+//# sourceMappingURL=Porto.d.ts.map