@gitmyabi/relayadapt7702 1.0.0

package/contracts/RelayAdapt7702_json.d.ts

@@ -0,0 +1,1154 @@
+import type { Address, PublicClient, WalletClient } from 'viem';
+/**
+ * Transaction struct type
+ */
+export type Transaction = {
+    proof: SnarkProof;
+    merkleRoot: `0x${string}`;
+    nullifiers: `0x${string}`[];
+    commitments: `0x${string}`[];
+    boundParams: BoundParams;
+    unshieldPreimage: CommitmentPreimage;
+};
+/**
+ * SnarkProof struct type
+ */
+export type SnarkProof = {
+    a: G1Point;
+    b: G2Point;
+    c: G1Point;
+};
+/**
+ * G1Point struct type
+ */
+export type G1Point = {
+    x: bigint;
+    y: bigint;
+};
+/**
+ * G2Point struct type
+ */
+export type G2Point = {
+    x: bigint[];
+    y: bigint[];
+};
+/**
+ * BoundParams struct type
+ */
+export type BoundParams = {
+    treeNumber: bigint;
+    minGasPrice: bigint;
+    unshield: bigint;
+    chainID: bigint;
+    adaptContract: `0x${string}`;
+    adaptParams: `0x${string}`;
+    commitmentCiphertext: CommitmentCiphertext[];
+};
+/**
+ * CommitmentCiphertext struct type
+ */
+export type CommitmentCiphertext = {
+    ciphertext: `0x${string}`[];
+    blindedSenderViewingKey: `0x${string}`;
+    blindedReceiverViewingKey: `0x${string}`;
+    annotationData: `0x${string}`;
+    memo: `0x${string}`;
+};
+/**
+ * CommitmentPreimage struct type
+ */
+export type CommitmentPreimage = {
+    npk: `0x${string}`;
+    token: TokenData;
+    value: bigint;
+};
+/**
+ * TokenData struct type
+ */
+export type TokenData = {
+    tokenType: bigint;
+    tokenAddress: `0x${string}`;
+    tokenSubID: bigint;
+};
+/**
+ * RelayAdapt7702.ActionData struct type
+ */
+export type RelayAdapt7702_ActionData = {
+    requireSuccess: boolean;
+    minGasLimit: bigint;
+    calls: RelayAdapt7702_Call[];
+};
+/**
+ * RelayAdapt7702.Call struct type
+ */
+export type RelayAdapt7702_Call = {
+    to: `0x${string}`;
+    data: `0x${string}`;
+    value: bigint;
+};
+/**
+ * ShieldRequest struct type
+ */
+export type ShieldRequest = {
+    preimage: CommitmentPreimage;
+    ciphertext: ShieldCiphertext;
+};
+/**
+ * ShieldCiphertext struct type
+ */
+export type ShieldCiphertext = {
+    encryptedBundle: `0x${string}`[];
+    shieldKey: `0x${string}`;
+};
+/**
+ * RelayAdapt7702.TokenTransfer struct type
+ */
+export type RelayAdapt7702_TokenTransfer = {
+    token: TokenData;
+    to: `0x${string}`;
+    value: bigint;
+};
+/**
+ * RelayAdapt7702_json ABI
+ *
+ * This ABI is typed using viem's type system for full type safety.
+ */
+export declare const RelayAdapt7702_jsonAbi: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_railgun";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "_wBase";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "callIndex";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "revertReason";
+        readonly type: "bytes";
+    }];
+    readonly name: "CallFailed";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ECDSAInvalidSignature";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "length";
+        readonly type: "uint256";
+    }];
+    readonly name: "ECDSAInvalidSignatureLength";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "s";
+        readonly type: "bytes32";
+    }];
+    readonly name: "ECDSAInvalidSignatureS";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "token";
+        readonly type: "address";
+    }];
+    readonly name: "SafeERC20FailedOperation";
+    readonly type: "error";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "callIndex";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bytes";
+        readonly name: "revertReason";
+        readonly type: "bytes";
+    }];
+    readonly name: "CallError";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "DOMAIN_SEPARATOR";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "EXECUTE_TYPEHASH";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "MULTICALL_TYPEHASH";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "adaptImplementation";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly components: readonly [{
+                readonly components: readonly [{
+                    readonly internalType: "uint256";
+                    readonly name: "x";
+                    readonly type: "uint256";
+                }, {
+                    readonly internalType: "uint256";
+                    readonly name: "y";
+                    readonly type: "uint256";
+                }];
+                readonly internalType: "struct G1Point";
+                readonly name: "a";
+                readonly type: "tuple";
+            }, {
+                readonly components: readonly [{
+                    readonly internalType: "uint256[2]";
+                    readonly name: "x";
+                    readonly type: "uint256[2]";
+                }, {
+                    readonly internalType: "uint256[2]";
+                    readonly name: "y";
+                    readonly type: "uint256[2]";
+                }];
+                readonly internalType: "struct G2Point";
+                readonly name: "b";
+                readonly type: "tuple";
+            }, {
+                readonly components: readonly [{
+                    readonly internalType: "uint256";
+                    readonly name: "x";
+                    readonly type: "uint256";
+                }, {
+                    readonly internalType: "uint256";
+                    readonly name: "y";
+                    readonly type: "uint256";
+                }];
+                readonly internalType: "struct G1Point";
+                readonly name: "c";
+                readonly type: "tuple";
+            }];
+            readonly internalType: "struct SnarkProof";
+            readonly name: "proof";
+            readonly type: "tuple";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "merkleRoot";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes32[]";
+            readonly name: "nullifiers";
+            readonly type: "bytes32[]";
+        }, {
+            readonly internalType: "bytes32[]";
+            readonly name: "commitments";
+            readonly type: "bytes32[]";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "uint16";
+                readonly name: "treeNumber";
+                readonly type: "uint16";
+            }, {
+                readonly internalType: "uint72";
+                readonly name: "minGasPrice";
+                readonly type: "uint72";
+            }, {
+                readonly internalType: "enum UnshieldType";
+                readonly name: "unshield";
+                readonly type: "uint8";
+            }, {
+                readonly internalType: "uint64";
+                readonly name: "chainID";
+                readonly type: "uint64";
+            }, {
+                readonly internalType: "address";
+                readonly name: "adaptContract";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bytes32";
+                readonly name: "adaptParams";
+                readonly type: "bytes32";
+            }, {
+                readonly components: readonly [{
+                    readonly internalType: "bytes32[4]";
+                    readonly name: "ciphertext";
+                    readonly type: "bytes32[4]";
+                }, {
+                    readonly internalType: "bytes32";
+                    readonly name: "blindedSenderViewingKey";
+                    readonly type: "bytes32";
+                }, {
+                    readonly internalType: "bytes32";
+                    readonly name: "blindedReceiverViewingKey";
+                    readonly type: "bytes32";
+                }, {
+                    readonly internalType: "bytes";
+                    readonly name: "annotationData";
+                    readonly type: "bytes";
+                }, {
+                    readonly internalType: "bytes";
+                    readonly name: "memo";
+                    readonly type: "bytes";
+                }];
+                readonly internalType: "struct CommitmentCiphertext[]";
+                readonly name: "commitmentCiphertext";
+                readonly type: "tuple[]";
+            }];
+            readonly internalType: "struct BoundParams";
+            readonly name: "boundParams";
+            readonly type: "tuple";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "bytes32";
+                readonly name: "npk";
+                readonly type: "bytes32";
+            }, {
+                readonly components: readonly [{
+                    readonly internalType: "enum TokenType";
+                    readonly name: "tokenType";
+                    readonly type: "uint8";
+                }, {
+                    readonly internalType: "address";
+                    readonly name: "tokenAddress";
+                    readonly type: "address";
+                }, {
+                    readonly internalType: "uint256";
+                    readonly name: "tokenSubID";
+                    readonly type: "uint256";
+                }];
+                readonly internalType: "struct TokenData";
+                readonly name: "token";
+                readonly type: "tuple";
+            }, {
+                readonly internalType: "uint120";
+                readonly name: "value";
+                readonly type: "uint120";
+            }];
+            readonly internalType: "struct CommitmentPreimage";
+            readonly name: "unshieldPreimage";
+            readonly type: "tuple";
+        }];
+        readonly internalType: "struct Transaction[]";
+        readonly name: "_transactions";
+        readonly type: "tuple[]";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "bool";
+            readonly name: "requireSuccess";
+            readonly type: "bool";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "minGasLimit";
+            readonly type: "uint256";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "address";
+                readonly name: "to";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "data";
+                readonly type: "bytes";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "value";
+                readonly type: "uint256";
+            }];
+            readonly internalType: "struct RelayAdapt7702.Call[]";
+            readonly name: "calls";
+            readonly type: "tuple[]";
+        }];
+        readonly internalType: "struct RelayAdapt7702.ActionData";
+        readonly name: "_actionData";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_nonce";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "_signature";
+        readonly type: "bytes";
+    }];
+    readonly name: "execute";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly components: readonly [{
+                readonly components: readonly [{
+                    readonly internalType: "uint256";
+                    readonly name: "x";
+                    readonly type: "uint256";
+                }, {
+                    readonly internalType: "uint256";
+                    readonly name: "y";
+                    readonly type: "uint256";
+                }];
+                readonly internalType: "struct G1Point";
+                readonly name: "a";
+                readonly type: "tuple";
+            }, {
+                readonly components: readonly [{
+                    readonly internalType: "uint256[2]";
+                    readonly name: "x";
+                    readonly type: "uint256[2]";
+                }, {
+                    readonly internalType: "uint256[2]";
+                    readonly name: "y";
+                    readonly type: "uint256[2]";
+                }];
+                readonly internalType: "struct G2Point";
+                readonly name: "b";
+                readonly type: "tuple";
+            }, {
+                readonly components: readonly [{
+                    readonly internalType: "uint256";
+                    readonly name: "x";
+                    readonly type: "uint256";
+                }, {
+                    readonly internalType: "uint256";
+                    readonly name: "y";
+                    readonly type: "uint256";
+                }];
+                readonly internalType: "struct G1Point";
+                readonly name: "c";
+                readonly type: "tuple";
+            }];
+            readonly internalType: "struct SnarkProof";
+            readonly name: "proof";
+            readonly type: "tuple";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "merkleRoot";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes32[]";
+            readonly name: "nullifiers";
+            readonly type: "bytes32[]";
+        }, {
+            readonly internalType: "bytes32[]";
+            readonly name: "commitments";
+            readonly type: "bytes32[]";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "uint16";
+                readonly name: "treeNumber";
+                readonly type: "uint16";
+            }, {
+                readonly internalType: "uint72";
+                readonly name: "minGasPrice";
+                readonly type: "uint72";
+            }, {
+                readonly internalType: "enum UnshieldType";
+                readonly name: "unshield";
+                readonly type: "uint8";
+            }, {
+                readonly internalType: "uint64";
+                readonly name: "chainID";
+                readonly type: "uint64";
+            }, {
+                readonly internalType: "address";
+                readonly name: "adaptContract";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bytes32";
+                readonly name: "adaptParams";
+                readonly type: "bytes32";
+            }, {
+                readonly components: readonly [{
+                    readonly internalType: "bytes32[4]";
+                    readonly name: "ciphertext";
+                    readonly type: "bytes32[4]";
+                }, {
+                    readonly internalType: "bytes32";
+                    readonly name: "blindedSenderViewingKey";
+                    readonly type: "bytes32";
+                }, {
+                    readonly internalType: "bytes32";
+                    readonly name: "blindedReceiverViewingKey";
+                    readonly type: "bytes32";
+                }, {
+                    readonly internalType: "bytes";
+                    readonly name: "annotationData";
+                    readonly type: "bytes";
+                }, {
+                    readonly internalType: "bytes";
+                    readonly name: "memo";
+                    readonly type: "bytes";
+                }];
+                readonly internalType: "struct CommitmentCiphertext[]";
+                readonly name: "commitmentCiphertext";
+                readonly type: "tuple[]";
+            }];
+            readonly internalType: "struct BoundParams";
+            readonly name: "boundParams";
+            readonly type: "tuple";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "bytes32";
+                readonly name: "npk";
+                readonly type: "bytes32";
+            }, {
+                readonly components: readonly [{
+                    readonly internalType: "enum TokenType";
+                    readonly name: "tokenType";
+                    readonly type: "uint8";
+                }, {
+                    readonly internalType: "address";
+                    readonly name: "tokenAddress";
+                    readonly type: "address";
+                }, {
+                    readonly internalType: "uint256";
+                    readonly name: "tokenSubID";
+                    readonly type: "uint256";
+                }];
+                readonly internalType: "struct TokenData";
+                readonly name: "token";
+                readonly type: "tuple";
+            }, {
+                readonly internalType: "uint120";
+                readonly name: "value";
+                readonly type: "uint120";
+            }];
+            readonly internalType: "struct CommitmentPreimage";
+            readonly name: "unshieldPreimage";
+            readonly type: "tuple";
+        }];
+        readonly internalType: "struct Transaction[]";
+        readonly name: "_transactions";
+        readonly type: "tuple[]";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "bool";
+            readonly name: "requireSuccess";
+            readonly type: "bool";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "minGasLimit";
+            readonly type: "uint256";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "address";
+                readonly name: "to";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "data";
+                readonly type: "bytes";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "value";
+                readonly type: "uint256";
+            }];
+            readonly internalType: "struct RelayAdapt7702.Call[]";
+            readonly name: "calls";
+            readonly type: "tuple[]";
+        }];
+        readonly internalType: "struct RelayAdapt7702.ActionData";
+        readonly name: "_actionData";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_nonce";
+        readonly type: "uint256";
+    }];
+    readonly name: "getExecutePayloadHash";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "pure";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "_requireSuccess";
+        readonly type: "bool";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "data";
+            readonly type: "bytes";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "value";
+            readonly type: "uint256";
+        }];
+        readonly internalType: "struct RelayAdapt7702.Call[]";
+        readonly name: "_calls";
+        readonly type: "tuple[]";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_nonce";
+        readonly type: "uint256";
+    }];
+    readonly name: "getMulticallPayloadHash";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "pure";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "_requireSuccess";
+        readonly type: "bool";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "data";
+            readonly type: "bytes";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "value";
+            readonly type: "uint256";
+        }];
+        readonly internalType: "struct RelayAdapt7702.Call[]";
+        readonly name: "_calls";
+        readonly type: "tuple[]";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_nonce";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "_signature";
+        readonly type: "bytes";
+    }];
+    readonly name: "multicall";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "nonce";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "railgun";
+    readonly outputs: readonly [{
+        readonly internalType: "contract RailgunSmartWallet";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "bytes32";
+                readonly name: "npk";
+                readonly type: "bytes32";
+            }, {
+                readonly components: readonly [{
+                    readonly internalType: "enum TokenType";
+                    readonly name: "tokenType";
+                    readonly type: "uint8";
+                }, {
+                    readonly internalType: "address";
+                    readonly name: "tokenAddress";
+                    readonly type: "address";
+                }, {
+                    readonly internalType: "uint256";
+                    readonly name: "tokenSubID";
+                    readonly type: "uint256";
+                }];
+                readonly internalType: "struct TokenData";
+                readonly name: "token";
+                readonly type: "tuple";
+            }, {
+                readonly internalType: "uint120";
+                readonly name: "value";
+                readonly type: "uint120";
+            }];
+            readonly internalType: "struct CommitmentPreimage";
+            readonly name: "preimage";
+            readonly type: "tuple";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "bytes32[3]";
+                readonly name: "encryptedBundle";
+                readonly type: "bytes32[3]";
+            }, {
+                readonly internalType: "bytes32";
+                readonly name: "shieldKey";
+                readonly type: "bytes32";
+            }];
+            readonly internalType: "struct ShieldCiphertext";
+            readonly name: "ciphertext";
+            readonly type: "tuple";
+        }];
+        readonly internalType: "struct ShieldRequest[]";
+        readonly name: "_shieldRequests";
+        readonly type: "tuple[]";
+    }];
+    readonly name: "shield";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "enum TokenType";
+                readonly name: "tokenType";
+                readonly type: "uint8";
+            }, {
+                readonly internalType: "address";
+                readonly name: "tokenAddress";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "tokenSubID";
+                readonly type: "uint256";
+            }];
+            readonly internalType: "struct TokenData";
+            readonly name: "token";
+            readonly type: "tuple";
+        }, {
+            readonly internalType: "address";
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "value";
+            readonly type: "uint256";
+        }];
+        readonly internalType: "struct RelayAdapt7702.TokenTransfer[]";
+        readonly name: "_transfers";
+        readonly type: "tuple[]";
+    }];
+    readonly name: "transfer";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "unwrapBase";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "wBase";
+    readonly outputs: readonly [{
+        readonly internalType: "contract IWBase";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "wrapBase";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly stateMutability: "payable";
+    readonly type: "receive";
+}];
+/**
+ * Type-safe ABI for RelayAdapt7702_json
+ */
+export type RelayAdapt7702_jsonAbi = typeof RelayAdapt7702_jsonAbi;
+/**
+ * Contract instance type for RelayAdapt7702_json
+ */
+export type RelayAdapt7702_jsonContract = any;
+/**
+ * RelayAdapt7702_json Contract Class
+ *
+ * Provides a class-based API similar to TypeChain for interacting with the contract.
+ *
+ * @example
+ * ```typescript
+ * import { createPublicClient, createWalletClient, http } from 'viem';
+ * import { mainnet } from 'viem/chains';
+ * import { RelayAdapt7702_json } from 'RelayAdapt7702_json';
+ *
+ * const publicClient = createPublicClient({ chain: mainnet, transport: http() });
+ * const walletClient = createWalletClient({ chain: mainnet, transport: http() });
+ *
+ * const contract = new RelayAdapt7702_json('0x...', { publicClient, walletClient });
+ *
+ * // Read functions
+ * const result = await contract.balanceOf('0x...');
+ *
+ * // Write functions
+ * const hash = await contract.transfer('0x...', 1000n);
+ *
+ * // Simulate transactions (dry-run)
+ * const simulation = await contract.simulate.transfer('0x...', 1000n);
+ * console.log('Gas estimate:', simulation.request.gas);
+ *
+ * // Watch events
+ * const unwatch = contract.watch.Transfer((event) => {
+ *   console.log('Transfer event:', event);
+ * });
+ * ```
+ */
+export declare class RelayAdapt7702_json {
+    private contract;
+    private contractAddress;
+    private publicClient;
+    constructor(address: Address, clients: {
+        publicClient: PublicClient;
+        walletClient?: WalletClient;
+    });
+    /**
+     * Get the contract address
+     */
+    get address(): Address;
+    /**
+     * Get the underlying viem contract instance
+     */
+    getContract(): RelayAdapt7702_jsonContract;
+    /**
+     * DOMAIN_SEPARATOR
+     * view
+     */
+    DOMAIN_SEPARATOR(): Promise<`0x${string}`>;
+    /**
+     * EXECUTE_TYPEHASH
+     * view
+     */
+    EXECUTE_TYPEHASH(): Promise<`0x${string}`>;
+    /**
+     * MULTICALL_TYPEHASH
+     * view
+     */
+    MULTICALL_TYPEHASH(): Promise<`0x${string}`>;
+    /**
+     * adaptImplementation
+     * view
+     */
+    adaptImplementation(): Promise<`0x${string}`>;
+    /**
+     * getExecutePayloadHash
+     * pure
+     */
+    getExecutePayloadHash(_transactions: Transaction[], _actionData: RelayAdapt7702_ActionData, _nonce: bigint): Promise<`0x${string}`>;
+    /**
+     * getMulticallPayloadHash
+     * pure
+     */
+    getMulticallPayloadHash(_requireSuccess: boolean, _calls: RelayAdapt7702_Call[], _nonce: bigint): Promise<`0x${string}`>;
+    /**
+     * nonce
+     * view
+     */
+    nonce(): Promise<bigint>;
+    /**
+     * railgun
+     * view
+     */
+    railgun(): Promise<`0x${string}`>;
+    /**
+     * wBase
+     * view
+     */
+    wBase(): Promise<`0x${string}`>;
+    /**
+     * execute
+     * payable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    execute(_transactions: Transaction[], _actionData: RelayAdapt7702_ActionData, _nonce: bigint, _signature: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * multicall
+     * payable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    multicall(_requireSuccess: boolean, _calls: RelayAdapt7702_Call[], _nonce: bigint, _signature: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * shield
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    shield(_shieldRequests: ShieldRequest[], options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * transfer
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    transfer(_transfers: RelayAdapt7702_TokenTransfer[], options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * unwrapBase
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    unwrapBase(_amount: bigint, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * wrapBase
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    wrapBase(_amount: bigint, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * Simulate contract write operations (dry-run without sending transaction)
+     *
+     * @example
+     * const result = await contract.simulate.transfer('0x...', 1000n);
+     * console.log('Gas estimate:', result.request.gas);
+     * console.log('Would succeed:', result.result);
+     */
+    get simulate(): {
+        /**
+         * Simulate execute
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        execute(_transactions: Transaction[], _actionData: RelayAdapt7702_ActionData, _nonce: bigint, _signature: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate multicall
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        multicall(_requireSuccess: boolean, _calls: RelayAdapt7702_Call[], _nonce: bigint, _signature: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate shield
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        shield(_shieldRequests: ShieldRequest[], options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate transfer
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        transfer(_transfers: RelayAdapt7702_TokenTransfer[], options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate unwrapBase
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        unwrapBase(_amount: bigint, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate wrapBase
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        wrapBase(_amount: bigint, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+    };
+    /**
+     * Watch contract events
+     *
+     * @example
+     * // Watch all Transfer events
+     * const unwatch = contract.watch.Transfer((event) => {
+     *   console.log('Transfer:', event);
+     * });
+     *
+     * // Stop watching
+     * unwatch();
+     */
+    get watch(): {
+        /**
+         * Watch CallError events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        CallError: (callback: (event: {
+            callIndex: bigint;
+            revertReason: `0x${string}`;
+        }) => void) => () => void;
+    };
+}