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

package/dist/cli/internal/context.d.ts

@@ -0,0 +1,521 @@
+import * as Chains from '../../core/Chains.js';
+import * as WalletClient from '../../viem/WalletClient.js';
+/** Gets a Viem client for Porto Dialog. */
+export declare function getWalletClient(options?: getWalletClient.Options): Promise<WalletClient.WalletClient<import("viem").Transport, {
+    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;
+}, undefined>>;
+export declare namespace getWalletClient {
+    type Options = {
+        /** Dialog hostname. */
+        dialog?: string | undefined;
+    };
+}
+/** Gets a Viem client for Relay. */
+export declare function getRelayClient(options?: getRelayClient.Options): Promise<{
+    account: undefined;
+    batch?: {
+        multicall?: boolean | import("viem").Prettify<import("viem").MulticallBatchOptions> | undefined;
+    } | undefined;
+    cacheTime: number;
+    ccipRead?: false | {
+        request?: (parameters: import("viem").CcipRequestParameters) => Promise<`0x${string}`>;
+    } | undefined;
+    chain: Chains.Chain;
+    experimental_blockTag?: import("viem").BlockTag | undefined;
+    key: string;
+    name: string;
+    pollingInterval: number;
+    request: import("viem").EIP1193RequestFn<[{
+        Method: "web3_clientVersion";
+        Parameters?: undefined;
+        ReturnType: string;
+    }, {
+        Method: "web3_sha3";
+        Parameters: [data: import("viem").Hash];
+        ReturnType: string;
+    }, {
+        Method: "net_listening";
+        Parameters?: undefined;
+        ReturnType: boolean;
+    }, {
+        Method: "net_peerCount";
+        Parameters?: undefined;
+        ReturnType: import("viem").Quantity;
+    }, {
+        Method: "net_version";
+        Parameters?: undefined;
+        ReturnType: import("viem").Quantity;
+    }, {
+        Method: "eth_blobBaseFee";
+        Parameters?: undefined;
+        ReturnType: import("viem").Quantity;
+    }, {
+        Method: "eth_blockNumber";
+        Parameters?: undefined;
+        ReturnType: import("viem").Quantity;
+    }, {
+        Method: "eth_call";
+        Parameters: readonly [transaction: import("viem").ExactPartial<import("viem").RpcTransactionRequest>] | readonly [transaction: import("viem").ExactPartial<import("viem").RpcTransactionRequest>, block: import("viem").RpcBlockNumber | import("viem").BlockTag | import("viem").RpcBlockIdentifier] | readonly [transaction: import("viem").ExactPartial<import("viem").RpcTransactionRequest>, block: import("viem").RpcBlockNumber | import("viem").BlockTag | import("viem").RpcBlockIdentifier, stateOverrideSet: import("viem").RpcStateOverride] | readonly [transaction: import("viem").ExactPartial<import("viem").RpcTransactionRequest>, block: import("viem").RpcBlockNumber | import("viem").BlockTag | import("viem").RpcBlockIdentifier, stateOverrideSet: import("viem").RpcStateOverride, blockOverrides: import("viem").RpcBlockOverrides];
+        ReturnType: import("viem").Hex;
+    }, {
+        Method: "eth_createAccessList";
+        Parameters: [transaction: import("viem").ExactPartial<import("viem").RpcTransactionRequest>] | [transaction: import("viem").ExactPartial<import("viem").RpcTransactionRequest>, block: import("viem").RpcBlockNumber | import("viem").BlockTag | import("viem").RpcBlockIdentifier];
+        ReturnType: {
+            accessList: import("viem").AccessList;
+            gasUsed: import("viem").Quantity;
+        };
+    }, {
+        Method: "eth_chainId";
+        Parameters?: undefined;
+        ReturnType: import("viem").Quantity;
+    }, {
+        Method: "eth_coinbase";
+        Parameters?: undefined;
+        ReturnType: import("viem").Address;
+    }, {
+        Method: "eth_estimateGas";
+        Parameters: [transaction: import("viem").RpcTransactionRequest] | [transaction: import("viem").RpcTransactionRequest, block: import("viem").RpcBlockNumber | import("viem").BlockTag] | [transaction: import("viem").RpcTransactionRequest, block: import("viem").RpcBlockNumber | import("viem").BlockTag, stateOverride: import("viem").RpcStateOverride];
+        ReturnType: import("viem").Quantity;
+    }, {
+        Method: "eth_feeHistory";
+        Parameters: [blockCount: import("viem").Quantity, newestBlock: import("viem").RpcBlockNumber | import("viem").BlockTag, rewardPercentiles: number[] | undefined];
+        ReturnType: import("viem").RpcFeeHistory;
+    }, {
+        Method: "eth_gasPrice";
+        Parameters?: undefined;
+        ReturnType: import("viem").Quantity;
+    }, {
+        Method: "eth_getBalance";
+        Parameters: [address: import("viem").Address, block: import("viem").RpcBlockNumber | import("viem").BlockTag | import("viem").RpcBlockIdentifier];
+        ReturnType: import("viem").Quantity;
+    }, {
+        Method: "eth_getBlockByHash";
+        Parameters: [hash: import("viem").Hash, includeTransactionObjects: boolean];
+        ReturnType: import("viem").RpcBlock | null;
+    }, {
+        Method: "eth_getBlockByNumber";
+        Parameters: [block: import("viem").RpcBlockNumber | import("viem").BlockTag, includeTransactionObjects: boolean];
+        ReturnType: import("viem").RpcBlock | null;
+    }, {
+        Method: "eth_getBlockTransactionCountByHash";
+        Parameters: [hash: import("viem").Hash];
+        ReturnType: import("viem").Quantity;
+    }, {
+        Method: "eth_getBlockTransactionCountByNumber";
+        Parameters: [block: import("viem").RpcBlockNumber | import("viem").BlockTag];
+        ReturnType: import("viem").Quantity;
+    }, {
+        Method: "eth_getCode";
+        Parameters: [address: import("viem").Address, block: import("viem").RpcBlockNumber | import("viem").BlockTag | import("viem").RpcBlockIdentifier];
+        ReturnType: import("viem").Hex;
+    }, {
+        Method: "eth_getFilterChanges";
+        Parameters: [filterId: import("viem").Quantity];
+        ReturnType: import("viem").RpcLog[] | import("viem").Hex[];
+    }, {
+        Method: "eth_getFilterLogs";
+        Parameters: [filterId: import("viem").Quantity];
+        ReturnType: import("viem").RpcLog[];
+    }, {
+        Method: "eth_getLogs";
+        Parameters: [{
+            address?: import("viem").Address | import("viem").Address[] | undefined;
+            topics?: import("viem").LogTopic[] | undefined;
+        } & ({
+            fromBlock?: import("viem").RpcBlockNumber | import("viem").BlockTag | undefined;
+            toBlock?: import("viem").RpcBlockNumber | import("viem").BlockTag | undefined;
+            blockHash?: undefined;
+        } | {
+            fromBlock?: undefined;
+            toBlock?: undefined;
+            blockHash?: import("viem").Hash | undefined;
+        })];
+        ReturnType: import("viem").RpcLog[];
+    }, {
+        Method: "eth_getProof";
+        Parameters: [address: import("viem").Address, storageKeys: import("viem").Hash[], block: import("viem").RpcBlockNumber | import("viem").BlockTag];
+        ReturnType: import("viem").RpcProof;
+    }, {
+        Method: "eth_getStorageAt";
+        Parameters: [address: import("viem").Address, index: import("viem").Quantity, block: import("viem").RpcBlockNumber | import("viem").BlockTag | import("viem").RpcBlockIdentifier];
+        ReturnType: import("viem").Hex;
+    }, {
+        Method: "eth_getTransactionByBlockHashAndIndex";
+        Parameters: [hash: import("viem").Hash, index: import("viem").Quantity];
+        ReturnType: import("viem").RpcTransaction | null;
+    }, {
+        Method: "eth_getTransactionByBlockNumberAndIndex";
+        Parameters: [block: import("viem").RpcBlockNumber | import("viem").BlockTag, index: import("viem").Quantity];
+        ReturnType: import("viem").RpcTransaction | null;
+    }, {
+        Method: "eth_getTransactionByHash";
+        Parameters: [hash: import("viem").Hash];
+        ReturnType: import("viem").RpcTransaction | null;
+    }, {
+        Method: "eth_getTransactionCount";
+        Parameters: [address: import("viem").Address, block: import("viem").RpcBlockNumber | import("viem").BlockTag | import("viem").RpcBlockIdentifier];
+        ReturnType: import("viem").Quantity;
+    }, {
+        Method: "eth_getTransactionReceipt";
+        Parameters: [hash: import("viem").Hash];
+        ReturnType: import("viem").RpcTransactionReceipt | null;
+    }, {
+        Method: "eth_getUncleByBlockHashAndIndex";
+        Parameters: [hash: import("viem").Hash, index: import("viem").Quantity];
+        ReturnType: import("viem").RpcUncle | null;
+    }, {
+        Method: "eth_getUncleByBlockNumberAndIndex";
+        Parameters: [block: import("viem").RpcBlockNumber | import("viem").BlockTag, index: import("viem").Quantity];
+        ReturnType: import("viem").RpcUncle | null;
+    }, {
+        Method: "eth_getUncleCountByBlockHash";
+        Parameters: [hash: import("viem").Hash];
+        ReturnType: import("viem").Quantity;
+    }, {
+        Method: "eth_getUncleCountByBlockNumber";
+        Parameters: [block: import("viem").RpcBlockNumber | import("viem").BlockTag];
+        ReturnType: import("viem").Quantity;
+    }, {
+        Method: "eth_maxPriorityFeePerGas";
+        Parameters?: undefined;
+        ReturnType: import("viem").Quantity;
+    }, {
+        Method: "eth_newBlockFilter";
+        Parameters?: undefined;
+        ReturnType: import("viem").Quantity;
+    }, {
+        Method: "eth_newFilter";
+        Parameters: [filter: {
+            fromBlock?: import("viem").RpcBlockNumber | import("viem").BlockTag | undefined;
+            toBlock?: import("viem").RpcBlockNumber | import("viem").BlockTag | undefined;
+            address?: import("viem").Address | import("viem").Address[] | undefined;
+            topics?: import("viem").LogTopic[] | undefined;
+        }];
+        ReturnType: import("viem").Quantity;
+    }, {
+        Method: "eth_newPendingTransactionFilter";
+        Parameters?: undefined;
+        ReturnType: import("viem").Quantity;
+    }, {
+        Method: "eth_protocolVersion";
+        Parameters?: undefined;
+        ReturnType: string;
+    }, {
+        Method: "eth_sendRawTransaction";
+        Parameters: [signedTransaction: import("viem").Hex];
+        ReturnType: import("viem").Hash;
+    }, {
+        Method: "eth_sendRawTransactionSync";
+        Parameters: [signedTransaction: import("viem").Hex] | [signedTransaction: import("viem").Hex, timeout: import("viem").Hex];
+        ReturnType: import("viem").RpcTransactionReceipt;
+    }, {
+        Method: "eth_simulateV1";
+        Parameters: [{
+            blockStateCalls: readonly {
+                blockOverrides?: import("viem").RpcBlockOverrides | undefined;
+                calls?: readonly import("viem").ExactPartial<import("viem").RpcTransactionRequest>[] | undefined;
+                stateOverrides?: import("viem").RpcStateOverride | undefined;
+            }[];
+            returnFullTransactions?: boolean | undefined;
+            traceTransfers?: boolean | undefined;
+            validation?: boolean | undefined;
+        }, import("viem").RpcBlockNumber | import("viem").BlockTag];
+        ReturnType: readonly (import("viem").RpcBlock & {
+            calls: readonly {
+                error?: {
+                    data?: import("viem").Hex | undefined;
+                    code: number;
+                    message: string;
+                } | undefined;
+                logs?: readonly import("viem").RpcLog[] | undefined;
+                gasUsed: import("viem").Hex;
+                returnData: import("viem").Hex;
+                status: import("viem").Hex;
+            }[];
+        })[];
+    }, {
+        Method: "eth_uninstallFilter";
+        Parameters: [filterId: import("viem").Quantity];
+        ReturnType: boolean;
+    }, {
+        Method: "eth_accounts";
+        Parameters?: undefined;
+        ReturnType: import("viem").Address[];
+    }, {
+        Method: "eth_chainId";
+        Parameters?: undefined;
+        ReturnType: import("viem").Quantity;
+    }, {
+        Method: "eth_estimateGas";
+        Parameters: [transaction: import("viem").RpcTransactionRequest] | [transaction: import("viem").RpcTransactionRequest, block: import("viem").RpcBlockNumber | import("viem").BlockTag] | [transaction: import("viem").RpcTransactionRequest, block: import("viem").RpcBlockNumber | import("viem").BlockTag, stateOverride: import("viem").RpcStateOverride];
+        ReturnType: import("viem").Quantity;
+    }, {
+        Method: "eth_requestAccounts";
+        Parameters?: undefined;
+        ReturnType: import("viem").Address[];
+    }, {
+        Method: "eth_sendTransaction";
+        Parameters: [transaction: import("viem").RpcTransactionRequest];
+        ReturnType: import("viem").Hash;
+    }, {
+        Method: "eth_sendRawTransaction";
+        Parameters: [signedTransaction: import("viem").Hex];
+        ReturnType: import("viem").Hash;
+    }, {
+        Method: "eth_sendRawTransactionSync";
+        Parameters: [signedTransaction: import("viem").Hex] | [signedTransaction: import("viem").Hex, timeout: import("viem").Hex];
+        ReturnType: import("viem").RpcTransactionReceipt;
+    }, {
+        Method: "eth_sign";
+        Parameters: [address: import("viem").Address, data: import("viem").Hex];
+        ReturnType: import("viem").Hex;
+    }, {
+        Method: "eth_signTransaction";
+        Parameters: [request: import("viem").RpcTransactionRequest];
+        ReturnType: import("viem").Hex;
+    }, {
+        Method: "eth_signTypedData_v4";
+        Parameters: [address: import("viem").Address, message: string];
+        ReturnType: import("viem").Hex;
+    }, {
+        Method: "eth_syncing";
+        Parameters?: undefined;
+        ReturnType: import("viem").NetworkSync | false;
+    }, {
+        Method: "personal_sign";
+        Parameters: [data: import("viem").Hex, address: import("viem").Address];
+        ReturnType: import("viem").Hex;
+    }, {
+        Method: "wallet_addEthereumChain";
+        Parameters: [chain: import("viem").AddEthereumChainParameter];
+        ReturnType: null;
+    }, {
+        Method: "wallet_addSubAccount";
+        Parameters: [{
+            account: import("viem").OneOf<{
+                keys: readonly {
+                    publicKey: import("viem").Hex;
+                    type: "address" | "p256" | "webcrypto-p256" | "webauthn-p256";
+                }[];
+                type: "create";
+            } | {
+                address: import("viem").Address;
+                chainId?: number | undefined;
+                type: "deployed";
+            } | {
+                address: import("viem").Address;
+                chainId?: number | undefined;
+                factory: import("viem").Address;
+                factoryData: import("viem").Hex;
+                type: "undeployed";
+            }>;
+            version: string;
+        }];
+        ReturnType: {
+            address: import("viem").Address;
+            factory?: import("viem").Address | undefined;
+            factoryData?: import("viem").Hex | undefined;
+        };
+    }, {
+        Method: "wallet_connect";
+        Parameters: [{
+            capabilities?: import("viem").Capabilities | undefined;
+            version: string;
+        }];
+        ReturnType: {
+            accounts: readonly {
+                address: import("viem").Address;
+                capabilities?: import("viem").Capabilities | undefined;
+            }[];
+        };
+    }, {
+        Method: "wallet_disconnect";
+        Parameters?: undefined;
+        ReturnType: void;
+    }, {
+        Method: "wallet_getAssets";
+        Parameters?: [import("viem").WalletGetAssetsParameters];
+        ReturnType: import("viem").WalletGetAssetsReturnType;
+    }, {
+        Method: "wallet_getCallsStatus";
+        Parameters?: [string];
+        ReturnType: import("viem").WalletGetCallsStatusReturnType;
+    }, {
+        Method: "wallet_getCapabilities";
+        Parameters?: readonly [] | readonly [import("viem").Address | undefined] | readonly [import("viem").Address | undefined, readonly import("viem").Hex[] | undefined] | undefined;
+        ReturnType: import("viem").Prettify<import("viem").WalletCapabilitiesRecord>;
+    }, {
+        Method: "wallet_getPermissions";
+        Parameters?: undefined;
+        ReturnType: import("viem").WalletPermission[];
+    }, {
+        Method: "wallet_grantPermissions";
+        Parameters?: [import("viem").WalletGrantPermissionsParameters];
+        ReturnType: import("viem").Prettify<import("viem").WalletGrantPermissionsReturnType>;
+    }, {
+        Method: "wallet_requestPermissions";
+        Parameters: [permissions: {
+            eth_accounts: Record<string, any>;
+        }];
+        ReturnType: import("viem").WalletPermission[];
+    }, {
+        Method: "wallet_revokePermissions";
+        Parameters: [permissions: {
+            eth_accounts: Record<string, any>;
+        }];
+        ReturnType: null;
+    }, {
+        Method: "wallet_sendCalls";
+        Parameters?: import("viem").WalletSendCallsParameters;
+        ReturnType: import("viem").WalletSendCallsReturnType;
+    }, {
+        Method: "wallet_sendTransaction";
+        Parameters: [transaction: import("viem").RpcTransactionRequest];
+        ReturnType: import("viem").Hash;
+    }, {
+        Method: "wallet_showCallsStatus";
+        Parameters?: [string];
+        ReturnType: void;
+    }, {
+        Method: "wallet_switchEthereumChain";
+        Parameters: [chain: {
+            chainId: string;
+        }];
+        ReturnType: null;
+    }, {
+        Method: "wallet_watchAsset";
+        Parameters: import("viem").WatchAssetParams;
+        ReturnType: boolean;
+    }, {
+        Method: "eth_chainId";
+        Parameters?: undefined;
+        ReturnType: import("viem").Hex;
+    }, {
+        Method: "eth_estimateUserOperationGas";
+        Parameters: [userOperation: import("viem").RpcUserOperation, entrypoint: import("viem").Address] | [userOperation: import("viem").RpcUserOperation, entrypoint: import("viem").Address, stateOverrideSet: import("viem").RpcStateOverride];
+        ReturnType: import("viem").RpcEstimateUserOperationGasReturnType;
+    }, {
+        Method: "eth_getUserOperationByHash";
+        Parameters: [hash: import("viem").Hash];
+        ReturnType: import("viem").RpcGetUserOperationByHashReturnType | null;
+    }, {
+        Method: "eth_getUserOperationReceipt";
+        Parameters: [hash: import("viem").Hash];
+        ReturnType: import("viem").RpcUserOperationReceipt | null;
+    }, {
+        Method: "eth_sendUserOperation";
+        Parameters: [userOperation: import("viem").RpcUserOperation, entrypoint: import("viem").Address];
+        ReturnType: import("viem").Hash;
+    }, {
+        Method: "eth_supportedEntryPoints";
+        Parameters?: undefined;
+        ReturnType: readonly import("viem").Address[];
+    }, {
+        Method: "pm_getPaymasterStubData";
+        Parameters?: [userOperation: import("viem").OneOf<import("viem").PartialBy<Pick<import("viem").RpcUserOperation<"0.6">, "callData" | "callGasLimit" | "initCode" | "maxFeePerGas" | "maxPriorityFeePerGas" | "nonce" | "sender" | "preVerificationGas" | "verificationGasLimit">, "callGasLimit" | "initCode" | "maxFeePerGas" | "maxPriorityFeePerGas" | "preVerificationGas" | "verificationGasLimit"> | import("viem").PartialBy<Pick<import("viem").RpcUserOperation<"0.7">, "callData" | "callGasLimit" | "factory" | "factoryData" | "maxFeePerGas" | "maxPriorityFeePerGas" | "nonce" | "sender" | "preVerificationGas" | "verificationGasLimit">, "callGasLimit" | "factory" | "factoryData" | "maxFeePerGas" | "maxPriorityFeePerGas" | "preVerificationGas" | "verificationGasLimit">>, entrypoint: import("viem").Address, chainId: import("viem").Hex, context: unknown];
+        ReturnType: import("viem").OneOf<{
+            paymasterAndData: import("viem").Hex;
+        } | {
+            paymaster: import("viem").Address;
+            paymasterData: import("viem").Hex;
+            paymasterVerificationGasLimit: import("viem").Hex;
+            paymasterPostOpGasLimit: import("viem").Hex;
+        }> & {
+            sponsor?: {
+                name: string;
+                icon?: string | undefined;
+            } | undefined;
+            isFinal?: boolean | undefined;
+        };
+    }, {
+        Method: "pm_getPaymasterData";
+        Parameters?: [userOperation: Pick<import("viem").RpcUserOperation<"0.6">, "callData" | "callGasLimit" | "initCode" | "maxFeePerGas" | "maxPriorityFeePerGas" | "nonce" | "sender" | "preVerificationGas" | "verificationGasLimit"> | Pick<import("viem").RpcUserOperation<"0.7">, "callData" | "callGasLimit" | "factory" | "factoryData" | "maxFeePerGas" | "maxPriorityFeePerGas" | "nonce" | "sender" | "preVerificationGas" | "verificationGasLimit">, entrypoint: import("viem").Address, chainId: import("viem").Hex, context: unknown];
+        ReturnType: import("viem").OneOf<{
+            paymasterAndData: import("viem").Hex;
+        } | {
+            paymaster: import("viem").Address;
+            paymasterData: import("viem").Hex;
+            paymasterVerificationGasLimit: import("viem").Hex;
+            paymasterPostOpGasLimit: import("viem").Hex;
+        }>;
+    }]>;
+    transport: import("viem").TransportConfig<"http", import("viem").EIP1193RequestFn> & {
+        fetchOptions?: import("viem").HttpTransportConfig["fetchOptions"] | undefined;
+        url?: string | undefined;
+    };
+    type: string;
+    uid: string;
+    extend: <const client extends {
+        [x: string]: unknown;
+        account?: undefined;
+        batch?: undefined;
+        cacheTime?: undefined;
+        ccipRead?: undefined;
+        chain?: undefined;
+        experimental_blockTag?: undefined;
+        key?: undefined;
+        name?: undefined;
+        pollingInterval?: undefined;
+        request?: undefined;
+        transport?: undefined;
+        type?: undefined;
+        uid?: undefined;
+    } & import("viem").ExactPartial<Pick<import("viem").PublicActions<import("viem").HttpTransport<undefined, false>, Chains.Chain, undefined>, "call" | "createContractEventFilter" | "createEventFilter" | "estimateContractGas" | "estimateGas" | "getBlock" | "getBlockNumber" | "getChainId" | "getContractEvents" | "getEnsText" | "getFilterChanges" | "getGasPrice" | "getLogs" | "getTransaction" | "getTransactionCount" | "getTransactionReceipt" | "prepareTransactionRequest" | "readContract" | "sendRawTransaction" | "simulateContract" | "uninstallFilter" | "watchBlockNumber" | "watchContractEvent"> & Pick<import("viem").WalletActions<Chains.Chain, undefined>, "sendTransaction" | "writeContract">>>(fn: (client: import("viem").Client<import("viem").HttpTransport<undefined, false>, Chains.Chain, undefined, undefined, {
+        [x: string]: unknown;
+        account?: undefined;
+        batch?: undefined;
+        cacheTime?: undefined;
+        ccipRead?: undefined;
+        chain?: undefined;
+        experimental_blockTag?: undefined;
+        key?: undefined;
+        name?: undefined;
+        pollingInterval?: undefined;
+        request?: undefined;
+        transport?: undefined;
+        type?: undefined;
+        uid?: undefined;
+    } | undefined>) => client) => import("viem").Client<import("viem").HttpTransport<undefined, false>, Chains.Chain, undefined, undefined, { [K in keyof client]: client[K]; }>;
+}>;
+export declare namespace getRelayClient {
+    type Options = {
+        /** Chain name. */
+        chain?: string | undefined;
+        /** Relay URL. */
+        rpc?: string | undefined;
+    };
+}
+//# sourceMappingURL=context.d.ts.map

package/dist/cli/internal/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/cli/internal/context.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,MAAM,MAAM,sBAAsB,CAAA;AAG9C,OAAO,KAAK,YAAY,MAAM,4BAA4B,CAAA;AAI1D,2CAA2C;AAC3C,wBAAsB,eAAe,CAAC,OAAO,GAAE,eAAe,CAAC,OAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAa1E;AAED,MAAM,CAAC,OAAO,WAAW,eAAe,CAAC;IACvC,KAAK,OAAO,GAAG;QACb,uBAAuB;QACvB,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAC5B,CAAA;CACF;AAED,oCAAoC;AACpC,wBAAsB,cAAc,CAAC,OAAO,GAAE,cAAc,CAAC,OAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAsBi0uB,CAAC;kBAAyD,CAAC;;qBAAsE,CAAC;mBAA6D,CAAC;qBAA+D,CAAC;;qBAAwD,CAAC;mBAAoC,CAAC;qBAAsC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAAy3M,CAAC;mBAA6D,CAAC;mBAA6D,CAAC;kBAAyD,CAAC;;;;;;;;;;;;;;;;;;;;;;;8BAAsnE,CAAC;qBAA2D,CAAC;8BAA6F,CAAC;;kCAA2F,CAAC;0BAAqD,CAAC;sBAAiD,CAAC;;;;qBAA+K,CAAC;wBAA4B,CAAC;;;;oBAA6I,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAAk7nB,CAAC;;;;uBAAmJ,CAAC;;;;;;;;;mBAA+R,CAAC;uBAA8C,CAAC;;;;;wBAAyZ,CAAC;;;;;;4BAA2M,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAA5k1C,CAAC;;oBAAsD,CAAC;;mBAAoE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAV3pX;AAED,MAAM,CAAC,OAAO,WAAW,cAAc,CAAC;IACtC,KAAK,OAAO,GAAG;QACb,kBAAkB;QAClB,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QAC1B,iBAAiB;QACjB,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KACzB,CAAA;CACF"}

package/dist/cli/internal/context.js

@@ -0,0 +1,38 @@
+import { createClient, http } from 'viem';
+import { getChainId } from 'viem/actions';
+import * as Chains from '../../core/Chains.js';
+import * as Mode from '../../core/Mode.js';
+import * as Porto from '../../core/Porto.js';
+import * as WalletClient from '../../viem/WalletClient.js';
+import * as Dialog from '../Dialog.js';
+import * as Utils from './utils.js';
+/** Gets a Viem client for Porto Dialog. */
+export async function getWalletClient(options = {}) {
+    const { dialog: host } = options;
+    const porto = Porto.create({
+        announceProvider: false,
+        chains: [Chains.riseTestnet],
+        mode: Mode.dialog({
+            host: host ? new URL('/dialog', 'https://' + host).toString() : undefined,
+            renderer: await Dialog.cli(),
+        }),
+    });
+    return WalletClient.fromPorto(porto, {
+        chain: Chains.riseTestnet,
+    });
+}
+/** Gets a Viem client for Relay. */
+export async function getRelayClient(options = {}) {
+    const chain = Utils.kebabToCamel(options.chain);
+    const client = createClient({
+        // biome-ignore lint/performance/noDynamicNamespaceImportAccess: _
+        chain: Chains[chain],
+        transport: http(options.rpc),
+    });
+    client.chain = {
+        ...client.chain,
+        id: (await getChainId(client)),
+    };
+    return client;
+}
+//# sourceMappingURL=context.js.map

package/dist/cli/internal/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../../src/cli/internal/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAEzC,OAAO,KAAK,MAAM,MAAM,sBAAsB,CAAA;AAC9C,OAAO,KAAK,IAAI,MAAM,oBAAoB,CAAA;AAC1C,OAAO,KAAK,KAAK,MAAM,qBAAqB,CAAA;AAC5C,OAAO,KAAK,YAAY,MAAM,4BAA4B,CAAA;AAC1D,OAAO,KAAK,MAAM,MAAM,cAAc,CAAA;AACtC,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC,2CAA2C;AAC3C,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,UAAmC,EAAE;IACzE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,OAAO,CAAA;IAChC,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC;QACzB,gBAAgB,EAAE,KAAK;QACvB,MAAM,EAAE,CAAC,MAAM,CAAC,WAAW,CAAC;QAC5B,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC;YAChB,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,SAAS,EAAE,UAAU,GAAG,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,SAAS;YACzE,QAAQ,EAAE,MAAM,MAAM,CAAC,GAAG,EAAE;SAC7B,CAAC;KACH,CAAC,CAAA;IACF,OAAO,YAAY,CAAC,SAAS,CAAC,KAAK,EAAE;QACnC,KAAK,EAAE,MAAM,CAAC,WAAW;KAC1B,CAAC,CAAA;AACJ,CAAC;AASD,oCAAoC;AACpC,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,UAAkC,EAAE;IACvE,MAAM,KAAK,GAAG,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,KAAM,CAAwB,CAAA;IACvE,MAAM,MAAM,GAAG,YAAY,CAAC;QAC1B,kEAAkE;QAClE,KAAK,EAAE,MAAM,CAAC,KAAK,CAAiB;QACpC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC;KAC7B,CAAC,CAAA;IACF,MAAM,CAAC,KAAK,GAAG;QACb,GAAG,MAAM,CAAC,KAAK;QACf,EAAE,EAAE,CAAC,MAAM,UAAU,CAAC,MAAM,CAAC,CAAU;KACxC,CAAA;IACD,OAAO,MAAM,CAAA;AACf,CAAC"}

package/dist/cli/internal/http.d.ts

@@ -0,0 +1,7 @@
+import * as Http from 'node:http';
+export type Server = Http.Server & {
+    closeAsync: () => Promise<unknown>;
+    url: string;
+};
+export declare function createServer(handler: Http.RequestListener): Promise<Server>;
+//# sourceMappingURL=http.d.ts.map

package/dist/cli/internal/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../../src/cli/internal/http.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAGjC,MAAM,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,GAAG;IACjC,UAAU,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAA;IAClC,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAmB3E"}

package/dist/cli/internal/http.js

@@ -0,0 +1,17 @@
+import * as Http from 'node:http';
+export function createServer(handler) {
+    const server = Http.createServer(handler);
+    return new Promise((resolve, reject) => {
+        server.on('error', reject);
+        server.listen(() => {
+            const { port } = server.address();
+            resolve(Object.assign(server, {
+                closeAsync() {
+                    return new Promise((resolve, reject) => server.close((err) => (err ? reject(err) : resolve(undefined))));
+                },
+                url: `http://localhost:${port}`,
+            }));
+        });
+    });
+}
+//# sourceMappingURL=http.js.map

package/dist/cli/internal/http.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.js","sourceRoot":"","sources":["../../../src/cli/internal/http.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAQjC,MAAM,UAAU,YAAY,CAAC,OAA6B;IACxD,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAA;IAEzC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACrC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;QAC1B,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE;YACjB,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,CAAC,OAAO,EAAiB,CAAA;YAChD,OAAO,CACL,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE;gBACpB,UAAU;oBACR,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,CACrC,MAAM,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAChE,CAAA;gBACH,CAAC;gBACD,GAAG,EAAE,oBAAoB,IAAI,EAAE;aAChC,CAAC,CACH,CAAA;QACH,CAAC,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;AACJ,CAAC"}

package/dist/cli/internal/utils.d.ts

@@ -0,0 +1,7 @@
+/** Gets all chain names. */
+export declare function getChainNames(): string[];
+/** Converts kebab-case string to camelCase. */
+export declare function kebabToCamel(str: string): string;
+/** Converts camelCase string to kebab-case. */
+export declare function camelToKebab(str: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/cli/internal/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/cli/internal/utils.ts"],"names":[],"mappings":"AAEA,4BAA4B;AAC5B,wBAAgB,aAAa,aAI5B;AAED,+CAA+C;AAC/C,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAShD;AAED,+CAA+C;AAC/C,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAKhD"}

package/dist/cli/internal/utils.js

@@ -0,0 +1,24 @@
+import * as Chains from '../../core/Chains.js';
+/** Gets all chain names. */
+export function getChainNames() {
+    return Object.entries(Chains)
+        .filter(([_, chain]) => typeof chain === 'object' && 'id' in chain)
+        .map(([key]) => camelToKebab(key));
+}
+/** Converts kebab-case string to camelCase. */
+export function kebabToCamel(str) {
+    return str
+        .split('-')
+        .map((word, index) => index === 0
+        ? word.toLowerCase()
+        : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join('');
+}
+/** Converts camelCase string to kebab-case. */
+export function camelToKebab(str) {
+    return str
+        .split(/(?=[A-Z])/)
+        .map((word) => word.toLowerCase())
+        .join('-');
+}
+//# sourceMappingURL=utils.js.map

package/dist/cli/internal/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/cli/internal/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,sBAAsB,CAAA;AAE9C,4BAA4B;AAC5B,MAAM,UAAU,aAAa;IAC3B,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;SAC1B,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,IAAI,IAAI,KAAK,CAAC;SAClE,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAA;AACtC,CAAC;AAED,+CAA+C;AAC/C,MAAM,UAAU,YAAY,CAAC,GAAW;IACtC,OAAO,GAAG;SACP,KAAK,CAAC,GAAG,CAAC;SACV,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CACnB,KAAK,KAAK,CAAC;QACT,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE;QACpB,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAC/D;SACA,IAAI,CAAC,EAAE,CAAC,CAAA;AACb,CAAC;AAED,+CAA+C;AAC/C,MAAM,UAAU,YAAY,CAAC,GAAW;IACtC,OAAO,GAAG;SACP,KAAK,CAAC,WAAW,CAAC;SAClB,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;SACjC,IAAI,CAAC,GAAG,CAAC,CAAA;AACd,CAAC"}