@gitmyabi/gnosissafe 1.0.0

package/contracts/GnosisSafe_json.js

@@ -0,0 +1,1806 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GnosisSafe_json = exports.GnosisSafe_jsonAbi = void 0;
+const viem_1 = require("viem");
+/**
+ * GnosisSafe_json ABI
+ *
+ * This ABI is typed using viem's type system for full type safety.
+ */
+exports.GnosisSafe_jsonAbi = [
+    {
+        "inputs": [],
+        "stateMutability": "nonpayable",
+        "type": "constructor"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": false,
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            }
+        ],
+        "name": "AddedOwner",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "bytes32",
+                "name": "approvedHash",
+                "type": "bytes32"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            }
+        ],
+        "name": "ApproveHash",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": false,
+                "internalType": "address",
+                "name": "handler",
+                "type": "address"
+            }
+        ],
+        "name": "ChangedFallbackHandler",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": false,
+                "internalType": "address",
+                "name": "guard",
+                "type": "address"
+            }
+        ],
+        "name": "ChangedGuard",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "threshold",
+                "type": "uint256"
+            }
+        ],
+        "name": "ChangedThreshold",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": false,
+                "internalType": "address",
+                "name": "module",
+                "type": "address"
+            }
+        ],
+        "name": "DisabledModule",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": false,
+                "internalType": "address",
+                "name": "module",
+                "type": "address"
+            }
+        ],
+        "name": "EnabledModule",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": false,
+                "internalType": "bytes32",
+                "name": "txHash",
+                "type": "bytes32"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "payment",
+                "type": "uint256"
+            }
+        ],
+        "name": "ExecutionFailure",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "module",
+                "type": "address"
+            }
+        ],
+        "name": "ExecutionFromModuleFailure",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "module",
+                "type": "address"
+            }
+        ],
+        "name": "ExecutionFromModuleSuccess",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": false,
+                "internalType": "bytes32",
+                "name": "txHash",
+                "type": "bytes32"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "payment",
+                "type": "uint256"
+            }
+        ],
+        "name": "ExecutionSuccess",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": false,
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            }
+        ],
+        "name": "RemovedOwner",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "sender",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "SafeReceived",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "initiator",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "address[]",
+                "name": "owners",
+                "type": "address[]"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "threshold",
+                "type": "uint256"
+            },
+            {
+                "indexed": false,
+                "internalType": "address",
+                "name": "initializer",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "address",
+                "name": "fallbackHandler",
+                "type": "address"
+            }
+        ],
+        "name": "SafeSetup",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "bytes32",
+                "name": "msgHash",
+                "type": "bytes32"
+            }
+        ],
+        "name": "SignMsg",
+        "type": "event"
+    },
+    {
+        "stateMutability": "nonpayable",
+        "type": "fallback"
+    },
+    {
+        "inputs": [],
+        "name": "VERSION",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "_threshold",
+                "type": "uint256"
+            }
+        ],
+        "name": "addOwnerWithThreshold",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes32",
+                "name": "hashToApprove",
+                "type": "bytes32"
+            }
+        ],
+        "name": "approveHash",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            },
+            {
+                "internalType": "bytes32",
+                "name": "",
+                "type": "bytes32"
+            }
+        ],
+        "name": "approvedHashes",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "_threshold",
+                "type": "uint256"
+            }
+        ],
+        "name": "changeThreshold",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes32",
+                "name": "dataHash",
+                "type": "bytes32"
+            },
+            {
+                "internalType": "bytes",
+                "name": "data",
+                "type": "bytes"
+            },
+            {
+                "internalType": "bytes",
+                "name": "signatures",
+                "type": "bytes"
+            },
+            {
+                "internalType": "uint256",
+                "name": "requiredSignatures",
+                "type": "uint256"
+            }
+        ],
+        "name": "checkNSignatures",
+        "outputs": [],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes32",
+                "name": "dataHash",
+                "type": "bytes32"
+            },
+            {
+                "internalType": "bytes",
+                "name": "data",
+                "type": "bytes"
+            },
+            {
+                "internalType": "bytes",
+                "name": "signatures",
+                "type": "bytes"
+            }
+        ],
+        "name": "checkSignatures",
+        "outputs": [],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "prevModule",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "module",
+                "type": "address"
+            }
+        ],
+        "name": "disableModule",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "domainSeparator",
+        "outputs": [
+            {
+                "internalType": "bytes32",
+                "name": "",
+                "type": "bytes32"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "module",
+                "type": "address"
+            }
+        ],
+        "name": "enableModule",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            },
+            {
+                "internalType": "bytes",
+                "name": "data",
+                "type": "bytes"
+            },
+            {
+                "internalType": "enum Enum.Operation",
+                "name": "operation",
+                "type": "uint8"
+            },
+            {
+                "internalType": "uint256",
+                "name": "safeTxGas",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "baseGas",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "gasPrice",
+                "type": "uint256"
+            },
+            {
+                "internalType": "address",
+                "name": "gasToken",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "refundReceiver",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "_nonce",
+                "type": "uint256"
+            }
+        ],
+        "name": "encodeTransactionData",
+        "outputs": [
+            {
+                "internalType": "bytes",
+                "name": "",
+                "type": "bytes"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            },
+            {
+                "internalType": "bytes",
+                "name": "data",
+                "type": "bytes"
+            },
+            {
+                "internalType": "enum Enum.Operation",
+                "name": "operation",
+                "type": "uint8"
+            },
+            {
+                "internalType": "uint256",
+                "name": "safeTxGas",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "baseGas",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "gasPrice",
+                "type": "uint256"
+            },
+            {
+                "internalType": "address",
+                "name": "gasToken",
+                "type": "address"
+            },
+            {
+                "internalType": "address payable",
+                "name": "refundReceiver",
+                "type": "address"
+            },
+            {
+                "internalType": "bytes",
+                "name": "signatures",
+                "type": "bytes"
+            }
+        ],
+        "name": "execTransaction",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "success",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "payable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            },
+            {
+                "internalType": "bytes",
+                "name": "data",
+                "type": "bytes"
+            },
+            {
+                "internalType": "enum Enum.Operation",
+                "name": "operation",
+                "type": "uint8"
+            }
+        ],
+        "name": "execTransactionFromModule",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "success",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            },
+            {
+                "internalType": "bytes",
+                "name": "data",
+                "type": "bytes"
+            },
+            {
+                "internalType": "enum Enum.Operation",
+                "name": "operation",
+                "type": "uint8"
+            }
+        ],
+        "name": "execTransactionFromModuleReturnData",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "success",
+                "type": "bool"
+            },
+            {
+                "internalType": "bytes",
+                "name": "returnData",
+                "type": "bytes"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "getChainId",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "start",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "pageSize",
+                "type": "uint256"
+            }
+        ],
+        "name": "getModulesPaginated",
+        "outputs": [
+            {
+                "internalType": "address[]",
+                "name": "array",
+                "type": "address[]"
+            },
+            {
+                "internalType": "address",
+                "name": "next",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "getOwners",
+        "outputs": [
+            {
+                "internalType": "address[]",
+                "name": "",
+                "type": "address[]"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "offset",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "length",
+                "type": "uint256"
+            }
+        ],
+        "name": "getStorageAt",
+        "outputs": [
+            {
+                "internalType": "bytes",
+                "name": "",
+                "type": "bytes"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "getThreshold",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            },
+            {
+                "internalType": "bytes",
+                "name": "data",
+                "type": "bytes"
+            },
+            {
+                "internalType": "enum Enum.Operation",
+                "name": "operation",
+                "type": "uint8"
+            },
+            {
+                "internalType": "uint256",
+                "name": "safeTxGas",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "baseGas",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "gasPrice",
+                "type": "uint256"
+            },
+            {
+                "internalType": "address",
+                "name": "gasToken",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "refundReceiver",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "_nonce",
+                "type": "uint256"
+            }
+        ],
+        "name": "getTransactionHash",
+        "outputs": [
+            {
+                "internalType": "bytes32",
+                "name": "",
+                "type": "bytes32"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "module",
+                "type": "address"
+            }
+        ],
+        "name": "isModuleEnabled",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            }
+        ],
+        "name": "isOwner",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "nonce",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "prevOwner",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "_threshold",
+                "type": "uint256"
+            }
+        ],
+        "name": "removeOwner",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            },
+            {
+                "internalType": "bytes",
+                "name": "data",
+                "type": "bytes"
+            },
+            {
+                "internalType": "enum Enum.Operation",
+                "name": "operation",
+                "type": "uint8"
+            }
+        ],
+        "name": "requiredTxGas",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "handler",
+                "type": "address"
+            }
+        ],
+        "name": "setFallbackHandler",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "guard",
+                "type": "address"
+            }
+        ],
+        "name": "setGuard",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address[]",
+                "name": "_owners",
+                "type": "address[]"
+            },
+            {
+                "internalType": "uint256",
+                "name": "_threshold",
+                "type": "uint256"
+            },
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "bytes",
+                "name": "data",
+                "type": "bytes"
+            },
+            {
+                "internalType": "address",
+                "name": "fallbackHandler",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "paymentToken",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "payment",
+                "type": "uint256"
+            },
+            {
+                "internalType": "address payable",
+                "name": "paymentReceiver",
+                "type": "address"
+            }
+        ],
+        "name": "setup",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes32",
+                "name": "",
+                "type": "bytes32"
+            }
+        ],
+        "name": "signedMessages",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "targetContract",
+                "type": "address"
+            },
+            {
+                "internalType": "bytes",
+                "name": "calldataPayload",
+                "type": "bytes"
+            }
+        ],
+        "name": "simulateAndRevert",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "prevOwner",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "oldOwner",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "newOwner",
+                "type": "address"
+            }
+        ],
+        "name": "swapOwner",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "stateMutability": "payable",
+        "type": "receive"
+    }
+];
+/**
+ * GnosisSafe_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 { GnosisSafe_json } from 'GnosisSafe_json';
+ *
+ * const publicClient = createPublicClient({ chain: mainnet, transport: http() });
+ * const walletClient = createWalletClient({ chain: mainnet, transport: http() });
+ *
+ * const contract = new GnosisSafe_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);
+ * });
+ * ```
+ */
+class GnosisSafe_json {
+    constructor(address, clients) {
+        this.contractAddress = address;
+        this.publicClient = clients.publicClient;
+        this.contract = (0, viem_1.getContract)({
+            address,
+            abi: exports.GnosisSafe_jsonAbi,
+            client: {
+                public: clients.publicClient,
+                wallet: clients.walletClient,
+            },
+        });
+    }
+    /**
+     * Get the contract address
+     */
+    get address() {
+        return this.contractAddress;
+    }
+    /**
+     * Get the underlying viem contract instance
+     */
+    getContract() {
+        return this.contract;
+    }
+    /**
+     * VERSION
+     * view
+     */
+    async VERSION() {
+        return this.contract.read.VERSION();
+    }
+    /**
+     * approvedHashes
+     * view
+     */
+    async approvedHashes(arg0, arg1) {
+        return this.contract.read.approvedHashes([arg0, arg1]);
+    }
+    /**
+     * checkNSignatures
+     * view
+     */
+    async checkNSignatures(dataHash, data, signatures, requiredSignatures) {
+        return this.contract.read.checkNSignatures([dataHash, data, signatures, requiredSignatures]);
+    }
+    /**
+     * checkSignatures
+     * view
+     */
+    async checkSignatures(dataHash, data, signatures) {
+        return this.contract.read.checkSignatures([dataHash, data, signatures]);
+    }
+    /**
+     * domainSeparator
+     * view
+     */
+    async domainSeparator() {
+        return this.contract.read.domainSeparator();
+    }
+    /**
+     * encodeTransactionData
+     * view
+     */
+    async encodeTransactionData(to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, _nonce) {
+        return this.contract.read.encodeTransactionData([to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, _nonce]);
+    }
+    /**
+     * getChainId
+     * view
+     */
+    async getChainId() {
+        return this.contract.read.getChainId();
+    }
+    /**
+     * getModulesPaginated
+     * view
+     */
+    async getModulesPaginated(start, pageSize) {
+        return this.contract.read.getModulesPaginated([start, pageSize]);
+    }
+    /**
+     * getOwners
+     * view
+     */
+    async getOwners() {
+        return this.contract.read.getOwners();
+    }
+    /**
+     * getStorageAt
+     * view
+     */
+    async getStorageAt(offset, length) {
+        return this.contract.read.getStorageAt([offset, length]);
+    }
+    /**
+     * getThreshold
+     * view
+     */
+    async getThreshold() {
+        return this.contract.read.getThreshold();
+    }
+    /**
+     * getTransactionHash
+     * view
+     */
+    async getTransactionHash(to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, _nonce) {
+        return this.contract.read.getTransactionHash([to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, _nonce]);
+    }
+    /**
+     * isModuleEnabled
+     * view
+     */
+    async isModuleEnabled(module) {
+        return this.contract.read.isModuleEnabled([module]);
+    }
+    /**
+     * isOwner
+     * view
+     */
+    async isOwner(owner) {
+        return this.contract.read.isOwner([owner]);
+    }
+    /**
+     * nonce
+     * view
+     */
+    async nonce() {
+        return this.contract.read.nonce();
+    }
+    /**
+     * signedMessages
+     * view
+     */
+    async signedMessages(arg0) {
+        return this.contract.read.signedMessages([arg0]);
+    }
+    /**
+     * addOwnerWithThreshold
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    async addOwnerWithThreshold(owner, _threshold, options) {
+        if (!this.contract.write) {
+            throw new Error('Wallet client is required for write operations');
+        }
+        return this.contract.write.addOwnerWithThreshold([owner, _threshold], options);
+    }
+    /**
+     * approveHash
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    async approveHash(hashToApprove, options) {
+        if (!this.contract.write) {
+            throw new Error('Wallet client is required for write operations');
+        }
+        return this.contract.write.approveHash([hashToApprove], options);
+    }
+    /**
+     * changeThreshold
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    async changeThreshold(_threshold, options) {
+        if (!this.contract.write) {
+            throw new Error('Wallet client is required for write operations');
+        }
+        return this.contract.write.changeThreshold([_threshold], options);
+    }
+    /**
+     * disableModule
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    async disableModule(prevModule, module, options) {
+        if (!this.contract.write) {
+            throw new Error('Wallet client is required for write operations');
+        }
+        return this.contract.write.disableModule([prevModule, module], options);
+    }
+    /**
+     * enableModule
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    async enableModule(module, options) {
+        if (!this.contract.write) {
+            throw new Error('Wallet client is required for write operations');
+        }
+        return this.contract.write.enableModule([module], options);
+    }
+    /**
+     * execTransaction
+     * payable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    async execTransaction(to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, signatures, options) {
+        if (!this.contract.write) {
+            throw new Error('Wallet client is required for write operations');
+        }
+        return this.contract.write.execTransaction([to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, signatures], options);
+    }
+    /**
+     * execTransactionFromModule
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    async execTransactionFromModule(to, value, data, operation, options) {
+        if (!this.contract.write) {
+            throw new Error('Wallet client is required for write operations');
+        }
+        return this.contract.write.execTransactionFromModule([to, value, data, operation], options);
+    }
+    /**
+     * execTransactionFromModuleReturnData
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    async execTransactionFromModuleReturnData(to, value, data, operation, options) {
+        if (!this.contract.write) {
+            throw new Error('Wallet client is required for write operations');
+        }
+        return this.contract.write.execTransactionFromModuleReturnData([to, value, data, operation], options);
+    }
+    /**
+     * removeOwner
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    async removeOwner(prevOwner, owner, _threshold, options) {
+        if (!this.contract.write) {
+            throw new Error('Wallet client is required for write operations');
+        }
+        return this.contract.write.removeOwner([prevOwner, owner, _threshold], options);
+    }
+    /**
+     * requiredTxGas
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    async requiredTxGas(to, value, data, operation, options) {
+        if (!this.contract.write) {
+            throw new Error('Wallet client is required for write operations');
+        }
+        return this.contract.write.requiredTxGas([to, value, data, operation], options);
+    }
+    /**
+     * setFallbackHandler
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    async setFallbackHandler(handler, options) {
+        if (!this.contract.write) {
+            throw new Error('Wallet client is required for write operations');
+        }
+        return this.contract.write.setFallbackHandler([handler], options);
+    }
+    /**
+     * setGuard
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    async setGuard(guard, options) {
+        if (!this.contract.write) {
+            throw new Error('Wallet client is required for write operations');
+        }
+        return this.contract.write.setGuard([guard], options);
+    }
+    /**
+     * setup
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    async setup(_owners, _threshold, to, data, fallbackHandler, paymentToken, payment, paymentReceiver, options) {
+        if (!this.contract.write) {
+            throw new Error('Wallet client is required for write operations');
+        }
+        return this.contract.write.setup([_owners, _threshold, to, data, fallbackHandler, paymentToken, payment, paymentReceiver], options);
+    }
+    /**
+     * simulateAndRevert
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    async simulateAndRevert(targetContract, calldataPayload, options) {
+        if (!this.contract.write) {
+            throw new Error('Wallet client is required for write operations');
+        }
+        return this.contract.write.simulateAndRevert([targetContract, calldataPayload], options);
+    }
+    /**
+     * swapOwner
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    async swapOwner(prevOwner, oldOwner, newOwner, options) {
+        if (!this.contract.write) {
+            throw new Error('Wallet client is required for write operations');
+        }
+        return this.contract.write.swapOwner([prevOwner, oldOwner, newOwner], options);
+    }
+    /**
+     * 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() {
+        const contract = this.contract;
+        if (!contract.simulate) {
+            throw new Error('Public client is required for simulation');
+        }
+        return {
+            /**
+             * Simulate addOwnerWithThreshold
+             * Returns gas estimate and result without sending transaction
+             * @param options Optional transaction parameters (value, gas, nonce, etc.)
+             */
+            async addOwnerWithThreshold(owner, _threshold, options) {
+                return contract.simulate.addOwnerWithThreshold([owner, _threshold], options);
+            },
+            /**
+             * Simulate approveHash
+             * Returns gas estimate and result without sending transaction
+             * @param options Optional transaction parameters (value, gas, nonce, etc.)
+             */
+            async approveHash(hashToApprove, options) {
+                return contract.simulate.approveHash([hashToApprove], options);
+            },
+            /**
+             * Simulate changeThreshold
+             * Returns gas estimate and result without sending transaction
+             * @param options Optional transaction parameters (value, gas, nonce, etc.)
+             */
+            async changeThreshold(_threshold, options) {
+                return contract.simulate.changeThreshold([_threshold], options);
+            },
+            /**
+             * Simulate disableModule
+             * Returns gas estimate and result without sending transaction
+             * @param options Optional transaction parameters (value, gas, nonce, etc.)
+             */
+            async disableModule(prevModule, module, options) {
+                return contract.simulate.disableModule([prevModule, module], options);
+            },
+            /**
+             * Simulate enableModule
+             * Returns gas estimate and result without sending transaction
+             * @param options Optional transaction parameters (value, gas, nonce, etc.)
+             */
+            async enableModule(module, options) {
+                return contract.simulate.enableModule([module], options);
+            },
+            /**
+             * Simulate execTransaction
+             * Returns gas estimate and result without sending transaction
+             * @param options Optional transaction parameters (value, gas, nonce, etc.)
+             */
+            async execTransaction(to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, signatures, options) {
+                return contract.simulate.execTransaction([to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, signatures], options);
+            },
+            /**
+             * Simulate execTransactionFromModule
+             * Returns gas estimate and result without sending transaction
+             * @param options Optional transaction parameters (value, gas, nonce, etc.)
+             */
+            async execTransactionFromModule(to, value, data, operation, options) {
+                return contract.simulate.execTransactionFromModule([to, value, data, operation], options);
+            },
+            /**
+             * Simulate execTransactionFromModuleReturnData
+             * Returns gas estimate and result without sending transaction
+             * @param options Optional transaction parameters (value, gas, nonce, etc.)
+             */
+            async execTransactionFromModuleReturnData(to, value, data, operation, options) {
+                return contract.simulate.execTransactionFromModuleReturnData([to, value, data, operation], options);
+            },
+            /**
+             * Simulate removeOwner
+             * Returns gas estimate and result without sending transaction
+             * @param options Optional transaction parameters (value, gas, nonce, etc.)
+             */
+            async removeOwner(prevOwner, owner, _threshold, options) {
+                return contract.simulate.removeOwner([prevOwner, owner, _threshold], options);
+            },
+            /**
+             * Simulate requiredTxGas
+             * Returns gas estimate and result without sending transaction
+             * @param options Optional transaction parameters (value, gas, nonce, etc.)
+             */
+            async requiredTxGas(to, value, data, operation, options) {
+                return contract.simulate.requiredTxGas([to, value, data, operation], options);
+            },
+            /**
+             * Simulate setFallbackHandler
+             * Returns gas estimate and result without sending transaction
+             * @param options Optional transaction parameters (value, gas, nonce, etc.)
+             */
+            async setFallbackHandler(handler, options) {
+                return contract.simulate.setFallbackHandler([handler], options);
+            },
+            /**
+             * Simulate setGuard
+             * Returns gas estimate and result without sending transaction
+             * @param options Optional transaction parameters (value, gas, nonce, etc.)
+             */
+            async setGuard(guard, options) {
+                return contract.simulate.setGuard([guard], options);
+            },
+            /**
+             * Simulate setup
+             * Returns gas estimate and result without sending transaction
+             * @param options Optional transaction parameters (value, gas, nonce, etc.)
+             */
+            async setup(_owners, _threshold, to, data, fallbackHandler, paymentToken, payment, paymentReceiver, options) {
+                return contract.simulate.setup([_owners, _threshold, to, data, fallbackHandler, paymentToken, payment, paymentReceiver], options);
+            },
+            /**
+             * Simulate simulateAndRevert
+             * Returns gas estimate and result without sending transaction
+             * @param options Optional transaction parameters (value, gas, nonce, etc.)
+             */
+            async simulateAndRevert(targetContract, calldataPayload, options) {
+                return contract.simulate.simulateAndRevert([targetContract, calldataPayload], options);
+            },
+            /**
+             * Simulate swapOwner
+             * Returns gas estimate and result without sending transaction
+             * @param options Optional transaction parameters (value, gas, nonce, etc.)
+             */
+            async swapOwner(prevOwner, oldOwner, newOwner, options) {
+                return contract.simulate.swapOwner([prevOwner, oldOwner, newOwner], options);
+            }
+        };
+    }
+    /**
+     * Watch contract events
+     *
+     * @example
+     * // Watch all Transfer events
+     * const unwatch = contract.watch.Transfer((event) => {
+     *   console.log('Transfer:', event);
+     * });
+     *
+     * // Stop watching
+     * unwatch();
+     */
+    get watch() {
+        return {
+            /**
+             * Watch AddedOwner events
+             * @param callback Function to call when event is emitted
+             * @param filter Optional filter for indexed parameters
+             * @returns Unwatch function to stop listening
+             */
+            AddedOwner: (callback) => {
+                return this.publicClient.watchContractEvent({
+                    address: this.contractAddress,
+                    abi: exports.GnosisSafe_jsonAbi,
+                    eventName: 'AddedOwner',
+                    onLogs: (logs) => {
+                        logs.forEach((log) => {
+                            callback(log.args);
+                        });
+                    },
+                });
+            },
+            /**
+             * Watch ApproveHash events
+             * @param callback Function to call when event is emitted
+             * @param filter Optional filter for indexed parameters
+             * @returns Unwatch function to stop listening
+             */
+            ApproveHash: (callback, filter) => {
+                return this.publicClient.watchContractEvent({
+                    address: this.contractAddress,
+                    abi: exports.GnosisSafe_jsonAbi,
+                    eventName: 'ApproveHash',
+                    args: filter,
+                    onLogs: (logs) => {
+                        logs.forEach((log) => {
+                            callback(log.args);
+                        });
+                    },
+                });
+            },
+            /**
+             * Watch ChangedFallbackHandler events
+             * @param callback Function to call when event is emitted
+             * @param filter Optional filter for indexed parameters
+             * @returns Unwatch function to stop listening
+             */
+            ChangedFallbackHandler: (callback) => {
+                return this.publicClient.watchContractEvent({
+                    address: this.contractAddress,
+                    abi: exports.GnosisSafe_jsonAbi,
+                    eventName: 'ChangedFallbackHandler',
+                    onLogs: (logs) => {
+                        logs.forEach((log) => {
+                            callback(log.args);
+                        });
+                    },
+                });
+            },
+            /**
+             * Watch ChangedGuard events
+             * @param callback Function to call when event is emitted
+             * @param filter Optional filter for indexed parameters
+             * @returns Unwatch function to stop listening
+             */
+            ChangedGuard: (callback) => {
+                return this.publicClient.watchContractEvent({
+                    address: this.contractAddress,
+                    abi: exports.GnosisSafe_jsonAbi,
+                    eventName: 'ChangedGuard',
+                    onLogs: (logs) => {
+                        logs.forEach((log) => {
+                            callback(log.args);
+                        });
+                    },
+                });
+            },
+            /**
+             * Watch ChangedThreshold events
+             * @param callback Function to call when event is emitted
+             * @param filter Optional filter for indexed parameters
+             * @returns Unwatch function to stop listening
+             */
+            ChangedThreshold: (callback) => {
+                return this.publicClient.watchContractEvent({
+                    address: this.contractAddress,
+                    abi: exports.GnosisSafe_jsonAbi,
+                    eventName: 'ChangedThreshold',
+                    onLogs: (logs) => {
+                        logs.forEach((log) => {
+                            callback(log.args);
+                        });
+                    },
+                });
+            },
+            /**
+             * Watch DisabledModule events
+             * @param callback Function to call when event is emitted
+             * @param filter Optional filter for indexed parameters
+             * @returns Unwatch function to stop listening
+             */
+            DisabledModule: (callback) => {
+                return this.publicClient.watchContractEvent({
+                    address: this.contractAddress,
+                    abi: exports.GnosisSafe_jsonAbi,
+                    eventName: 'DisabledModule',
+                    onLogs: (logs) => {
+                        logs.forEach((log) => {
+                            callback(log.args);
+                        });
+                    },
+                });
+            },
+            /**
+             * Watch EnabledModule events
+             * @param callback Function to call when event is emitted
+             * @param filter Optional filter for indexed parameters
+             * @returns Unwatch function to stop listening
+             */
+            EnabledModule: (callback) => {
+                return this.publicClient.watchContractEvent({
+                    address: this.contractAddress,
+                    abi: exports.GnosisSafe_jsonAbi,
+                    eventName: 'EnabledModule',
+                    onLogs: (logs) => {
+                        logs.forEach((log) => {
+                            callback(log.args);
+                        });
+                    },
+                });
+            },
+            /**
+             * Watch ExecutionFailure events
+             * @param callback Function to call when event is emitted
+             * @param filter Optional filter for indexed parameters
+             * @returns Unwatch function to stop listening
+             */
+            ExecutionFailure: (callback) => {
+                return this.publicClient.watchContractEvent({
+                    address: this.contractAddress,
+                    abi: exports.GnosisSafe_jsonAbi,
+                    eventName: 'ExecutionFailure',
+                    onLogs: (logs) => {
+                        logs.forEach((log) => {
+                            callback(log.args);
+                        });
+                    },
+                });
+            },
+            /**
+             * Watch ExecutionFromModuleFailure events
+             * @param callback Function to call when event is emitted
+             * @param filter Optional filter for indexed parameters
+             * @returns Unwatch function to stop listening
+             */
+            ExecutionFromModuleFailure: (callback, filter) => {
+                return this.publicClient.watchContractEvent({
+                    address: this.contractAddress,
+                    abi: exports.GnosisSafe_jsonAbi,
+                    eventName: 'ExecutionFromModuleFailure',
+                    args: filter,
+                    onLogs: (logs) => {
+                        logs.forEach((log) => {
+                            callback(log.args);
+                        });
+                    },
+                });
+            },
+            /**
+             * Watch ExecutionFromModuleSuccess events
+             * @param callback Function to call when event is emitted
+             * @param filter Optional filter for indexed parameters
+             * @returns Unwatch function to stop listening
+             */
+            ExecutionFromModuleSuccess: (callback, filter) => {
+                return this.publicClient.watchContractEvent({
+                    address: this.contractAddress,
+                    abi: exports.GnosisSafe_jsonAbi,
+                    eventName: 'ExecutionFromModuleSuccess',
+                    args: filter,
+                    onLogs: (logs) => {
+                        logs.forEach((log) => {
+                            callback(log.args);
+                        });
+                    },
+                });
+            },
+            /**
+             * Watch ExecutionSuccess events
+             * @param callback Function to call when event is emitted
+             * @param filter Optional filter for indexed parameters
+             * @returns Unwatch function to stop listening
+             */
+            ExecutionSuccess: (callback) => {
+                return this.publicClient.watchContractEvent({
+                    address: this.contractAddress,
+                    abi: exports.GnosisSafe_jsonAbi,
+                    eventName: 'ExecutionSuccess',
+                    onLogs: (logs) => {
+                        logs.forEach((log) => {
+                            callback(log.args);
+                        });
+                    },
+                });
+            },
+            /**
+             * Watch RemovedOwner events
+             * @param callback Function to call when event is emitted
+             * @param filter Optional filter for indexed parameters
+             * @returns Unwatch function to stop listening
+             */
+            RemovedOwner: (callback) => {
+                return this.publicClient.watchContractEvent({
+                    address: this.contractAddress,
+                    abi: exports.GnosisSafe_jsonAbi,
+                    eventName: 'RemovedOwner',
+                    onLogs: (logs) => {
+                        logs.forEach((log) => {
+                            callback(log.args);
+                        });
+                    },
+                });
+            },
+            /**
+             * Watch SafeReceived events
+             * @param callback Function to call when event is emitted
+             * @param filter Optional filter for indexed parameters
+             * @returns Unwatch function to stop listening
+             */
+            SafeReceived: (callback, filter) => {
+                return this.publicClient.watchContractEvent({
+                    address: this.contractAddress,
+                    abi: exports.GnosisSafe_jsonAbi,
+                    eventName: 'SafeReceived',
+                    args: filter,
+                    onLogs: (logs) => {
+                        logs.forEach((log) => {
+                            callback(log.args);
+                        });
+                    },
+                });
+            },
+            /**
+             * Watch SafeSetup events
+             * @param callback Function to call when event is emitted
+             * @param filter Optional filter for indexed parameters
+             * @returns Unwatch function to stop listening
+             */
+            SafeSetup: (callback, filter) => {
+                return this.publicClient.watchContractEvent({
+                    address: this.contractAddress,
+                    abi: exports.GnosisSafe_jsonAbi,
+                    eventName: 'SafeSetup',
+                    args: filter,
+                    onLogs: (logs) => {
+                        logs.forEach((log) => {
+                            callback(log.args);
+                        });
+                    },
+                });
+            },
+            /**
+             * Watch SignMsg events
+             * @param callback Function to call when event is emitted
+             * @param filter Optional filter for indexed parameters
+             * @returns Unwatch function to stop listening
+             */
+            SignMsg: (callback, filter) => {
+                return this.publicClient.watchContractEvent({
+                    address: this.contractAddress,
+                    abi: exports.GnosisSafe_jsonAbi,
+                    eventName: 'SignMsg',
+                    args: filter,
+                    onLogs: (logs) => {
+                        logs.forEach((log) => {
+                            callback(log.args);
+                        });
+                    },
+                });
+            }
+        };
+    }
+}
+exports.GnosisSafe_json = GnosisSafe_json;