rise-wallet 0.2.29 → 0.3.1

package/dist/core/Porto.d.ts

@@ -56,38 +56,311 @@ export declare const defaultConfig: {
     }, ...{
         blockExplorers: {
             readonly default: {
-                readonly name: "Blockscout";
-                readonly url: "https://explorer.testnet.riselabs.xyz/";
-                readonly apiUrl: "https://explorer.testnet.riselabs.xyz/api";
+                readonly name: "Basescan";
+                readonly url: "https://sepolia.basescan.org";
+                readonly apiUrl: "https://api-sepolia.basescan.org/api";
             };
         };
-        blockTime?: number | undefined | undefined;
+        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: 11155931;
-        name: "RISE Testnet";
+        id: 84532;
+        name: "Base Sepolia";
         nativeCurrency: {
-            readonly name: "RISE Testnet Ether";
+            readonly name: "Sepolia 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"];
+                readonly http: readonly ["https://sepolia.base.org"];
             };
         };
-        sourceId?: number | undefined | undefined;
+        sourceId: 11155111;
         testnet: true;
         custom?: Record<string, unknown> | undefined;
         fees?: import("viem").ChainFees<undefined> | undefined;
-        formatters?: undefined;
-        serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | 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: {
@@ -99,6 +372,7 @@ export declare const defaultConfig: {
                 label?: string | undefined;
                 permissions?: import("./internal/permissionsRequest.js").PermissionsRequest | undefined;
                 signInWithEthereum?: import("./internal/schema/capabilities.js").signInWithEthereum.Request | undefined;
+                providerRdns?: string | undefined;
             }) => Promise<{
                 account: {
                     signInWithEthereum: {
@@ -106,8 +380,105 @@ export declare const defaultConfig: {
                         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: readonly [{
+                        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;
+                    } | {
+                        expiry: number;
+                        hash: `0x${string}`;
+                        id: `0x${string}`;
+                        publicKey: `0x${string}`;
+                        role: "admin" | "session";
+                        type: "eip1193provider";
+                        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?: {
+                            rdns: string;
+                        } | undefined;
+                    }, ...import("../viem/Key.js").Key[]];
+                } | {
+                    signInWithEthereum: {
+                        message: string;
+                        signature: `0x${string}`;
+                    } | undefined;
                     type: "local";
+                    address: import("viem").Address;
+                    publicKey: import("viem").Hex;
                     nonceManager?: import("viem").NonceManager | undefined;
                     sign: (parameters: {
                         hash: import("viem").Hash;
@@ -401,6 +772,42 @@ export declare const defaultConfig: {
                     } | {
                         privateKey: () => Hex.Hex;
                     }> | undefined;
+                } | {
+                    expiry: number;
+                    hash: `0x${string}`;
+                    id: `0x${string}`;
+                    publicKey: `0x${string}`;
+                    role: "admin" | "session";
+                    type: "eip1193provider";
+                    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?: {
+                        rdns: string;
+                    } | undefined;
                 };
             }>;
             readonly grantPermissions: (parameters: {
@@ -415,10 +822,13 @@ export declare const defaultConfig: {
                 key?: {
                     credentialId?: string | undefined;
                     publicKey: Hex.Hex;
+                } | {
+                    rdns?: string | undefined;
                 } | undefined;
                 internal: Mode.ActionsInternal;
                 permissions?: import("./internal/permissionsRequest.js").PermissionsRequest | undefined;
                 signInWithEthereum?: import("./internal/schema/capabilities.js").signInWithEthereum.Request | undefined;
+                providerRdns?: string | undefined;
             }) => Promise<{
                 accounts: {
                     signInWithEthereum: {
@@ -622,14 +1032,14 @@ export declare const defaultConfig: {
                     } | undefined;
                 };
                 digest: `0x${string}`;
-                key: Pick<import("../viem/Key.js").Key, "publicKey" | "type" | "prehash">;
+                key: Pick<import("../viem/Key.js").Key, "type" | "prehash" | "publicKey">;
                 typedData: {
-                    domain: Record<string, never> | {
+                    domain: {
                         chainId: number;
                         name: string;
                         verifyingContract: `0x${string}`;
                         version: string;
-                    };
+                    } | Record<string, never>;
                     message: Record<string, unknown>;
                     primaryType: string;
                     types: Record<string, unknown>;
@@ -748,6 +1158,7 @@ export declare const defaultConfig: {
                 label?: string | undefined;
                 permissions?: import("./internal/permissionsRequest.js").PermissionsRequest | undefined;
                 signInWithEthereum?: import("./internal/schema/capabilities.js").signInWithEthereum.Request | undefined;
+                providerRdns?: string | undefined;
             }) => Promise<{
                 account: {
                     signInWithEthereum: {
@@ -916,7 +1327,7 @@ export declare const defaultConfig: {
                 id: `0x${string}`;
                 publicKey: `0x${string}`;
                 role: "admin" | "session";
-                type: "address" | "p256" | "secp256k1" | "webauthn-p256";
+                type: "address" | "p256" | "secp256k1" | "webauthn-p256" | "eip1193provider";
                 feeToken?: {
                     limit: `${number}` | `${number}.${number}`;
                     symbol?: string | undefined;
@@ -1125,6 +1536,42 @@ export declare const defaultConfig: {
                     } | {
                         privateKey: () => Hex.Hex;
                     }> | undefined;
+                } | {
+                    expiry: number;
+                    hash: `0x${string}`;
+                    id: `0x${string}`;
+                    publicKey: `0x${string}`;
+                    role: "admin" | "session";
+                    type: "eip1193provider";
+                    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?: {
+                        rdns: string;
+                    } | undefined;
                 };
             }>;
             readonly grantPermissions: (parameters: {
@@ -1139,10 +1586,13 @@ export declare const defaultConfig: {
                 key?: {
                     credentialId?: string | undefined;
                     publicKey: Hex.Hex;
+                } | {
+                    rdns?: string | undefined;
                 } | undefined;
                 internal: Mode.ActionsInternal;
                 permissions?: import("./internal/permissionsRequest.js").PermissionsRequest | undefined;
                 signInWithEthereum?: import("./internal/schema/capabilities.js").signInWithEthereum.Request | undefined;
+                providerRdns?: string | undefined;
             }) => Promise<{
                 accounts: {
                     readonly signInWithEthereum: {
@@ -1363,14 +1813,14 @@ export declare const defaultConfig: {
                     } | undefined;
                 };
                 digest: `0x${string}`;
-                key: Pick<import("../viem/Key.js").Key, "publicKey" | "type" | "prehash">;
+                key: Pick<import("../viem/Key.js").Key, "type" | "prehash" | "publicKey">;
                 typedData: {
-                    domain: Record<string, never> | {
+                    domain: {
                         chainId: number;
                         name: string;
                         verifyingContract: `0x${string}`;
                         version: string;
-                    };
+                    } | Record<string, never>;
                     message: Record<string, unknown>;
                     primaryType: string;
                     types: Record<string, unknown>;
@@ -1381,17 +1831,17 @@ export declare const defaultConfig: {
                 context: any;
                 digest: `0x${string}`;
                 key: {
+                    type: "address" | "p256" | "secp256k1" | "webauthn-p256" | "eip1193provider";
                     publicKey: `0x${string}`;
-                    type: "address" | "p256" | "secp256k1" | "webauthn-p256";
                     prehash?: boolean | undefined;
                 };
                 typedData: {
-                    domain: {
+                    domain: Record<string, never> | {
                         chainId: number;
                         name: string;
                         verifyingContract: `0x${string}`;
                         version: string;
-                    } | Record<string, never>;
+                    };
                     message: Record<string, unknown>;
                     primaryType: string;
                     types: Record<string, unknown>;
@@ -1487,21 +1937,21 @@ export declare const defaultConfig: {
     }>;
     readonly relay: import("viem").HttpTransport<undefined, false>;
     readonly storage: Storage.Storage;
-    readonly storageKey: "porto.store";
+    readonly storageKey: "risewallet.store";
 };
 /**
  * Instantiates an Porto instance.
  *
  * @example
  * ```ts twoslash
- * import { Porto } from 'porto'
+ * 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): Porto<chains>;
+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[]
@@ -1552,7 +2002,7 @@ export type Config<chains extends readonly [Chains.Chain, ...Chains.Chain[]] = r
      */
     transports: Record<chains[number]['id'], Transport>;
 };
-export type Porto<chains extends readonly [Chains.Chain, ...Chains.Chain[]] = readonly [
+export type RiseWallet<chains extends readonly [Chains.Chain, ...Chains.Chain[]] = readonly [
     Chains.Chain,
     ...Chains.Chain[]
 ]> = {