@safe-global/protocol-kit 5.2.2 → 6.0.0-alpha.1

package/dist/esm/test-utils/index.mjs

@@ -0,0 +1,4217 @@
+// test-utils/webauthnShim.ts
+import { p256 } from "@noble/curves/p256";
+import { ethers } from "ethers";
+import CBOR from "cbor";
+function base64UrlEncode(data) {
+  const buffer = typeof data === "string" ? Buffer.from(data.replace(/^0x/, ""), "hex") : Buffer.from(data);
+  return buffer.toString("base64url");
+}
+function userVerificationFlag(userVerification = "preferred") {
+  switch (userVerification) {
+    case "preferred":
+      return 1;
+    case "required":
+      return 4;
+    default:
+      throw new Error(`user verification requirement ${userVerification} not supported`);
+  }
+}
+function b2ab(buf) {
+  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+}
+function isEqualArray(a, b) {
+  if (a.length != b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] != b[i]) return false;
+  return true;
+}
+function encodeWebAuthnSigningMessage(clientData, authenticatorData) {
+  return ethers.getBytes(
+    ethers.concat([
+      authenticatorData,
+      ethers.sha256(ethers.toUtf8Bytes(JSON.stringify(clientData)))
+    ])
+  );
+}
+var Credential = class {
+  constructor(rp, user, pk) {
+    this.rp = rp;
+    this.user = user;
+    this.pk = pk || p256.utils.normPrivateKeyToScalar(p256.utils.randomPrivateKey());
+    this.id = ethers.dataSlice(
+      ethers.keccak256(ethers.dataSlice(p256.getPublicKey(this.pk, false), 1)),
+      12
+    );
+    this.rawId = ethers.getBytes(this.id);
+  }
+  /**
+   * Computes the COSE encoded public key for this credential.
+   * See <https://datatracker.ietf.org/doc/html/rfc8152>.
+   *
+   * @returns Hex-encoded COSE-encoded public key
+   */
+  cosePublicKey() {
+    const pubk = p256.getPublicKey(this.pk, false);
+    const x = pubk.subarray(1, 33);
+    const y = pubk.subarray(33, 65);
+    const key = /* @__PURE__ */ new Map();
+    key.set(-1, 1);
+    key.set(-2, b2ab(x));
+    key.set(-3, b2ab(y));
+    key.set(1, 2);
+    key.set(3, -7);
+    return ethers.hexlify(CBOR.encode(key));
+  }
+};
+var WebAuthnCredentials = class {
+  /**
+   * Creates a new instance of the WebAuthn credentials.
+   * @param privateKey The private key to use for the credentials. If not provided, a random key will be generated.
+   */
+  constructor(privateKey) {
+    this.privateKey = privateKey;
+    this.credentials = [];
+  }
+  /**
+   * This is a shim for `navigator.credentials.create` method.
+   * See <https://w3c.github.io/webappsec-credential-management/#dom-credentialscontainer-create>.
+   *
+   * @param options The public key credential creation options.
+   * @returns A public key credential with an attestation response.
+   */
+  create({
+    publicKey
+  }) {
+    if (!publicKey.pubKeyCredParams.some(({ alg }) => alg === -7)) {
+      throw new Error("unsupported signature algorithm(s)");
+    }
+    const credential = new Credential(publicKey.rp.id, publicKey.user.id, this.privateKey);
+    this.credentials.push(credential);
+    const clientData = {
+      type: "webauthn.create",
+      challenge: base64UrlEncode(publicKey.challenge),
+      origin: `https://${publicKey.rp.id}`
+    };
+    const attestationObject = {
+      authData: b2ab(
+        ethers.getBytes(
+          ethers.solidityPacked(
+            ["bytes32", "uint8", "uint32", "bytes16", "uint16", "bytes", "bytes"],
+            [
+              ethers.sha256(ethers.toUtf8Bytes(publicKey.rp.id)),
+              64 + userVerificationFlag(publicKey.userVerification),
+              // flags = attested_data + user_present
+              0,
+              // signCount
+              `0x${"42".repeat(16)}`,
+              // aaguid
+              ethers.dataLength(credential.id),
+              credential.id,
+              credential.cosePublicKey()
+            ]
+          )
+        )
+      ),
+      fmt: "none",
+      attStmt: {}
+    };
+    return {
+      id: base64UrlEncode(credential.rawId),
+      rawId: credential.rawId.slice(),
+      response: {
+        clientDataJSON: b2ab(ethers.toUtf8Bytes(JSON.stringify(clientData))),
+        attestationObject: b2ab(CBOR.encode(attestationObject)),
+        getPublicKey: () => b2ab(p256.getPublicKey(credential.pk, false))
+      },
+      type: "public-key"
+    };
+  }
+  /**
+   * This is a shim for `navigator.credentials.get` method.
+   * See <https://w3c.github.io/webappsec-credential-management/#dom-credentialscontainer-get>.
+   *
+   * @param options The public key credential request options.
+   * @returns A public key credential with an assertion response.
+   */
+  get({
+    publicKey
+  }) {
+    const credential = publicKey.allowCredentials.flatMap(({ id }) => this.credentials.filter((c) => isEqualArray(c.rawId, id))).at(0);
+    if (credential === void 0) {
+      throw new Error("credential not found");
+    }
+    const clientData = {
+      type: "webauthn.get",
+      challenge: base64UrlEncode(publicKey.challenge),
+      origin: `https://${credential.rp}`
+    };
+    const authenticatorData = ethers.solidityPacked(
+      ["bytes32", "uint8", "uint32"],
+      [
+        ethers.sha256(ethers.toUtf8Bytes(credential.rp)),
+        userVerificationFlag(publicKey.userVerification),
+        // flags = user_present
+        0
+        // signCount
+      ]
+    );
+    const message = encodeWebAuthnSigningMessage(clientData, authenticatorData);
+    const signature = p256.sign(message, credential.pk, {
+      lowS: false,
+      prehash: true
+    });
+    return {
+      id: base64UrlEncode(credential.rawId),
+      rawId: credential.rawId.slice(),
+      response: {
+        clientDataJSON: b2ab(ethers.toUtf8Bytes(JSON.stringify(clientData))),
+        authenticatorData: b2ab(ethers.getBytes(authenticatorData)),
+        signature: b2ab(signature.toDERRawBytes(false)),
+        userHandle: credential.user
+      },
+      type: "public-key"
+    };
+  }
+};
+
+// test-utils/passkeys.ts
+import { keccak256 as keccak2563, toBytes as toBytes4 } from "viem";
+
+// src/utils/types.ts
+import { isHex, defineChain, etherUnits } from "viem";
+import * as allChains from "viem/chains";
+function asHash(hash) {
+  return hash;
+}
+function asHex(hex) {
+  return isHex(hex) ? hex : `0x${hex}`;
+}
+function getChainById(chainId) {
+  const chain = Object.values(allChains).find((chain2) => chain2.id === Number(chainId));
+  if (chain) {
+    return chain;
+  } else {
+    return defineChain({
+      id: Number(chainId),
+      name: "Custom",
+      nativeCurrency: {
+        decimals: etherUnits.wei,
+        name: "Ether",
+        symbol: "ETH"
+      },
+      rpcUrls: {
+        default: {
+          http: [],
+          webSocket: []
+        }
+      }
+    });
+  }
+}
+
+// src/utils/constants.ts
+import { zeroAddress } from "viem";
+var SENTINEL_ADDRESS = "0x0000000000000000000000000000000000000001";
+
+// src/utils/address.ts
+function sameString(str1, str2) {
+  return !!str1 && !!str2 && str1.toLowerCase() === str2.toLowerCase();
+}
+function isSentinelAddress(address) {
+  return sameString(address, SENTINEL_ADDRESS);
+}
+
+// src/utils/eip-3770/index.ts
+import { isAddress } from "viem";
+
+// src/utils/eip-3770/config.ts
+var networks = [
+  { chainId: 1n, shortName: "eth" },
+  { chainId: 3n, shortName: "rop" },
+  { chainId: 4n, shortName: "rin" },
+  { chainId: 5n, shortName: "gor" },
+  { chainId: 10n, shortName: "oeth" },
+  { chainId: 11n, shortName: "meta" },
+  { chainId: 12n, shortName: "kal" },
+  { chainId: 14n, shortName: "flr" },
+  { chainId: 16n, shortName: "cflr" },
+  { chainId: 18n, shortName: "tst" },
+  { chainId: 19n, shortName: "sgb" },
+  { chainId: 25n, shortName: "cro" },
+  { chainId: 28n, shortName: "bobarinkeby" },
+  { chainId: 30n, shortName: "rsk" },
+  { chainId: 31n, shortName: "trsk" },
+  { chainId: 39n, shortName: "u2u" },
+  { chainId: 40n, shortName: "telosevm" },
+  { chainId: 41n, shortName: "telosevmtestnet" },
+  { chainId: 42n, shortName: "kov" },
+  { chainId: 43n, shortName: "pangolin" },
+  { chainId: 44n, shortName: "crab" },
+  { chainId: 46n, shortName: "darwinia" },
+  { chainId: 50n, shortName: "xdc" },
+  { chainId: 51n, shortName: "txdc" },
+  { chainId: 56n, shortName: "bnb" },
+  { chainId: 57n, shortName: "sys" },
+  { chainId: 61n, shortName: "etc" },
+  { chainId: 63n, shortName: "metc" },
+  { chainId: 69n, shortName: "okov" },
+  { chainId: 71n, shortName: "cfxtest" },
+  { chainId: 81n, shortName: "joc" },
+  { chainId: 82n, shortName: "meter" },
+  { chainId: 83n, shortName: "meter-test" },
+  { chainId: 88n, shortName: "vic" },
+  { chainId: 96n, shortName: "bkc" },
+  { chainId: 97n, shortName: "bnbt" },
+  { chainId: 100n, shortName: "gno" },
+  { chainId: 106n, shortName: "vlx" },
+  { chainId: 108n, shortName: "tt" },
+  { chainId: 109n, shortName: "shibariumecosystem" },
+  { chainId: 111n, shortName: "etl" },
+  { chainId: 114n, shortName: "c2flr" },
+  { chainId: 122n, shortName: "fuse" },
+  { chainId: 123n, shortName: "spark" },
+  { chainId: 130n, shortName: "unichain" },
+  { chainId: 133n, shortName: "HSKT" },
+  { chainId: 137n, shortName: "matic" },
+  { chainId: 146n, shortName: "sonic" },
+  { chainId: 148n, shortName: "shimmerevm" },
+  { chainId: 155n, shortName: "tenet-testnet" },
+  { chainId: 169n, shortName: "manta" },
+  { chainId: 177n, shortName: "hsk" },
+  { chainId: 179n, shortName: "abey" },
+  { chainId: 181n, shortName: "water" },
+  { chainId: 195n, shortName: "tokb" },
+  { chainId: 196n, shortName: "okb" },
+  { chainId: 204n, shortName: "opbnb" },
+  { chainId: 240n, shortName: "zkTCRO" },
+  { chainId: 246n, shortName: "ewt" },
+  { chainId: 250n, shortName: "ftm" },
+  { chainId: 252n, shortName: "fraxtal" },
+  { chainId: 255n, shortName: "kroma" },
+  { chainId: 274n, shortName: "lachain" },
+  { chainId: 280n, shortName: "zksync-goerli" },
+  { chainId: 282n, shortName: "zkTCRO" },
+  { chainId: 288n, shortName: "boba" },
+  { chainId: 291n, shortName: "orderly" },
+  { chainId: 300n, shortName: "zksync-sepolia" },
+  { chainId: 314n, shortName: "filecoin" },
+  { chainId: 321n, shortName: "kcs" },
+  { chainId: 322n, shortName: "kcst" },
+  { chainId: 324n, shortName: "zksync" },
+  { chainId: 336n, shortName: "sdn" },
+  { chainId: 338n, shortName: "tcro" },
+  { chainId: 360n, shortName: "shape" },
+  { chainId: 369n, shortName: "pls" },
+  { chainId: 388n, shortName: "zkCRO" },
+  { chainId: 418n, shortName: "latestnet" },
+  { chainId: 420n, shortName: "ogor" },
+  { chainId: 424n, shortName: "PGN" },
+  { chainId: 466n, shortName: "appchain" },
+  { chainId: 478n, shortName: "formnetwork" },
+  { chainId: 480n, shortName: "wc" },
+  { chainId: 530n, shortName: "FxCore" },
+  { chainId: 570n, shortName: "sys-rollux" },
+  { chainId: 588n, shortName: "metis-stardust" },
+  { chainId: 592n, shortName: "astr" },
+  { chainId: 595n, shortName: "maca" },
+  { chainId: 599n, shortName: "metis-goerli" },
+  { chainId: 648n, shortName: "ace" },
+  { chainId: 686n, shortName: "kar" },
+  { chainId: 690n, shortName: "redstone" },
+  { chainId: 787n, shortName: "aca" },
+  { chainId: 919n, shortName: "modesep" },
+  { chainId: 938n, shortName: "haust" },
+  { chainId: 943n, shortName: "t4pls" },
+  { chainId: 970n, shortName: "ccn" },
+  { chainId: 995n, shortName: "5ire" },
+  { chainId: 1001n, shortName: "baobab" },
+  { chainId: 1008n, shortName: "eun" },
+  { chainId: 1030n, shortName: "cfx" },
+  { chainId: 1088n, shortName: "metis-andromeda" },
+  { chainId: 1101n, shortName: "zkevm" },
+  { chainId: 1111n, shortName: "wemix" },
+  { chainId: 1112n, shortName: "twemix" },
+  { chainId: 1114n, shortName: "tcore2" },
+  { chainId: 1115n, shortName: "tcore" },
+  { chainId: 1116n, shortName: "core" },
+  { chainId: 1125n, shortName: "taker" },
+  { chainId: 1135n, shortName: "lisk" },
+  { chainId: 1230n, shortName: "UltronTestnet" },
+  { chainId: 1231n, shortName: "UltronMainnet" },
+  { chainId: 1284n, shortName: "mbeam" },
+  { chainId: 1285n, shortName: "mriver" },
+  { chainId: 1287n, shortName: "mbase" },
+  { chainId: 1294n, shortName: "bobabeam" },
+  { chainId: 1329n, shortName: "sei" },
+  { chainId: 1337n, shortName: "geth" },
+  { chainId: 1442n, shortName: "testnet-zkEVM-mango" },
+  { chainId: 1513n, shortName: "Story" },
+  { chainId: 1516n, shortName: "story-testnet" },
+  { chainId: 1559n, shortName: "tenet" },
+  { chainId: 1625n, shortName: "gravity" },
+  { chainId: 1663n, shortName: "Gobi" },
+  { chainId: 1729n, shortName: "reya" },
+  { chainId: 1750n, shortName: "metall2" },
+  { chainId: 1807n, shortName: "rana" },
+  { chainId: 1811n, shortName: "lif3-testnet" },
+  { chainId: 1890n, shortName: "lightlink_phoenix" },
+  { chainId: 1891n, shortName: "lightlink_pegasus" },
+  { chainId: 1923n, shortName: "swell-l2" },
+  { chainId: 1924n, shortName: "swell-l2-testnet" },
+  { chainId: 1984n, shortName: "euntest" },
+  { chainId: 1998n, shortName: "kyoto-testnet" },
+  { chainId: 2000n, shortName: "dc" },
+  { chainId: 2001n, shortName: "milkada" },
+  { chainId: 2002n, shortName: "milkalgo" },
+  { chainId: 2008n, shortName: "cloudwalk_testnet" },
+  { chainId: 2019n, shortName: "pmint_test" },
+  { chainId: 2020n, shortName: "pmint" },
+  { chainId: 2021n, shortName: "edg" },
+  { chainId: 2039n, shortName: "aleph" },
+  { chainId: 2187n, shortName: "g7" },
+  { chainId: 2192n, shortName: "snax" },
+  { chainId: 2221n, shortName: "tkava" },
+  { chainId: 2222n, shortName: "kava" },
+  { chainId: 2331n, shortName: "rss3-testnet" },
+  { chainId: 2358n, shortName: "kroma-sepolia" },
+  { chainId: 2442n, shortName: "zkevm-testnet-cardona" },
+  { chainId: 2810n, shortName: "hmorph" },
+  { chainId: 2818n, shortName: "morph" },
+  { chainId: 3338n, shortName: "PEAQ" },
+  { chainId: 3501n, shortName: "JFIN" },
+  { chainId: 3636n, shortName: "BTNX" },
+  { chainId: 3737n, shortName: "csb" },
+  { chainId: 3776n, shortName: "astrzk" },
+  { chainId: 4002n, shortName: "tftm" },
+  { chainId: 4061n, shortName: "Nahmii3Mainnet" },
+  { chainId: 4062n, shortName: "Nahmii3Testnet" },
+  { chainId: 4078n, shortName: "muster" },
+  { chainId: 4157n, shortName: "crossfi-testnet" },
+  { chainId: 4162n, shortName: "SXR" },
+  { chainId: 4202n, shortName: "lisksep" },
+  { chainId: 4337n, shortName: "beam" },
+  { chainId: 4460n, shortName: "orderlyl2" },
+  { chainId: 4653n, shortName: "gold" },
+  { chainId: 4661n, shortName: "appchaintestnet" },
+  { chainId: 4689n, shortName: "iotex-mainnet" },
+  { chainId: 4918n, shortName: "txvm" },
+  { chainId: 4919n, shortName: "xvm" },
+  { chainId: 5000n, shortName: "mantle" },
+  { chainId: 5001n, shortName: "mantle-testnet" },
+  { chainId: 5003n, shortName: "mnt-sep" },
+  { chainId: 5115n, shortName: "citrea-testnet" },
+  { chainId: 5165n, shortName: "ftn" },
+  { chainId: 5611n, shortName: "obnbt" },
+  { chainId: 5700n, shortName: "tsys" },
+  { chainId: 6001n, shortName: "bouncebit-mainnet" },
+  { chainId: 6102n, shortName: "cascadia" },
+  { chainId: 6321n, shortName: "eaura" },
+  { chainId: 6322n, shortName: "aura" },
+  { chainId: 6398n, shortName: "connext-sepolia" },
+  { chainId: 6688n, shortName: "iris" },
+  { chainId: 7000n, shortName: "zetachain-mainnet" },
+  { chainId: 7001n, shortName: "zetachain-testnet" },
+  { chainId: 7171n, shortName: "bitrock" },
+  { chainId: 7200n, shortName: "xsat" },
+  { chainId: 7332n, shortName: "EON" },
+  { chainId: 7341n, shortName: "shyft" },
+  { chainId: 7560n, shortName: "cyeth" },
+  { chainId: 7700n, shortName: "canto" },
+  { chainId: 7771n, shortName: "tbitrock" },
+  { chainId: 8192n, shortName: "tqf" },
+  { chainId: 8194n, shortName: "ttqf" },
+  { chainId: 8217n, shortName: "cypress" },
+  { chainId: 8329n, shortName: "lrz" },
+  { chainId: 8453n, shortName: "base" },
+  { chainId: 8822n, shortName: "iotaevm" },
+  { chainId: 9000n, shortName: "evmos-testnet" },
+  { chainId: 9001n, shortName: "evmos" },
+  { chainId: 9700n, shortName: "MainnetDev" },
+  { chainId: 9728n, shortName: "boba-testnet" },
+  { chainId: 10000n, shortName: "smartbch" },
+  { chainId: 10001n, shortName: "smartbchtest" },
+  { chainId: 10081n, shortName: "joct" },
+  { chainId: 10200n, shortName: "chi" },
+  { chainId: 10242n, shortName: "aa" },
+  { chainId: 10243n, shortName: "aat" },
+  { chainId: 10849n, shortName: "lamina1" },
+  { chainId: 11011n, shortName: "shapesep" },
+  { chainId: 11111n, shortName: "WAGMI" },
+  { chainId: 11235n, shortName: "islm" },
+  { chainId: 11437n, shortName: "shyftt" },
+  { chainId: 11501n, shortName: "bevm" },
+  { chainId: 11503n, shortName: "bevm-test" },
+  { chainId: 11820n, shortName: "artela-mainnet" },
+  { chainId: 11891n, shortName: "Arianee" },
+  { chainId: 12324n, shortName: "l3x" },
+  { chainId: 12325n, shortName: "l3x-testnet" },
+  { chainId: 12357n, shortName: "rei-testnet" },
+  { chainId: 12553n, shortName: "rss3" },
+  { chainId: 13337n, shortName: "beam-testnet" },
+  { chainId: 13371n, shortName: "imx" },
+  { chainId: 13473n, shortName: "imx-testnet" },
+  { chainId: 13746n, shortName: "g7t" },
+  { chainId: 14800n, shortName: "vana-moksha" },
+  { chainId: 17000n, shortName: "holesky" },
+  { chainId: 17069n, shortName: "garnet" },
+  { chainId: 17172n, shortName: "eclipse" },
+  { chainId: 18231n, shortName: "unreal-old" },
+  { chainId: 18233n, shortName: "unreal" },
+  { chainId: 22776n, shortName: "mapo" },
+  { chainId: 23294n, shortName: "sapphire" },
+  { chainId: 23295n, shortName: "sapphire-testnet" },
+  { chainId: 25327n, shortName: "Everclear" },
+  { chainId: 28979n, shortName: "kimbonet-testnet" },
+  { chainId: 31611n, shortName: "mezo" },
+  { chainId: 32769n, shortName: "zil" },
+  { chainId: 33101n, shortName: "zil-testnet" },
+  { chainId: 33139n, shortName: "apechain" },
+  { chainId: 33401n, shortName: "slingshot" },
+  { chainId: 34443n, shortName: "mode" },
+  { chainId: 35441n, shortName: "q" },
+  { chainId: 35443n, shortName: "q-testnet" },
+  { chainId: 37111n, shortName: "lens-sepolia" },
+  { chainId: 41455n, shortName: "aleph-zero" },
+  { chainId: 42161n, shortName: "arb1" },
+  { chainId: 42170n, shortName: "arb-nova" },
+  { chainId: 42220n, shortName: "celo" },
+  { chainId: 42421n, shortName: "rwa" },
+  { chainId: 42793n, shortName: "etlk" },
+  { chainId: 43111n, shortName: "hemi" },
+  { chainId: 43113n, shortName: "fuji" },
+  { chainId: 43114n, shortName: "avax" },
+  { chainId: 43288n, shortName: "boba-avax" },
+  { chainId: 44787n, shortName: "alfa" },
+  { chainId: 45000n, shortName: "autobahnnetwork" },
+  { chainId: 47763n, shortName: "neox-mainnet" },
+  { chainId: 47805n, shortName: "rei" },
+  { chainId: 48899n, shortName: "zircuit-testnet" },
+  { chainId: 48900n, shortName: "zircuit-mainnet" },
+  { chainId: 53457n, shortName: "dodochain" },
+  { chainId: 54211n, shortName: "islmt" },
+  { chainId: 56288n, shortName: "boba-bnb" },
+  { chainId: 57000n, shortName: "tsys-rollux" },
+  { chainId: 57054n, shortName: "blaze" },
+  { chainId: 57073n, shortName: "ink" },
+  { chainId: 58008n, shortName: "sepPGN" },
+  { chainId: 59140n, shortName: "linea-goerli" },
+  { chainId: 59141n, shortName: "linea-sepolia" },
+  { chainId: 59144n, shortName: "linea" },
+  { chainId: 60808n, shortName: "bob" },
+  { chainId: 61166n, shortName: "treasure" },
+  { chainId: 71401n, shortName: "gw-testnet-v1" },
+  { chainId: 71402n, shortName: "gw-mainnet-v1" },
+  { chainId: 73799n, shortName: "vt" },
+  { chainId: 80001n, shortName: "maticmum" },
+  { chainId: 80002n, shortName: "polygonamoy" },
+  { chainId: 80084n, shortName: "berachainbArtio" },
+  { chainId: 80085n, shortName: "berachainArtio" },
+  { chainId: 80094n, shortName: "berachain" },
+  { chainId: 81457n, shortName: "blastmainnet" },
+  { chainId: 83291n, shortName: "lrz-testnet" },
+  { chainId: 84531n, shortName: "basegor" },
+  { chainId: 84532n, shortName: "basesep" },
+  { chainId: 90001n, shortName: "dhobyghaut" },
+  { chainId: 97435n, shortName: "sling" },
+  { chainId: 98864n, shortName: "plume-devnet" },
+  { chainId: 98865n, shortName: "plume" },
+  { chainId: 103454n, shortName: "masatest" },
+  { chainId: 105105n, shortName: "stratis" },
+  { chainId: 111188n, shortName: "re-al" },
+  { chainId: 128123n, shortName: "etlt" },
+  { chainId: 167000n, shortName: "tko-mainnet" },
+  { chainId: 167008n, shortName: "tko-katla" },
+  { chainId: 167009n, shortName: "tko-hekla" },
+  { chainId: 175188n, shortName: "lpy" },
+  { chainId: 200101n, shortName: "milktada" },
+  { chainId: 200202n, shortName: "milktalgo" },
+  { chainId: 200810n, shortName: "btrt" },
+  { chainId: 205205n, shortName: "auroria" },
+  { chainId: 314159n, shortName: "filecoin-calibration" },
+  { chainId: 328527n, shortName: "nal" },
+  { chainId: 333999n, shortName: "olympus" },
+  { chainId: 381931n, shortName: "metal" },
+  { chainId: 421611n, shortName: "arb-rinkeby" },
+  { chainId: 421613n, shortName: "arb-goerli" },
+  { chainId: 421614n, shortName: "arb-sep" },
+  { chainId: 444444n, shortName: "syndr" },
+  { chainId: 490000n, shortName: "ATN" },
+  { chainId: 534351n, shortName: "scr-sepolia" },
+  { chainId: 534352n, shortName: "scr" },
+  { chainId: 534353n, shortName: "scr-alpha" },
+  { chainId: 543210n, shortName: "zero-network" },
+  { chainId: 555666n, shortName: "eclipset" },
+  { chainId: 622277n, shortName: "rth" },
+  { chainId: 656476n, shortName: "open-campus-codex" },
+  { chainId: 660279n, shortName: "xai" },
+  { chainId: 668668n, shortName: "cnw" },
+  { chainId: 713715n, shortName: "sei-devnet" },
+  { chainId: 743111n, shortName: "hemi-sep" },
+  { chainId: 763373n, shortName: "inksepolia" },
+  { chainId: 764984n, shortName: "lamina1test" },
+  { chainId: 808813n, shortName: "bob-sepolia" },
+  { chainId: 810180n, shortName: "zklink-nova" },
+  { chainId: 839999n, shortName: "txsat" },
+  { chainId: 978657n, shortName: "treasure-ruby" },
+  { chainId: 984122n, shortName: "forma" },
+  { chainId: 1501869n, shortName: "water9" },
+  { chainId: 3441006n, shortName: "mantaSepoliaTestnet" },
+  { chainId: 4457845n, shortName: "zero-sepolia" },
+  { chainId: 6038361n, shortName: "azkyt" },
+  { chainId: 7225878n, shortName: "saakuru" },
+  { chainId: 7777777n, shortName: "zora" },
+  { chainId: 9999999n, shortName: "fluence" },
+  { chainId: 11155111n, shortName: "sep" },
+  { chainId: 11155420n, shortName: "opsep" },
+  { chainId: 12227332n, shortName: "neox-t4" },
+  { chainId: 52164803n, shortName: "fluence-testnet" },
+  { chainId: 94204209n, shortName: "polygon-blackberry" },
+  { chainId: 111557560n, shortName: "cysep" },
+  { chainId: 123420111n, shortName: "opcelestia-raspberry" },
+  { chainId: 161221135n, shortName: "plume-testnet" },
+  { chainId: 168587773n, shortName: "blastsepolia" },
+  { chainId: 222000222n, shortName: "kanazawa" },
+  { chainId: 245022926n, shortName: "neonevm-devnet" },
+  { chainId: 245022934n, shortName: "neonevm-mainnet" },
+  { chainId: 253368190n, shortName: "flame" },
+  { chainId: 328527624n, shortName: "nalsep" },
+  { chainId: 333000333n, shortName: "meld" },
+  { chainId: 476462898n, shortName: "Skopje" },
+  { chainId: 666666666n, shortName: "degen-chain" },
+  { chainId: 888888888n, shortName: "ancient8" },
+  { chainId: 999999999n, shortName: "zsep" },
+  { chainId: 1313161554n, shortName: "aurora" },
+  { chainId: 1313161555n, shortName: "aurora-testnet" },
+  { chainId: 1511670449n, shortName: "GPT" },
+  { chainId: 1570754601n, shortName: "hst-test" },
+  { chainId: 1666600000n, shortName: "hmy-s0" },
+  { chainId: 1666700000n, shortName: "hmy-b-s0" },
+  { chainId: 11297108099n, shortName: "tpalm" },
+  { chainId: 11297108109n, shortName: "palm" },
+  { chainId: 37714555429n, shortName: "xaitestnet" },
+  { chainId: 88153591557n, shortName: "arb-blueberry" },
+  { chainId: 123420000220n, shortName: "fluence-stage" },
+  { chainId: 920637907288165n, shortName: "kkrt-starknet-sepolia" }
+];
+if (process.env.TEST_NETWORK === "hardhat") {
+  networks.push({ shortName: "local", chainId: 31337n });
+}
+
+// src/utils/eip-3770/index.ts
+function parseEip3770Address(fullAddress) {
+  const parts = fullAddress.split(":");
+  const address = parts.length > 1 ? parts[1] : parts[0];
+  const prefix = parts.length > 1 ? parts[0] : "";
+  return { prefix, address };
+}
+function getEip3770NetworkPrefixFromChainId(chainId) {
+  const network = networks.find((network2) => chainId === network2.chainId);
+  if (!network) {
+    throw new Error("No network prefix supported for the current chainId");
+  }
+  return network.shortName;
+}
+function isValidEip3770NetworkPrefix(prefix) {
+  return networks.some(({ shortName }) => shortName === prefix);
+}
+function validateEip3770NetworkPrefix(prefix, currentChainId) {
+  const isCurrentNetworkPrefix = prefix === getEip3770NetworkPrefixFromChainId(currentChainId);
+  if (!isValidEip3770NetworkPrefix(prefix) || !isCurrentNetworkPrefix) {
+    throw new Error("The network prefix must match the current network");
+  }
+}
+function validateEthereumAddress(address) {
+  if (!isAddress(address)) {
+    throw new Error(`Invalid Ethereum address ${address}`);
+  }
+}
+function validateEip3770Address(fullAddress, currentChainId) {
+  const { address, prefix } = parseEip3770Address(fullAddress);
+  validateEthereumAddress(address);
+  if (prefix) {
+    validateEip3770NetworkPrefix(prefix, currentChainId);
+  }
+  return { address, prefix };
+}
+
+// src/utils/eip-712/index.ts
+import { hashMessage as performMessageHash } from "viem";
+import semverSatisfies from "semver/functions/satisfies.js";
+
+// src/utils/eip-712/encode.ts
+import {
+  keccak256,
+  concat,
+  encodeAbiParameters,
+  getTypesForEIP712Domain,
+  validateTypedData,
+  hashDomain,
+  toHex
+} from "viem";
+function encodeField({
+  types,
+  name,
+  type,
+  value
+}) {
+  if (types[type] !== void 0) {
+    return [{ type: "bytes32" }, keccak256(encodeData({ data: value, primaryType: type, types }))];
+  }
+  if (type === "bytes") {
+    const prepend = value.length % 2 ? "0" : "";
+    value = `0x${prepend + value.slice(2)}`;
+    return [{ type: "bytes32" }, keccak256(value)];
+  }
+  if (type === "string") return [{ type: "bytes32" }, keccak256(toHex(value))];
+  if (type.lastIndexOf("]") === type.length - 1) {
+    const parsedType = type.slice(0, type.lastIndexOf("["));
+    const typeValuePairs = value.map(
+      (item) => encodeField({
+        name,
+        type: parsedType,
+        types,
+        value: item
+      })
+    );
+    return [
+      { type: "bytes32" },
+      keccak256(
+        encodeAbiParameters(
+          typeValuePairs.map(([t]) => t),
+          typeValuePairs.map(([, v]) => v)
+        )
+      )
+    ];
+  }
+  return [{ type }, value];
+}
+function findTypeDependencies({
+  primaryType: primaryType_,
+  types
+}, results = /* @__PURE__ */ new Set()) {
+  const match = primaryType_.match(/^\w*/u);
+  const primaryType = match?.[0] || "";
+  if (results.has(primaryType) || types[primaryType] === void 0) {
+    return results;
+  }
+  results.add(primaryType);
+  for (const field of types[primaryType]) {
+    findTypeDependencies({ primaryType: field.type, types }, results);
+  }
+  return results;
+}
+function encodeType({
+  primaryType,
+  types
+}) {
+  let result = "";
+  const unsortedDeps = findTypeDependencies({ primaryType, types });
+  unsortedDeps.delete(primaryType);
+  const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
+  for (const type of deps) {
+    result += `${type}(${types[type].map(({ name, type: t }) => `${t} ${name}`).join(",")})`;
+  }
+  return result;
+}
+function hashType({
+  primaryType,
+  types
+}) {
+  const encodedHashType = toHex(encodeType({ primaryType, types }));
+  return keccak256(encodedHashType);
+}
+function encodeData({
+  data,
+  primaryType,
+  types
+}) {
+  const encodedTypes = [{ type: "bytes32" }];
+  const encodedValues = [hashType({ primaryType, types })];
+  for (const field of types[primaryType]) {
+    const [type, value] = encodeField({
+      types,
+      name: field.name,
+      type: field.type,
+      value: data[field.name]
+    });
+    encodedTypes.push(type);
+    encodedValues.push(value);
+  }
+  return encodeAbiParameters(encodedTypes, encodedValues);
+}
+function hashStruct({
+  data,
+  primaryType,
+  types
+}) {
+  const encoded = encodeData({
+    data,
+    primaryType,
+    types
+  });
+  return keccak256(encoded);
+}
+function deducePrimaryType(types) {
+  return Object.keys(types)[0];
+}
+function hashTypedData(typedData) {
+  const data = encodeTypedData(typedData);
+  return keccak256(asHex(data));
+}
+function encodeTypedData(typedData) {
+  typedData.primaryType = !typedData?.primaryType ? deducePrimaryType(typedData.types) : typedData?.primaryType;
+  const { domain = {}, message, primaryType } = typedData;
+  const types = {
+    EIP712Domain: getTypesForEIP712Domain({ domain }),
+    ...typedData.types
+  };
+  validateTypedData({
+    domain,
+    message,
+    primaryType,
+    types
+  });
+  const parts = ["0x1901"];
+  if (domain)
+    parts.push(
+      hashDomain({
+        domain,
+        types
+      })
+    );
+  if (primaryType !== "EIP712Domain")
+    parts.push(
+      hashStruct({
+        data: message,
+        primaryType,
+        types
+      })
+    );
+  return concat(parts);
+}
+
+// src/utils/eip-712/index.ts
+var EQ_OR_GT_1_3_0 = ">=1.3.0";
+var EIP712_DOMAIN_BEFORE_V130 = [
+  {
+    type: "address",
+    name: "verifyingContract"
+  }
+];
+var EIP712_DOMAIN = [
+  {
+    type: "uint256",
+    name: "chainId"
+  },
+  {
+    type: "address",
+    name: "verifyingContract"
+  }
+];
+function getEip712TxTypes(safeVersion) {
+  const eip712WithChainId = semverSatisfies(safeVersion, EQ_OR_GT_1_3_0);
+  return {
+    EIP712Domain: eip712WithChainId ? EIP712_DOMAIN : EIP712_DOMAIN_BEFORE_V130,
+    SafeTx: [
+      { type: "address", name: "to" },
+      { type: "uint256", name: "value" },
+      { type: "bytes", name: "data" },
+      { type: "uint8", name: "operation" },
+      { type: "uint256", name: "safeTxGas" },
+      { type: "uint256", name: "baseGas" },
+      { type: "uint256", name: "gasPrice" },
+      { type: "address", name: "gasToken" },
+      { type: "address", name: "refundReceiver" },
+      { type: "uint256", name: "nonce" }
+    ]
+  };
+}
+function getEip712MessageTypes(safeVersion) {
+  const eip712WithChainId = semverSatisfies(safeVersion, EQ_OR_GT_1_3_0);
+  return {
+    EIP712Domain: eip712WithChainId ? EIP712_DOMAIN : EIP712_DOMAIN_BEFORE_V130,
+    SafeMessage: [{ type: "bytes", name: "message" }]
+  };
+}
+var hashTypedData2 = (typedData) => {
+  return hashTypedData(typedData);
+};
+var hashMessage = (message) => {
+  return performMessageHash(message);
+};
+var hashSafeMessage = (message) => {
+  return typeof message === "string" ? hashMessage(message) : hashTypedData2(message);
+};
+function generateTypedData({
+  safeAddress,
+  safeVersion,
+  chainId,
+  data
+}) {
+  const isSafeTransactionDataType = data.hasOwnProperty("to");
+  const eip712WithChainId = semverSatisfies(safeVersion, EQ_OR_GT_1_3_0);
+  let typedData;
+  if (isSafeTransactionDataType) {
+    const txData = data;
+    typedData = {
+      types: getEip712TxTypes(safeVersion),
+      domain: {
+        verifyingContract: safeAddress
+      },
+      primaryType: "SafeTx",
+      message: {
+        ...txData,
+        value: txData.value,
+        safeTxGas: txData.safeTxGas,
+        baseGas: txData.baseGas,
+        gasPrice: txData.gasPrice,
+        nonce: txData.nonce
+      }
+    };
+  } else {
+    const message = data;
+    typedData = {
+      types: getEip712MessageTypes(safeVersion),
+      domain: {
+        verifyingContract: safeAddress
+      },
+      primaryType: "SafeMessage",
+      message: { message: hashSafeMessage(message) }
+    };
+  }
+  if (eip712WithChainId) {
+    typedData.domain.chainId = Number(chainId);
+  }
+  return typedData;
+}
+
+// src/utils/safeVersions.ts
+import semverSatisfies2 from "semver/functions/satisfies.js";
+var SAFE_FEATURES_BY_VERSION = {
+  ["SAFE_TX_GAS_OPTIONAL" /* SAFE_TX_GAS_OPTIONAL */]: ">=1.3.0",
+  ["SAFE_TX_GUARDS" /* SAFE_TX_GUARDS */]: ">=1.3.0",
+  ["SAFE_FALLBACK_HANDLER" /* SAFE_FALLBACK_HANDLER */]: ">=1.1.1",
+  ["ETH_SIGN" /* ETH_SIGN */]: ">=1.1.0",
+  ["ACCOUNT_ABSTRACTION" /* ACCOUNT_ABSTRACTION */]: ">=1.3.0",
+  ["REQUIRED_TXGAS" /* REQUIRED_TXGAS */]: "<=1.2.0",
+  ["SIMULATE_AND_REVERT" /* SIMULATE_AND_REVERT */]: ">=1.3.0",
+  ["PASSKEY_SIGNER" /* PASSKEY_SIGNER */]: ">=1.3.0",
+  ["SAFE_L2_CONTRACTS" /* SAFE_L2_CONTRACTS */]: ">=1.3.0"
+};
+var hasSafeFeature = (feature, version) => {
+  if (!(feature in SAFE_FEATURES_BY_VERSION)) {
+    return false;
+  }
+  return semverSatisfies2(version, SAFE_FEATURES_BY_VERSION[feature]);
+};
+
+// src/utils/signatures/utils.ts
+import { recoverAddress } from "viem";
+import {
+  SigningMethod
+} from "@safe-global/types-kit";
+import semverSatisfies3 from "semver/functions/satisfies.js";
+
+// src/utils/transactions/gas.ts
+import { BaseError } from "viem";
+import { OperationType } from "@safe-global/types-kit";
+import semverSatisfies5 from "semver/functions/satisfies.js";
+
+// src/contracts/BaseContract.ts
+import {
+  encodeFunctionData
+} from "viem";
+import { estimateContractGas, getTransactionReceipt } from "viem/actions";
+
+// src/contracts/config.ts
+import {
+  getCompatibilityFallbackHandlerDeployments,
+  getCreateCallDeployments,
+  getMultiSendCallOnlyDeployments,
+  getMultiSendDeployments,
+  getProxyFactoryDeployments,
+  getSafeL2SingletonDeployments,
+  getSafeSingletonDeployments,
+  getSignMessageLibDeployments,
+  getSimulateTxAccessorDeployments
+} from "@safe-global/safe-deployments";
+import {
+  getSafeWebAuthnSignerFactoryDeployment,
+  getSafeWebAuthnShareSignerDeployment
+} from "@safe-global/safe-modules-deployments";
+var DEFAULT_SAFE_VERSION = "1.3.0";
+var safeDeploymentsVersions = {
+  "1.4.1": {
+    safeSingletonVersion: "1.4.1",
+    safeSingletonL2Version: "1.4.1",
+    safeProxyFactoryVersion: "1.4.1",
+    compatibilityFallbackHandler: "1.4.1",
+    multiSendVersion: "1.4.1",
+    multiSendCallOnlyVersion: "1.4.1",
+    signMessageLibVersion: "1.4.1",
+    createCallVersion: "1.4.1",
+    simulateTxAccessorVersion: "1.4.1",
+    safeWebAuthnSignerFactoryVersion: "0.2.1",
+    safeWebAuthnSharedSignerVersion: "0.2.1"
+  },
+  "1.3.0": {
+    safeSingletonVersion: "1.3.0",
+    safeSingletonL2Version: "1.3.0",
+    safeProxyFactoryVersion: "1.3.0",
+    compatibilityFallbackHandler: "1.3.0",
+    multiSendVersion: "1.3.0",
+    multiSendCallOnlyVersion: "1.3.0",
+    signMessageLibVersion: "1.3.0",
+    createCallVersion: "1.3.0",
+    simulateTxAccessorVersion: "1.3.0",
+    safeWebAuthnSignerFactoryVersion: "0.2.1",
+    safeWebAuthnSharedSignerVersion: "0.2.1"
+  },
+  "1.2.0": {
+    safeSingletonVersion: "1.2.0",
+    safeSingletonL2Version: void 0,
+    safeProxyFactoryVersion: "1.1.1",
+    compatibilityFallbackHandler: "1.3.0",
+    multiSendVersion: "1.1.1",
+    multiSendCallOnlyVersion: "1.3.0",
+    signMessageLibVersion: "1.3.0",
+    createCallVersion: "1.3.0",
+    safeWebAuthnSignerFactoryVersion: void 0,
+    safeWebAuthnSharedSignerVersion: void 0
+  },
+  "1.1.1": {
+    safeSingletonVersion: "1.1.1",
+    safeSingletonL2Version: void 0,
+    safeProxyFactoryVersion: "1.1.1",
+    compatibilityFallbackHandler: "1.3.0",
+    multiSendVersion: "1.1.1",
+    multiSendCallOnlyVersion: "1.3.0",
+    signMessageLibVersion: "1.3.0",
+    createCallVersion: "1.3.0",
+    safeWebAuthnSignerFactoryVersion: void 0,
+    safeWebAuthnSharedSignerVersion: void 0
+  },
+  "1.0.0": {
+    safeSingletonVersion: "1.0.0",
+    safeSingletonL2Version: void 0,
+    safeProxyFactoryVersion: "1.0.0",
+    compatibilityFallbackHandler: "1.3.0",
+    multiSendVersion: "1.1.1",
+    multiSendCallOnlyVersion: "1.3.0",
+    signMessageLibVersion: "1.3.0",
+    createCallVersion: "1.3.0",
+    safeWebAuthnSignerFactoryVersion: void 0,
+    safeWebAuthnSharedSignerVersion: void 0
+  }
+};
+var safeDeploymentsL1ChainIds = [
+  1n
+  // Ethereum Mainnet
+];
+var contractFunctions = {
+  safeSingletonVersion: getSafeSingletonDeployments,
+  safeSingletonL2Version: getSafeL2SingletonDeployments,
+  safeProxyFactoryVersion: getProxyFactoryDeployments,
+  compatibilityFallbackHandler: getCompatibilityFallbackHandlerDeployments,
+  multiSendVersion: getMultiSendDeployments,
+  multiSendCallOnlyVersion: getMultiSendCallOnlyDeployments,
+  signMessageLibVersion: getSignMessageLibDeployments,
+  createCallVersion: getCreateCallDeployments,
+  simulateTxAccessorVersion: getSimulateTxAccessorDeployments,
+  safeWebAuthnSignerFactoryVersion: getSafeWebAuthnSignerFactoryDeployment,
+  safeWebAuthnSharedSignerVersion: getSafeWebAuthnShareSignerDeployment
+};
+function getContractDeployment(safeVersion, chainId, contractName3) {
+  const contractVersion = safeDeploymentsVersions[safeVersion][contractName3];
+  const filters = {
+    version: contractVersion,
+    network: chainId.toString(),
+    released: true
+  };
+  const deployment = contractFunctions[contractName3](filters);
+  return deployment;
+}
+
+// src/contracts/BaseContract.ts
+var BaseContract = class {
+  /**
+   * @constructor
+   * Constructs an instance of BaseContract.
+   *
+   * @param contractName - The contract name.
+   * @param chainId - The chain ID of the contract.
+   * @param safeProvider - An instance of SafeProvider.
+   * @param defaultAbi - The default ABI for the contract. It should be compatible with the specific version of the contract.
+   * @param safeVersion - The version of the Safe contract.
+   * @param customContractAddress - Optional custom address for the contract. If not provided, the address is derived from the Safe deployments based on the chainId and safeVersion.
+   * @param customContractAbi - Optional custom ABI for the contract. If not provided, the ABI is derived from the Safe deployments or the defaultAbi is used.
+   * @param deploymentType - Optional deployment type for the contract. If not provided, the first deployment retrieved from the safe-deployments array will be used.
+   */
+  constructor(contractName3, chainId, safeProvider, defaultAbi, safeVersion, customContractAddress, customContractAbi, deploymentType) {
+    this.getAddress = () => {
+      return this.contractAddress;
+    };
+    this.encode = (functionToEncode, args) => {
+      const abi = this.contractAbi;
+      const functionName = functionToEncode;
+      const params = args;
+      return encodeFunctionData({
+        abi,
+        functionName,
+        args: params
+      });
+    };
+    this.estimateGas = async (functionToEstimate, args, options = {}) => {
+      const contractOptions = this.convertOptions(options);
+      const abi = this.contractAbi;
+      const params = args;
+      return estimateContractGas(this.runner, {
+        abi,
+        functionName: functionToEstimate,
+        address: this.getAddress(),
+        args: params,
+        ...contractOptions
+      });
+    };
+    const deployment = getContractDeployment(safeVersion, chainId, contractName3);
+    const resolvedAddress = customContractAddress ?? this.#resolveAddress(
+      deployment?.networkAddresses[chainId.toString()],
+      deployment,
+      deploymentType
+    );
+    if (!resolvedAddress) {
+      throw new Error(`Invalid ${contractName3.replace("Version", "")} contract address`);
+    }
+    this.chainId = chainId;
+    this.contractName = contractName3;
+    this.safeVersion = safeVersion;
+    this.contractAddress = resolvedAddress;
+    this.contractAbi = customContractAbi || deployment?.abi || // this cast is required because abi is set as any[] in safe-deployments
+    defaultAbi;
+    this.runner = safeProvider.getExternalProvider();
+    this.safeProvider = safeProvider;
+  }
+  #resolveAddress(networkAddresses, deployment, deploymentType) {
+    if (!networkAddresses) {
+      return void 0;
+    }
+    if (deploymentType && deployment && "deployments" in deployment) {
+      const customDeploymentTypeAddress = deployment.deployments[deploymentType]?.address;
+      if (typeof networkAddresses === "string") {
+        return networkAddresses === customDeploymentTypeAddress ? customDeploymentTypeAddress : void 0;
+      }
+      return networkAddresses.find((address) => address === customDeploymentTypeAddress);
+    }
+    if (typeof networkAddresses === "string") {
+      return networkAddresses;
+    }
+    return networkAddresses[0];
+  }
+  async init() {
+    this.wallet = await this.safeProvider.getExternalSigner();
+  }
+  async getTransactionReceipt(hash) {
+    return getTransactionReceipt(this.runner, { hash });
+  }
+  /**
+   * Converts a type of TransactionOptions to a viem transaction type. The viem transaction type creates a clear distinction between the multiple transaction objects (e.g., post-London hard fork) and doesn't allow a union of fields.
+   * See: https://github.com/wevm/viem/blob/viem%402.18.0/src/types/fee.ts and https://github.com/wevm/viem/blob/603227e2588366914fb79a902d23fd9afc353cc6/src/types/transaction.ts#L200
+   *
+   * @param options - Transaction options as expected throughout safe sdk and propagated on the results.
+   *
+   * @returns Options object compatible with Viem
+   */
+  convertOptions(options) {
+    const chain = this.getChain();
+    if (!chain) throw new Error("Invalid chainId");
+    const account = this.getWallet().account;
+    if (!account) throw new Error("Invalid signer");
+    const txOptions = convertTransactionOptions(options);
+    return { chain, ...txOptions, account };
+  }
+  getChain() {
+    return getChainById(this.chainId);
+  }
+  getWallet() {
+    if (!this.wallet) throw new Error("A signer must be set");
+    return this.wallet;
+  }
+  async write(functionName, args, options) {
+    const converted = this.convertOptions(options);
+    return await this.getWallet().writeContract({
+      address: this.contractAddress,
+      abi: this.contractAbi,
+      functionName,
+      args,
+      ...converted
+    });
+  }
+  async read(functionName, args) {
+    return await this.runner.readContract({
+      functionName,
+      abi: this.contractAbi,
+      address: this.contractAddress,
+      args
+    });
+  }
+};
+var BaseContract_default = BaseContract;
+
+// src/contracts/CreateCall/v1.3.0/CreateCallContract_v1_3_0.ts
+import {
+  createCall_1_3_0_ContractArtifacts
+} from "@safe-global/types-kit";
+
+// src/contracts/utils.ts
+import {
+  concat as concat2,
+  getContractAddress,
+  isAddress as isAddress4,
+  keccak256 as keccak2562,
+  pad,
+  parseAbi as parseAbi2,
+  toHex as toHex3,
+  toEventHash,
+  decodeEventLog
+} from "viem";
+import { waitForTransactionReceipt } from "viem/actions";
+
+// src/utils/block.ts
+function asBlockId(blockId) {
+  return typeof blockId === "number" ? blockNumber(blockId) : blockTag(blockId);
+}
+function blockNumber(blockNumber2) {
+  return { blockNumber: blockNumber2.toNumber() };
+}
+function blockTag(blockTag2) {
+  return { blockTag: blockTag2 };
+}
+
+// src/SafeProvider.ts
+import {
+  createPublicClient,
+  createWalletClient,
+  custom as custom2,
+  http,
+  getAddress,
+  isAddress as isAddress3,
+  decodeAbiParameters,
+  encodeAbiParameters as encodeAbiParameters3,
+  parseAbiParameters as parseAbiParameters2,
+  toBytes as toBytes2,
+  walletActions as walletActions2,
+  publicActions,
+  createClient as createClient2,
+  rpcSchema
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import {
+  call,
+  estimateGas,
+  getBalance,
+  getCode,
+  getTransaction,
+  getTransactionCount,
+  getStorageAt,
+  readContract
+} from "viem/actions";
+
+// src/utils/provider.ts
+import { isAddress as isAddress2 } from "viem";
+
+// src/utils/passkeys/extractPasskeyData.ts
+import { Buffer as Buffer2 } from "buffer";
+import { getFCLP256VerifierDeployment } from "@safe-global/safe-modules-deployments";
+async function decodePublicKeyForWeb(publicKey) {
+  const algorithm = {
+    name: "ECDSA",
+    namedCurve: "P-256",
+    hash: { name: "SHA-256" }
+  };
+  const key = await crypto.subtle.importKey("spki", publicKey, algorithm, true, ["verify"]);
+  const { x, y } = await crypto.subtle.exportKey("jwk", key);
+  const isValidCoordinates = !!x && !!y;
+  if (!isValidCoordinates) {
+    throw new Error("Failed to generate passkey Coordinates. crypto.subtle.exportKey() failed");
+  }
+  return {
+    x: "0x" + Buffer2.from(x, "base64").toString("hex"),
+    y: "0x" + Buffer2.from(y, "base64").toString("hex")
+  };
+}
+function getDefaultFCLP256VerifierAddress(chainId) {
+  const FCLP256VerifierDeployment = getFCLP256VerifierDeployment({
+    version: "0.2.1",
+    released: true,
+    network: chainId
+  });
+  if (!FCLP256VerifierDeployment) {
+    throw new Error(`Failed to load FCLP256Verifier deployment for chain ID ${chainId}`);
+  }
+  const verifierAddress = FCLP256VerifierDeployment.networkAddresses[chainId];
+  if (!verifierAddress) {
+    throw new Error(`FCLP256Verifier address not found for chain ID ${chainId}`);
+  }
+  return verifierAddress;
+}
+
+// src/utils/passkeys/PasskeyClient.ts
+import {
+  hexToBytes,
+  encodeAbiParameters as encodeAbiParameters2,
+  toHex as toHex2,
+  toBytes,
+  stringToBytes,
+  isHex as isHex2,
+  createClient,
+  custom,
+  walletActions,
+  maxUint256,
+  fromBytes,
+  fromHex,
+  parseAbiParameters,
+  encodeFunctionData as encodeFunctionData2,
+  parseAbi
+} from "viem";
+
+// src/utils/passkeys/isSharedSigner.ts
+async function isSharedSigner(passkey, safeWebAuthnSharedSignerContract, safeAddress, owners, chainId) {
+  const sharedSignerContractAddress = safeWebAuthnSharedSignerContract.contractAddress;
+  if (safeAddress && owners.includes(sharedSignerContractAddress)) {
+    const [sharedSignerSlot] = await safeWebAuthnSharedSignerContract.getConfiguration([
+      asHex(safeAddress)
+    ]);
+    const { x, y, verifiers } = sharedSignerSlot;
+    const verifierAddress = passkey.customVerifierAddress || getDefaultFCLP256VerifierAddress(chainId);
+    const isSharedSigner2 = BigInt(passkey.coordinates.x) === x && BigInt(passkey.coordinates.y) === y && BigInt(verifierAddress) === verifiers;
+    return isSharedSigner2;
+  }
+  return false;
+}
+var isSharedSigner_default = isSharedSigner;
+
+// src/utils/passkeys/PasskeyClient.ts
+var PASSKEY_CLIENT_KEY = "passkeyWallet";
+var PASSKEY_CLIENT_NAME = "Passkey Wallet Client";
+var sign = async (passkeyRawId, data, getFn) => {
+  const getCredentials = getFn || navigator.credentials.get.bind(navigator.credentials);
+  const assertion = await getCredentials({
+    publicKey: {
+      challenge: data,
+      allowCredentials: [{ type: "public-key", id: passkeyRawId }],
+      userVerification: "required"
+    }
+  });
+  const assertionResponse = assertion.response;
+  if (!assertionResponse?.authenticatorData) {
+    throw new Error("Failed to sign data with passkey Signer");
+  }
+  const { authenticatorData, signature, clientDataJSON } = assertionResponse;
+  return encodeAbiParameters2(parseAbiParameters("bytes, bytes, uint256[2]"), [
+    toHex2(new Uint8Array(authenticatorData)),
+    extractClientDataFields(clientDataJSON),
+    extractSignature(signature)
+  ]);
+};
+var signTransaction = () => {
+  throw new Error("Passkey Signers cannot sign transactions, they can only sign data.");
+};
+var signTypedData = () => {
+  throw new Error("Passkey Signers cannot sign signTypedData, they can only sign data.");
+};
+var createPasskeyClient = async (passkey, safeWebAuthnSignerFactoryContract, safeWebAuthnSharedSignerContract, provider, safeAddress, owners, chainId) => {
+  const { rawId, coordinates, customVerifierAddress } = passkey;
+  const passkeyRawId = hexToBytes(asHex(rawId));
+  const verifierAddress = customVerifierAddress || getDefaultFCLP256VerifierAddress(chainId);
+  const isPasskeySharedSigner = await isSharedSigner_default(
+    passkey,
+    safeWebAuthnSharedSignerContract,
+    safeAddress,
+    owners,
+    chainId
+  );
+  let signerAddress;
+  if (isPasskeySharedSigner) {
+    signerAddress = safeWebAuthnSharedSignerContract.getAddress();
+  } else {
+    ;
+    [signerAddress] = await safeWebAuthnSignerFactoryContract.getSigner([
+      BigInt(coordinates.x),
+      BigInt(coordinates.y),
+      fromHex(asHex(verifierAddress), "bigint")
+    ]);
+  }
+  return createClient({
+    account: signerAddress,
+    name: PASSKEY_CLIENT_NAME,
+    key: PASSKEY_CLIENT_KEY,
+    transport: custom(provider.transport)
+  }).extend(walletActions).extend(() => ({
+    signMessage({ message }) {
+      if (typeof message === "string") {
+        return sign(passkeyRawId, toBytes(message), passkey.getFn);
+      }
+      return sign(
+        passkeyRawId,
+        isHex2(message.raw) ? toBytes(message.raw) : message.raw,
+        passkey.getFn
+      );
+    },
+    signTransaction,
+    signTypedData,
+    encodeConfigure() {
+      return encodeFunctionData2({
+        abi: parseAbi(["function configure((uint256 x, uint256 y, uint176 verifiers) signer)"]),
+        functionName: "configure",
+        args: [
+          {
+            x: BigInt(passkey.coordinates.x),
+            y: BigInt(passkey.coordinates.y),
+            verifiers: fromHex(asHex(verifierAddress), "bigint")
+          }
+        ]
+      });
+    },
+    encodeCreateSigner() {
+      return asHex(
+        safeWebAuthnSignerFactoryContract.encode("createSigner", [
+          BigInt(coordinates.x),
+          BigInt(coordinates.y),
+          BigInt(verifierAddress)
+        ])
+      );
+    },
+    createDeployTxRequest() {
+      const passkeySignerDeploymentTransaction = {
+        to: safeWebAuthnSignerFactoryContract.getAddress(),
+        value: "0",
+        data: this.encodeCreateSigner()
+      };
+      return passkeySignerDeploymentTransaction;
+    }
+  }));
+};
+function decodeClientDataJSON(clientDataJSON) {
+  const uint8Array = new Uint8Array(clientDataJSON);
+  let result = "";
+  for (let i = 0; i < uint8Array.length; i++) {
+    result += String.fromCharCode(uint8Array[i]);
+  }
+  return result;
+}
+function extractClientDataFields(clientDataJSON) {
+  const decodedClientDataJSON = decodeClientDataJSON(clientDataJSON);
+  const match = decodedClientDataJSON.match(
+    /^\{"type":"webauthn.get","challenge":"[A-Za-z0-9\-_]{43}",(.*)\}$/
+  );
+  if (!match) {
+    throw new Error("challenge not found in client data JSON");
+  }
+  const [, fields] = match;
+  return toHex2(stringToBytes(fields));
+}
+function extractSignature(signature) {
+  const check = (x) => {
+    if (!x) {
+      throw new Error("invalid signature encoding");
+    }
+  };
+  const view = new DataView(
+    signature instanceof ArrayBuffer ? signature : signature instanceof Uint8Array ? signature.buffer : new Uint8Array(signature).buffer
+  );
+  check(view.getUint8(0) === 48);
+  check(view.getUint8(1) === view.byteLength - 2);
+  const readInt = (offset) => {
+    check(view.getUint8(offset) === 2);
+    const len = view.getUint8(offset + 1);
+    const start = offset + 2;
+    const end = start + len;
+    const n = fromBytes(new Uint8Array(view.buffer.slice(start, end)), "bigint");
+    check(n < maxUint256);
+    return [n, end];
+  };
+  const [r, sOffset] = readInt(2);
+  const [s] = readInt(sOffset);
+  return [r, s];
+}
+
+// src/utils/provider.ts
+var isEip1193Provider = (provider) => typeof provider !== "string";
+var isPrivateKey = (signer) => typeof signer === "string" && !isAddress2(signer);
+var isSignerPasskeyClient = (signer) => !!signer && signer.key === PASSKEY_CLIENT_KEY;
+
+// src/SafeProvider.ts
+var SafeProvider = class _SafeProvider {
+  #chain;
+  #externalProvider;
+  constructor({
+    provider,
+    signer
+  }) {
+    this.#externalProvider = createPublicClient({
+      transport: isEip1193Provider(provider) ? custom2(provider) : http(provider)
+    });
+    this.provider = provider;
+    this.signer = signer;
+    this.#chain = void 0;
+  }
+  getExternalProvider() {
+    return this.#externalProvider;
+  }
+  static async init({
+    provider,
+    signer,
+    safeVersion = DEFAULT_SAFE_VERSION,
+    contractNetworks,
+    safeAddress,
+    owners
+  }) {
+    const isPasskeySigner = signer && typeof signer !== "string";
+    if (isPasskeySigner) {
+      if (!hasSafeFeature("PASSKEY_SIGNER" /* PASSKEY_SIGNER */, safeVersion)) {
+        throw new Error(
+          "Current version of the Safe does not support the Passkey signer functionality"
+        );
+      }
+      const safeProvider = new _SafeProvider({
+        provider
+      });
+      const chainId = await safeProvider.getChainId();
+      const customContracts = contractNetworks?.[chainId.toString()];
+      let passkeySigner;
+      if (!isSignerPasskeyClient(signer)) {
+        const safeWebAuthnSignerFactoryContract = await getSafeWebAuthnSignerFactoryContract({
+          safeProvider,
+          safeVersion,
+          customContracts
+        });
+        const safeWebAuthnSharedSignerContract = await getSafeWebAuthnSharedSignerContract({
+          safeProvider,
+          safeVersion,
+          customContracts
+        });
+        passkeySigner = await createPasskeyClient(
+          signer,
+          safeWebAuthnSignerFactoryContract,
+          safeWebAuthnSharedSignerContract,
+          safeProvider.getExternalProvider(),
+          safeAddress || "",
+          owners || [],
+          chainId.toString()
+        );
+      } else {
+        passkeySigner = signer;
+      }
+      return new _SafeProvider({
+        provider,
+        signer: passkeySigner
+      });
+    } else {
+      return new _SafeProvider({
+        provider,
+        signer
+      });
+    }
+  }
+  async getExternalSigner() {
+    const { transport, chain = await this.#getChain() } = this.getExternalProvider();
+    if (isSignerPasskeyClient(this.signer)) {
+      return this.signer;
+    }
+    if (isPrivateKey(this.signer)) {
+      const account = privateKeyToAccount(asHex(this.signer));
+      return createWalletClient({
+        account,
+        chain,
+        transport: custom2(transport)
+      });
+    }
+    if (this.signer && typeof this.signer === "string") {
+      return createWalletClient({
+        account: this.signer,
+        chain,
+        transport: custom2(transport)
+      });
+    }
+    try {
+      const wallet = createWalletClient({
+        chain,
+        transport: custom2(transport)
+      });
+      const [address] = await wallet.getAddresses();
+      if (address) {
+        const client = createClient2({
+          account: address,
+          transport: custom2(transport),
+          chain: wallet.chain,
+          rpcSchema: rpcSchema()
+        }).extend(walletActions2).extend(publicActions);
+        return client;
+      }
+    } catch {
+    }
+    return void 0;
+  }
+  async isPasskeySigner() {
+    return isSignerPasskeyClient(this.signer);
+  }
+  isAddress(address) {
+    return isAddress3(address);
+  }
+  async getEip3770Address(fullAddress) {
+    const chainId = await this.getChainId();
+    return validateEip3770Address(fullAddress, chainId);
+  }
+  async getBalance(address, blockTag2) {
+    return getBalance(this.#externalProvider, {
+      address,
+      ...asBlockId(blockTag2)
+    });
+  }
+  async getNonce(address, blockTag2) {
+    return getTransactionCount(this.#externalProvider, {
+      address,
+      ...asBlockId(blockTag2)
+    });
+  }
+  async getChainId() {
+    const res = (await this.#getChain()).id;
+    return BigInt(res);
+  }
+  getChecksummedAddress(address) {
+    return getAddress(address);
+  }
+  async getContractCode(address, blockTag2) {
+    const res = await getCode(this.#externalProvider, {
+      address,
+      ...asBlockId(blockTag2)
+    });
+    return res ?? "0x";
+  }
+  async isContractDeployed(address, blockTag2) {
+    const contractCode = await getCode(this.#externalProvider, {
+      address,
+      ...asBlockId(blockTag2)
+    });
+    return !!contractCode;
+  }
+  async getStorageAt(address, position) {
+    const content = await getStorageAt(this.#externalProvider, {
+      address,
+      slot: asHex(position)
+    });
+    const decodedContent = this.decodeParameters("address", asHex(content));
+    return decodedContent[0];
+  }
+  async getTransaction(transactionHash) {
+    return getTransaction(this.#externalProvider, {
+      hash: asHash(transactionHash)
+    });
+  }
+  async getSignerAddress() {
+    const externalSigner = await this.getExternalSigner();
+    return externalSigner ? getAddress(externalSigner.account.address) : void 0;
+  }
+  async signMessage(message) {
+    const signer = await this.getExternalSigner();
+    const account = await this.getSignerAddress();
+    if (!signer || !account) {
+      throw new Error("SafeProvider must be initialized with a signer to use this method");
+    }
+    if (sameString(signer.account.address, account)) {
+      return await signer?.signMessage({
+        message: { raw: toBytes2(message) }
+      });
+    } else {
+      return await signer?.signMessage({
+        account,
+        message: { raw: toBytes2(message) }
+      });
+    }
+  }
+  async signTypedData(safeEIP712Args) {
+    const signer = await this.getExternalSigner();
+    if (!signer) {
+      throw new Error("SafeProvider must be initialized with a signer to use this method");
+    }
+    if (isTypedDataSigner(signer)) {
+      const typedData = generateTypedData(safeEIP712Args);
+      const { chainId, verifyingContract } = typedData.domain;
+      const chain = chainId ? Number(chainId) : void 0;
+      const domain = { verifyingContract, chainId: chain };
+      const signature = await signer.signTypedData({
+        domain,
+        types: typedData.primaryType === "SafeMessage" ? { SafeMessage: typedData.types.SafeMessage } : { SafeTx: typedData.types.SafeTx },
+        primaryType: typedData.primaryType,
+        message: typedData.message
+      });
+      return signature;
+    }
+    throw new Error("The current signer does not implement EIP-712 to sign typed data");
+  }
+  async estimateGas(transaction) {
+    const converted = toEstimateGasParameters(transaction);
+    return (await estimateGas(this.#externalProvider, converted)).toString();
+  }
+  async call(transaction, blockTag2) {
+    const converted = toTransactionRequest(transaction);
+    const { data } = await call(this.#externalProvider, {
+      ...converted,
+      ...asBlockId(blockTag2)
+    });
+    return data ?? "0x";
+  }
+  async readContract(args) {
+    return readContract(this.#externalProvider, args);
+  }
+  // TODO: fix anys
+  encodeParameters(types, values) {
+    return encodeAbiParameters3(parseAbiParameters2(types), values);
+  }
+  decodeParameters(types, values) {
+    return decodeAbiParameters(parseAbiParameters2(types), asHex(values));
+  }
+  async #getChain() {
+    if (this.#chain) return this.#chain;
+    const chain = getChainById(BigInt(await this.#externalProvider.getChainId()));
+    if (!chain) throw new Error("Invalid chainId");
+    this.#chain = chain;
+    return this.#chain;
+  }
+};
+var SafeProvider_default = SafeProvider;
+
+// src/utils/memoized.ts
+function createMemoizedFunction(callback, cache = {}) {
+  const replacer = createSafeContractSerializerReplacer();
+  return (...args) => {
+    const key = JSON.stringify(args, replacer);
+    cache[key] = cache[key] || callback(...args);
+    return cache[key];
+  };
+}
+function createSafeContractSerializerReplacer() {
+  const seen = /* @__PURE__ */ new Set();
+  return (_, value) => {
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    if (value instanceof SafeProvider_default && value !== null) {
+      if (seen.has(value)) {
+        return void 0;
+      }
+      seen.add(value);
+      return {
+        $safeProvider: {
+          provider: typeof value.provider === "object" ? "EIP1193Provider" : value.provider,
+          signer: value.signer
+        }
+      };
+    }
+    return value;
+  };
+}
+
+// src/contracts/utils.ts
+import semverSatisfies4 from "semver/functions/satisfies.js";
+var memoizedGetCompatibilityFallbackHandlerContract = createMemoizedFunction(
+  getCompatibilityFallbackHandlerContract
+);
+var memoizedGetProxyFactoryContract = createMemoizedFunction(
+  ({
+    safeProvider,
+    safeVersion,
+    customContracts,
+    deploymentType
+  }) => getSafeProxyFactoryContract({ safeProvider, safeVersion, customContracts, deploymentType })
+);
+var memoizedGetProxyCreationCode = createMemoizedFunction(
+  async ({
+    safeProvider,
+    safeVersion,
+    customContracts,
+    chainId,
+    deploymentType
+  }) => {
+    const safeProxyFactoryContract = await memoizedGetProxyFactoryContract({
+      safeProvider,
+      safeVersion,
+      customContracts,
+      chainId,
+      deploymentType
+    });
+    return safeProxyFactoryContract.proxyCreationCode();
+  }
+);
+var memoizedGetSafeContract = createMemoizedFunction(
+  ({
+    safeProvider,
+    safeVersion,
+    isL1SafeSingleton,
+    customContracts,
+    deploymentType
+  }) => getSafeContract({
+    safeProvider,
+    safeVersion,
+    isL1SafeSingleton,
+    customContracts,
+    deploymentType
+  })
+);
+function toTxResult(runner, hash, options) {
+  return {
+    hash,
+    options,
+    transactionResponse: {
+      wait: async () => waitForTransactionReceipt(runner, { hash })
+    }
+  };
+}
+function isTypedDataSigner(signer) {
+  const isPasskeySigner = !!signer?.passkeyRawId;
+  return signer.signTypedData !== void 0 || !isPasskeySigner;
+}
+
+// src/contracts/CreateCall/v1.4.1/CreateCallContract_v1_4_1.ts
+import {
+  createCall_1_4_1_ContractArtifacts
+} from "@safe-global/types-kit";
+
+// src/contracts/MultiSend/v1.1.1/MultiSendContract_v1_1_1.ts
+import {
+  multisend_1_1_1_ContractArtifacts
+} from "@safe-global/types-kit";
+
+// src/contracts/MultiSend/v1.3.0/MultiSendContract_v1_3_0.ts
+import {
+  multisend_1_3_0_ContractArtifacts
+} from "@safe-global/types-kit";
+
+// src/contracts/MultiSend/v1.4.1/MultiSendContract_v1_4_1.ts
+import {
+  multisend_1_4_1_ContractArtifacts
+} from "@safe-global/types-kit";
+
+// src/contracts/MultiSend/v1.3.0/MultiSendCallOnlyContract_v1_3_0.ts
+import {
+  multiSendCallOnly_1_3_0_ContractArtifacts
+} from "@safe-global/types-kit";
+
+// src/contracts/MultiSend/v1.4.1/MultiSendCallOnlyContract_v1_4_1.ts
+import {
+  multiSendCallOnly_1_4_1_ContractArtifacts
+} from "@safe-global/types-kit";
+
+// src/contracts/SignMessageLib/v1.3.0/SignMessageLibContract_v1_3_0.ts
+import {
+  signMessageLib_1_3_0_ContractArtifacts
+} from "@safe-global/types-kit";
+
+// src/contracts/SignMessageLib/v1.4.1/SignMessageLibContract_v1_4_1.ts
+import {
+  signMessageLib_1_4_1_ContractArtifacts
+} from "@safe-global/types-kit";
+
+// src/contracts/Safe/v1.0.0/SafeContract_v1_0_0.ts
+import { simulateContract } from "viem/actions";
+
+// src/contracts/Safe/SafeBaseContract.ts
+var SafeBaseContract = class extends BaseContract_default {
+  /**
+   * @constructor
+   * Constructs an instance of SafeBaseContract.
+   *
+   * @param chainId - The chain ID of the contract.
+   * @param safeProvider - An instance of SafeProvider.
+   * @param defaultAbi - The default ABI for the Safe contract. It should be compatible with the specific version of the Safe contract.
+   * @param safeVersion - The version of the Safe contract.
+   * @param isL1SafeSingleton - A flag indicating if the contract is a L1 Safe Singleton.
+   * @param customContractAddress - Optional custom address for the contract. If not provided, the address is derived from the Safe deployments based on the chainId and safeVersion.
+   * @param customContractAbi - Optional custom ABI for the contract. If not provided, the ABI is derived from the Safe deployments or the defaultAbi is used.
+   * @param deploymentType - Optional deployment type for the contract. If not provided, the first deployment retrieved from the safe-deployments array will be used.
+   */
+  constructor(chainId, safeProvider, defaultAbi, safeVersion, isL1SafeSingleton = safeDeploymentsL1ChainIds.includes(chainId), customContractAddress, customContractAbi, deploymentType) {
+    const isL1Contract = isL1SafeSingleton || !hasSafeFeature("SAFE_L2_CONTRACTS" /* SAFE_L2_CONTRACTS */, safeVersion);
+    const contractName3 = isL1Contract ? "safeSingletonVersion" : "safeSingletonL2Version";
+    super(
+      contractName3,
+      chainId,
+      safeProvider,
+      defaultAbi,
+      safeVersion,
+      customContractAddress,
+      customContractAbi,
+      deploymentType
+    );
+    this.contractName = contractName3;
+  }
+};
+var SafeBaseContract_default = SafeBaseContract;
+
+// src/contracts/Safe/v1.0.0/SafeContract_v1_0_0.ts
+import {
+  safe_1_0_0_ContractArtifacts
+} from "@safe-global/types-kit";
+var SafeContract_v1_0_0 = class extends SafeBaseContract_default {
+  /**
+   * Constructs an instance of SafeContract_v1_0_0
+   *
+   * @param chainId - The chain ID where the contract resides.
+   * @param safeProvider - An instance of SafeProvider.
+   * @param isL1SafeSingleton - A flag indicating if the contract is a L1 Safe Singleton.
+   * @param customContractAddress - Optional custom address for the contract. If not provided, the address is derived from the Safe deployments based on the chainId and safeVersion.
+   * @param customContractAbi - Optional custom ABI for the contract. If not provided, the default ABI for version 1.0.0 is used.
+   * @param deploymentType - Optional deployment type for the contract. If not provided, the first deployment retrieved from the safe-deployments array will be used.
+   */
+  constructor(chainId, safeProvider, isL1SafeSingleton, customContractAddress, customContractAbi, deploymentType) {
+    const safeVersion = "1.0.0";
+    const defaultAbi = safe_1_0_0_ContractArtifacts.abi;
+    super(
+      chainId,
+      safeProvider,
+      defaultAbi,
+      safeVersion,
+      isL1SafeSingleton,
+      customContractAddress,
+      customContractAbi,
+      deploymentType
+    );
+    /* ----- Specific v1.0.0 properties -----  */
+    this.DOMAIN_SEPARATOR_TYPEHASH = async () => {
+      return [await this.read("DOMAIN_SEPARATOR_TYPEHASH")];
+    };
+    this.SENTINEL_MODULES = async () => {
+      return [await this.read("SENTINEL_MODULES")];
+    };
+    this.SENTINEL_OWNERS = async () => {
+      return [await this.read("SENTINEL_OWNERS")];
+    };
+    this.SAFE_MSG_TYPEHASH = async () => {
+      return [await this.read("SAFE_MSG_TYPEHASH")];
+    };
+    this.SAFE_TX_TYPEHASH = async () => {
+      return [await this.read("SAFE_TX_TYPEHASH")];
+    };
+    /* ----- End of specific v1.0.0 properties -----  */
+    /**
+     * @returns Array[contractName]
+     */
+    this.NAME = async () => {
+      return [await this.read("NAME")];
+    };
+    /**
+     * @returns Array[safeContractVersion]
+     */
+    this.VERSION = async () => {
+      return [await this.read("VERSION")];
+    };
+    /**
+     * @param args - Array[owner, txHash]
+     * @returns Array[approvedHashes]
+     */
+    this.approvedHashes = async (args) => {
+      return [await this.read("approvedHashes", args)];
+    };
+    /**
+     * @returns Array[domainSeparator]
+     */
+    this.domainSeparator = async () => {
+      return [await this.read("domainSeparator")];
+    };
+    /**
+     * Returns array of modules.
+     * @returns Array[Array[modules]]
+     */
+    this.getModules = async () => {
+      return [await this.read("getModules")];
+    };
+    /**
+     * Returns the list of Safe owner accounts.
+     * @returns Array[Array[owners]]
+     */
+    this.getOwners = async () => {
+      return [await this.read("getOwners")];
+    };
+    /**
+     * Returns the Safe threshold.
+     * @returns Array[threshold]
+     */
+    this.getThreshold = async () => {
+      return [await this.read("getThreshold")];
+    };
+    /**
+     * Checks if a specific address is an owner of the current Safe.
+     * @param args - Array[address]
+     * @returns Array[isOwner]
+     */
+    this.isOwner = async (args) => {
+      return [await this.read("isOwner", args)];
+    };
+    /**
+     * Returns the Safe nonce.
+     * @returns Array[nonce]
+     */
+    this.nonce = async () => {
+      return [await this.read("nonce")];
+    };
+    /**
+     * @param args - Array[messageHash]
+     * @returns Array[signedMessages]
+     */
+    this.signedMessages = async (args) => {
+      return [await this.read("signedMessages", args)];
+    };
+    /**
+     * Returns hash of a message that can be signed by owners.
+     * @param args - Array[message]
+     * @returns Array[messageHash]
+     */
+    this.getMessageHash = async (args) => {
+      return [await this.read("getMessageHash", args)];
+    };
+    /**
+     * Returns the bytes that are hashed to be signed by owners.
+     * @param args - Array[to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, _nonce]
+     * @returns Array[encodedData]
+     */
+    this.encodeTransactionData = async (args) => {
+      return [await this.read("encodeTransactionData", args)];
+    };
+    /**
+     * Returns hash to be signed by owners.
+     * @param args - Array[to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, _nonce]
+     * @returns Array[transactionHash]
+     */
+    this.getTransactionHash = async (args) => {
+      return [await this.read("getTransactionHash", args)];
+    };
+  }
+  /**
+   * Marks a hash as approved. This can be used to validate a hash that is used by a signature.
+   * @param hash - The hash that should be marked as approved for signatures that are verified by this contract.
+   * @param options - Optional transaction options.
+   * @returns Transaction result.
+   */
+  async approveHash(hash, options) {
+    const gasLimit = options?.gasLimit || await this.estimateGas("approveHash", [asHash(hash)], options);
+    return toTxResult(
+      this.runner,
+      await this.write("approveHash", [asHash(hash)], { ...options, gasLimit }),
+      options
+    );
+  }
+  /**
+   * Executes a transaction.
+   * @param safeTransaction - The Safe transaction to execute.
+   * @param options - Transaction options.
+   * @returns Transaction result.
+   */
+  async execTransaction(safeTransaction, options) {
+    const gasLimit = options?.gasLimit || await this.estimateGas(
+      "execTransaction",
+      [
+        safeTransaction.data.to,
+        BigInt(safeTransaction.data.value),
+        asHex(safeTransaction.data.data),
+        safeTransaction.data.operation,
+        BigInt(safeTransaction.data.safeTxGas),
+        BigInt(safeTransaction.data.baseGas),
+        BigInt(safeTransaction.data.gasPrice),
+        safeTransaction.data.gasToken,
+        safeTransaction.data.refundReceiver,
+        asHex(safeTransaction.encodedSignatures())
+      ],
+      options
+    );
+    const args = [
+      safeTransaction.data.to,
+      BigInt(safeTransaction.data.value),
+      asHex(safeTransaction.data.data),
+      safeTransaction.data.operation,
+      BigInt(safeTransaction.data.safeTxGas),
+      BigInt(safeTransaction.data.baseGas),
+      BigInt(safeTransaction.data.gasPrice),
+      safeTransaction.data.gasToken,
+      safeTransaction.data.refundReceiver,
+      asHex(safeTransaction.encodedSignatures())
+    ];
+    return toTxResult(
+      this.runner,
+      await this.write("execTransaction", args, { ...options, gasLimit }),
+      options
+    );
+  }
+  async getModulesPaginated([start, pageSize]) {
+    if (pageSize <= 0) throw new Error("Invalid page size for fetching paginated modules");
+    const size = Number(pageSize);
+    const [array] = await this.getModules();
+    if (isSentinelAddress(start)) {
+      const next = pageSize < array.length ? array[size] : SENTINEL_ADDRESS;
+      return [array.slice(0, size), next];
+    } else {
+      const moduleIndex = array.findIndex((module) => sameString(module, start));
+      if (moduleIndex === -1) {
+        return [[], SENTINEL_ADDRESS];
+      }
+      const nextElementIndex = moduleIndex + 1;
+      const nextPageAddress = nextElementIndex + size < array.length ? array[nextElementIndex + size] : SENTINEL_ADDRESS;
+      return [array.slice(moduleIndex + 1, nextElementIndex + size), nextPageAddress];
+    }
+  }
+  /**
+   * Checks if a specific Safe module is enabled for the current Safe.
+   * @param moduleAddress - The module address to check.
+   * @returns True, if the module with the given address is enabled.
+   */
+  async isModuleEnabled([moduleAddress]) {
+    const [modules] = await this.getModules();
+    const isModuleEnabled = modules.some(
+      (enabledModuleAddress) => sameString(enabledModuleAddress, moduleAddress)
+    );
+    return [isModuleEnabled];
+  }
+  /**
+   * Checks whether a given Safe transaction can be executed successfully with no errors.
+   * @param safeTransaction - The Safe transaction to check.
+   * @param options - Optional transaction options.
+   * @returns True, if the given transactions is valid.
+   */
+  async isValidTransaction(safeTransaction, options = {}) {
+    try {
+      const gasLimit = options?.gasLimit || await this.estimateGas(
+        "execTransaction",
+        [
+          safeTransaction.data.to,
+          BigInt(safeTransaction.data.value),
+          asHex(safeTransaction.data.data),
+          safeTransaction.data.operation,
+          BigInt(safeTransaction.data.safeTxGas),
+          BigInt(safeTransaction.data.baseGas),
+          BigInt(safeTransaction.data.gasPrice),
+          safeTransaction.data.gasToken,
+          safeTransaction.data.refundReceiver,
+          asHex(safeTransaction.encodedSignatures())
+        ],
+        options
+      );
+      const converted = this.convertOptions({ ...options, gasLimit });
+      const txResult = await simulateContract(this.runner, {
+        address: this.contractAddress,
+        functionName: "execTransaction",
+        abi: this.contractAbi,
+        args: [
+          safeTransaction.data.to,
+          BigInt(safeTransaction.data.value),
+          asHex(safeTransaction.data.data),
+          safeTransaction.data.operation,
+          BigInt(safeTransaction.data.safeTxGas),
+          BigInt(safeTransaction.data.baseGas),
+          BigInt(safeTransaction.data.gasPrice),
+          safeTransaction.data.gasToken,
+          safeTransaction.data.refundReceiver,
+          asHex(safeTransaction.encodedSignatures())
+        ],
+        ...converted
+      });
+      return txResult.result;
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * returns the nonce of the Safe contract.
+   *
+   * @returns {Promise<bigint>} A promise that resolves to the nonce of the Safe contract.
+   */
+  async getNonce() {
+    const [nonce] = await this.nonce();
+    return nonce;
+  }
+};
+var SafeContract_v1_0_0_default = SafeContract_v1_0_0;
+
+// src/contracts/Safe/v1.1.1/SafeContract_v1_1_1.ts
+import { simulateContract as simulateContract2 } from "viem/actions";
+import {
+  safe_1_1_1_ContractArtifacts
+} from "@safe-global/types-kit";
+var SafeContract_v1_1_1 = class extends SafeBaseContract_default {
+  /**
+   * Constructs an instance of SafeContract_v1_1_1
+   *
+   * @param chainId - The chain ID where the contract resides.
+   * @param safeProvider - An instance of SafeProvider.
+   * @param isL1SafeSingleton - A flag indicating if the contract is a L1 Safe Singleton.
+   * @param customContractAddress - Optional custom address for the contract. If not provided, the address is derived from the Safe deployments based on the chainId and safeVersion.
+   * @param customContractAbi - Optional custom ABI for the contract. If not provided, the default ABI for version 1.1.1 is used.
+   * @param deploymentType - Optional deployment type for the contract. If not provided, the first deployment retrieved from the safe-deployments array will be used.
+   */
+  constructor(chainId, safeProvider, isL1SafeSingleton, customContractAddress, customContractAbi, deploymentType) {
+    const safeVersion = "1.1.1";
+    const defaultAbi = safe_1_1_1_ContractArtifacts.abi;
+    super(
+      chainId,
+      safeProvider,
+      defaultAbi,
+      safeVersion,
+      isL1SafeSingleton,
+      customContractAddress,
+      customContractAbi,
+      deploymentType
+    );
+    /**
+     * @returns Array[contractName]
+     */
+    this.NAME = async () => {
+      return [await this.read("NAME")];
+    };
+    /**
+     * @returns Array[safeContractVersion]
+     */
+    this.VERSION = async () => {
+      return [await this.read("VERSION")];
+    };
+    /**
+     * @param args - Array[owner, txHash]
+     * @returns Array[approvedHashes]
+     */
+    this.approvedHashes = async (args) => {
+      return [await this.read("approvedHashes", args)];
+    };
+    /**
+     * @returns Array[domainSeparator]
+     */
+    this.domainSeparator = async () => {
+      return [await this.read("domainSeparator")];
+    };
+    /**
+     * Returns array of first 10 modules.
+     * @returns Array[Array[modules]]
+     */
+    this.getModules = async () => {
+      return [await this.read("getModules")];
+    };
+    /**
+     * Returns array of modules.
+     * @param args - Array[start, pageSize]
+     * @returns Array[Array[modules], next]
+     */
+    this.getModulesPaginated = async (args) => {
+      const [array, next] = await this.read("getModulesPaginated", args);
+      return [array, next];
+    };
+    /**
+     * Returns the list of Safe owner accounts.
+     * @returns Array[Array[owners]]
+     */
+    this.getOwners = async () => {
+      return [await this.read("getOwners")];
+    };
+    /**
+     * Returns the Safe threshold.
+     * @returns Array[threshold]
+     */
+    this.getThreshold = async () => {
+      return [await this.read("getThreshold")];
+    };
+    /**
+     * Checks if a specific address is an owner of the current Safe.
+     * @param args - Array[address]
+     * @returns Array[isOwner]
+     */
+    this.isOwner = async (args) => {
+      return [await this.read("isOwner", args)];
+    };
+    /**
+     * Returns the Safe nonce.
+     * @returns Array[nonce]
+     */
+    this.nonce = async () => {
+      return [await this.read("nonce")];
+    };
+    /**
+     * @param args - Array[messageHash]
+     * @returns Array[signedMessages]
+     */
+    this.signedMessages = async (args) => {
+      return [await this.read("signedMessages", args)];
+    };
+    /**
+     * Returns hash of a message that can be signed by owners.
+     * @param args - Array[message]
+     * @returns Array[messageHash]
+     */
+    this.getMessageHash = async (args) => {
+      return [await this.read("getMessageHash", args)];
+    };
+    /**
+     * Returns the bytes that are hashed to be signed by owners.
+     * @param args - Array[to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, _nonce]
+     * @returns Array[encodedData]
+     */
+    this.encodeTransactionData = async (args) => {
+      return [await this.read("encodeTransactionData", args)];
+    };
+    /**
+     * Returns hash to be signed by owners.
+     * @param args - Array[to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, _nonce]
+     * @returns Array[transactionHash]
+     */
+    this.getTransactionHash = async (args) => {
+      return [await this.read("getTransactionHash", args)];
+    };
+  }
+  /**
+   * Marks a hash as approved. This can be used to validate a hash that is used by a signature.
+   * @param hash - The hash that should be marked as approved for signatures that are verified by this contract.
+   * @param options - Optional transaction options.
+   * @returns Transaction result.
+   */
+  async approveHash(hash, options) {
+    const gasLimit = options?.gasLimit || await this.estimateGas("approveHash", [asHash(hash)], options);
+    return toTxResult(
+      this.runner,
+      await this.write("approveHash", [asHash(hash)], { ...options, gasLimit }),
+      options
+    );
+  }
+  /**
+   * Executes a transaction.
+   * @param safeTransaction - The Safe transaction to execute.
+   * @param options - Transaction options.
+   * @returns Transaction result.
+   */
+  async execTransaction(safeTransaction, options) {
+    const gasLimit = options?.gasLimit || await this.estimateGas(
+      "execTransaction",
+      [
+        safeTransaction.data.to,
+        BigInt(safeTransaction.data.value),
+        asHex(safeTransaction.data.data),
+        safeTransaction.data.operation,
+        BigInt(safeTransaction.data.safeTxGas),
+        BigInt(safeTransaction.data.baseGas),
+        BigInt(safeTransaction.data.gasPrice),
+        safeTransaction.data.gasToken,
+        safeTransaction.data.refundReceiver,
+        asHex(safeTransaction.encodedSignatures())
+      ],
+      options
+    );
+    const args = [
+      safeTransaction.data.to,
+      BigInt(safeTransaction.data.value),
+      asHex(safeTransaction.data.data),
+      safeTransaction.data.operation,
+      BigInt(safeTransaction.data.safeTxGas),
+      BigInt(safeTransaction.data.baseGas),
+      BigInt(safeTransaction.data.gasPrice),
+      safeTransaction.data.gasToken,
+      safeTransaction.data.refundReceiver,
+      asHex(safeTransaction.encodedSignatures())
+    ];
+    return toTxResult(
+      this.runner,
+      await this.write("execTransaction", args, { ...options, gasLimit }),
+      options
+    );
+  }
+  /**
+   * Checks if a specific Safe module is enabled for the current Safe.
+   * @param moduleAddress - The module address to check.
+   * @returns True, if the module with the given address is enabled.
+   */
+  async isModuleEnabled([moduleAddress]) {
+    const [modules] = await this.getModules();
+    const isModuleEnabled = modules.some(
+      (enabledModuleAddress) => sameString(enabledModuleAddress, moduleAddress)
+    );
+    return [isModuleEnabled];
+  }
+  /**
+   * Checks whether a given Safe transaction can be executed successfully with no errors.
+   * @param safeTransaction - The Safe transaction to check.
+   * @param options - Optional transaction options.
+   * @returns True, if the given transactions is valid.
+   */
+  async isValidTransaction(safeTransaction, options = {}) {
+    try {
+      const gasLimit = options?.gasLimit || await this.estimateGas(
+        "execTransaction",
+        [
+          safeTransaction.data.to,
+          BigInt(safeTransaction.data.value),
+          asHex(safeTransaction.data.data),
+          safeTransaction.data.operation,
+          BigInt(safeTransaction.data.safeTxGas),
+          BigInt(safeTransaction.data.baseGas),
+          BigInt(safeTransaction.data.gasPrice),
+          safeTransaction.data.gasToken,
+          safeTransaction.data.refundReceiver,
+          asHex(safeTransaction.encodedSignatures())
+        ],
+        options
+      );
+      const converted = this.convertOptions({ ...options, gasLimit });
+      const txResult = await simulateContract2(this.runner, {
+        address: this.contractAddress,
+        functionName: "execTransaction",
+        abi: this.contractAbi,
+        args: [
+          safeTransaction.data.to,
+          BigInt(safeTransaction.data.value),
+          asHex(safeTransaction.data.data),
+          safeTransaction.data.operation,
+          BigInt(safeTransaction.data.safeTxGas),
+          BigInt(safeTransaction.data.baseGas),
+          BigInt(safeTransaction.data.gasPrice),
+          safeTransaction.data.gasToken,
+          safeTransaction.data.refundReceiver,
+          asHex(safeTransaction.encodedSignatures())
+        ],
+        ...converted
+      });
+      return txResult.result;
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * returns the nonce of the Safe contract.
+   *
+   * @returns {Promise<bigint>} A promise that resolves to the nonce of the Safe contract.
+   */
+  async getNonce() {
+    const [nonce] = await this.nonce();
+    return nonce;
+  }
+};
+var SafeContract_v1_1_1_default = SafeContract_v1_1_1;
+
+// src/contracts/Safe/v1.2.0/SafeContract_v1_2_0.ts
+import { simulateContract as simulateContract3 } from "viem/actions";
+import {
+  safe_1_2_0_ContractArtifacts
+} from "@safe-global/types-kit";
+var SafeContract_v1_2_0 = class extends SafeBaseContract_default {
+  /**
+   * Constructs an instance of SafeContract_v1_2_0
+   *
+   * @param chainId - The chain ID where the contract resides.
+   * @param safeProvider - An instance of SafeProvider.
+   * @param isL1SafeSingleton - A flag indicating if the contract is a L1 Safe Singleton.
+   * @param customContractAddress - Optional custom address for the contract. If not provided, the address is derived from the Safe deployments based on the chainId and safeVersion.
+   * @param customContractAbi - Optional custom ABI for the contract. If not provided, the default ABI for version 1.2.0 is used.
+   * @param deploymentType - Optional deployment type for the contract. If not provided, the first deployment retrieved from the safe-deployments array will be used.
+   */
+  constructor(chainId, safeProvider, isL1SafeSingleton, customContractAddress, customContractAbi, deploymentType) {
+    const safeVersion = "1.2.0";
+    const defaultAbi = safe_1_2_0_ContractArtifacts.abi;
+    super(
+      chainId,
+      safeProvider,
+      defaultAbi,
+      safeVersion,
+      isL1SafeSingleton,
+      customContractAddress,
+      customContractAbi,
+      deploymentType
+    );
+    /**
+     * @returns Array[contractName]
+     */
+    this.NAME = async () => {
+      return [await this.read("NAME")];
+    };
+    /**
+     * @returns Array[safeContractVersion]
+     */
+    this.VERSION = async () => {
+      return [await this.read("VERSION")];
+    };
+    /**
+     * @param args - Array[owner, txHash]
+     * @returns Array[approvedHashes]
+     */
+    this.approvedHashes = async (args) => {
+      return [await this.read("approvedHashes", args)];
+    };
+    /**
+     * @returns Array[domainSeparator]
+     */
+    this.domainSeparator = async () => {
+      return [await this.read("domainSeparator")];
+    };
+    /**
+     * Returns array of first 10 modules.
+     * @returns Array[Array[modules]]
+     */
+    this.getModules = async () => {
+      return [await this.read("getModules")];
+    };
+    /**
+     * Returns array of modules.
+     * @param args - Array[start, pageSize]
+     * @returns Array[Array[modules], next]
+     */
+    this.getModulesPaginated = async (args) => {
+      const [array, next] = await this.read("getModulesPaginated", args);
+      return [array, next];
+    };
+    /**
+     * Returns the list of Safe owner accounts.
+     * @returns Array[Array[owners]]
+     */
+    this.getOwners = async () => {
+      return [await this.read("getOwners")];
+    };
+    /**
+     * Returns the Safe threshold.
+     * @returns Array[threshold]
+     */
+    this.getThreshold = async () => {
+      return [await this.read("getThreshold")];
+    };
+    /**
+     * Checks if a specific Safe module is enabled for the current Safe.
+     * @param args - Array[moduleAddress]
+     * @returns Array[isEnabled]
+     */
+    this.isModuleEnabled = async (args) => {
+      return [await this.read("isModuleEnabled", args)];
+    };
+    /**
+     * Checks if a specific address is an owner of the current Safe.
+     * @param args - Array[address]
+     * @returns Array[isOwner]
+     */
+    this.isOwner = async (args) => {
+      return [await this.read("isOwner", args)];
+    };
+    /**
+     * Returns the Safe nonce.
+     * @returns Array[nonce]
+     */
+    this.nonce = async () => {
+      return [await this.read("nonce")];
+    };
+    /**
+     * @param args - Array[messageHash]
+     * @returns Array[signedMessages]
+     */
+    this.signedMessages = async (args) => {
+      return [await this.read("signedMessages", args)];
+    };
+    /**
+     * @param args - Array[message]
+     * @returns Array[messageHash]
+     */
+    this.getMessageHash = async (args) => {
+      return [await this.read("getMessageHash", args)];
+    };
+    /**
+     * Encodes the data for a transaction to the Safe contract.
+     *
+     * @param args - Array[to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, _nonce]
+     * @returns Array[encodedData]
+     */
+    this.encodeTransactionData = async (args) => {
+      return [await this.read("encodeTransactionData", args)];
+    };
+    /**
+     * Returns hash to be signed by owners.
+     *
+     * @param args - Array[to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, _nonce]
+     * @returns Array[transactionHash]
+     */
+    this.getTransactionHash = async (args) => {
+      return [await this.read("getTransactionHash", args)];
+    };
+  }
+  /**
+   * Marks a hash as approved. This can be used to validate a hash that is used by a signature.
+   * @param hash - The hash that should be marked as approved for signatures that are verified by this contract.
+   * @param options - Optional transaction options.
+   * @returns Transaction result.
+   */
+  async approveHash(hash, options) {
+    const gasLimit = options?.gasLimit || await this.estimateGas("approveHash", [asHash(hash)], options);
+    return toTxResult(
+      this.runner,
+      await this.write("approveHash", [asHash(hash)], { ...options, gasLimit }),
+      options
+    );
+  }
+  /**
+   * Executes a transaction.
+   * @param safeTransaction - The Safe transaction to execute.
+   * @param options - Transaction options.
+   * @returns Transaction result.
+   */
+  async execTransaction(safeTransaction, options) {
+    const gasLimit = options?.gasLimit || await this.estimateGas(
+      "execTransaction",
+      [
+        safeTransaction.data.to,
+        BigInt(safeTransaction.data.value),
+        asHex(safeTransaction.data.data),
+        safeTransaction.data.operation,
+        BigInt(safeTransaction.data.safeTxGas),
+        BigInt(safeTransaction.data.baseGas),
+        BigInt(safeTransaction.data.gasPrice),
+        safeTransaction.data.gasToken,
+        safeTransaction.data.refundReceiver,
+        asHex(safeTransaction.encodedSignatures())
+      ],
+      options
+    );
+    const args = [
+      safeTransaction.data.to,
+      BigInt(safeTransaction.data.value),
+      asHex(safeTransaction.data.data),
+      safeTransaction.data.operation,
+      BigInt(safeTransaction.data.safeTxGas),
+      BigInt(safeTransaction.data.baseGas),
+      BigInt(safeTransaction.data.gasPrice),
+      safeTransaction.data.gasToken,
+      safeTransaction.data.refundReceiver,
+      asHex(safeTransaction.encodedSignatures())
+    ];
+    return toTxResult(
+      this.runner,
+      await this.write("execTransaction", args, { ...options, gasLimit }),
+      options
+    );
+  }
+  /**
+   * Returns the chain id of the Safe contract. (Custom method - not defined in the Safe Contract)
+   * @returns Array[chainId]
+   */
+  async getChainId() {
+    return [await Promise.resolve(this.chainId)];
+  }
+  /**
+   * Checks whether a given Safe transaction can be executed successfully with no errors.
+   * @param safeTransaction - The Safe transaction to check.
+   * @param options - Optional transaction options.
+   * @returns True, if the given transactions is valid.
+   */
+  async isValidTransaction(safeTransaction, options = {}) {
+    try {
+      const gasLimit = options?.gasLimit || await this.estimateGas(
+        "execTransaction",
+        [
+          safeTransaction.data.to,
+          BigInt(safeTransaction.data.value),
+          asHex(safeTransaction.data.data),
+          safeTransaction.data.operation,
+          BigInt(safeTransaction.data.safeTxGas),
+          BigInt(safeTransaction.data.baseGas),
+          BigInt(safeTransaction.data.gasPrice),
+          safeTransaction.data.gasToken,
+          safeTransaction.data.refundReceiver,
+          asHex(safeTransaction.encodedSignatures())
+        ],
+        options
+      );
+      const converted = this.convertOptions({ ...options, gasLimit });
+      const txResult = await simulateContract3(this.runner, {
+        address: this.contractAddress,
+        functionName: "execTransaction",
+        abi: this.contractAbi,
+        args: [
+          safeTransaction.data.to,
+          BigInt(safeTransaction.data.value),
+          asHex(safeTransaction.data.data),
+          safeTransaction.data.operation,
+          BigInt(safeTransaction.data.safeTxGas),
+          BigInt(safeTransaction.data.baseGas),
+          BigInt(safeTransaction.data.gasPrice),
+          safeTransaction.data.gasToken,
+          safeTransaction.data.refundReceiver,
+          asHex(safeTransaction.encodedSignatures())
+        ],
+        ...converted
+      });
+      return txResult.result;
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * returns the nonce of the Safe contract.
+   *
+   * @returns {Promise<bigint>} A promise that resolves to the nonce of the Safe contract.
+   */
+  async getNonce() {
+    const [nonce] = await this.nonce();
+    return nonce;
+  }
+};
+var SafeContract_v1_2_0_default = SafeContract_v1_2_0;
+
+// src/contracts/Safe/v1.3.0/SafeContract_v1_3_0.ts
+import { simulateContract as simulateContract4 } from "viem/actions";
+import {
+  safe_1_3_0_ContractArtifacts
+} from "@safe-global/types-kit";
+var SafeContract_v1_3_0 = class extends SafeBaseContract_default {
+  /**
+   * Constructs an instance of SafeContract_v1_3_0
+   *
+   * @param chainId - The chain ID where the contract resides.
+   * @param safeProvider - An instance of SafeProvider.
+   * @param isL1SafeSingleton - A flag indicating if the contract is a L1 Safe Singleton.
+   * @param customContractAddress - Optional custom address for the contract. If not provided, the address is derived from the Safe deployments based on the chainId and safeVersion.
+   * @param customContractAbi - Optional custom ABI for the contract. If not provided, the default ABI for version 1.3.0 is used.
+   * @param deploymentType - Optional deployment type for the contract. If not provided, the first deployment retrieved from the safe-deployments array will be used.
+   */
+  constructor(chainId, safeProvider, isL1SafeSingleton, customContractAddress, customContractAbi, deploymentType) {
+    const safeVersion = "1.3.0";
+    const defaultAbi = safe_1_3_0_ContractArtifacts.abi;
+    super(
+      chainId,
+      safeProvider,
+      defaultAbi,
+      safeVersion,
+      isL1SafeSingleton,
+      customContractAddress,
+      customContractAbi,
+      deploymentType
+    );
+    /**
+     * @returns Array[safeContractVersion]
+     */
+    this.VERSION = async () => {
+      return [await this.read("VERSION")];
+    };
+    /**
+     * @param args - Array[owner, txHash]
+     * @returns Array[approvedHashes]
+     */
+    this.approvedHashes = async (args) => {
+      return [await this.read("approvedHashes", args)];
+    };
+    /**
+     * Checks whether the signature provided is valid for the provided data, hash and number of required signatures.
+     * Will revert otherwise.
+     * @param args - Array[dataHash, data, signatures, requiredSignatures]
+     * @returns Empty array
+     */
+    this.checkNSignatures = async (args) => {
+      await this.read("checkNSignatures", args);
+      return [];
+    };
+    /**
+     * Checks whether the signature provided is valid for the provided data and hash. Will revert otherwise.
+     * @param args - Array[dataHash, data, signatures]
+     * @returns Empty array
+     */
+    this.checkSignatures = async (args) => {
+      await this.read("checkSignatures", args);
+      return [];
+    };
+    /**
+     * @returns Array[domainSeparator]
+     */
+    this.domainSeparator = async () => {
+      return [await this.read("domainSeparator")];
+    };
+    /**
+     * Encodes the data for a transaction to the Safe contract.
+     * @param args - Array[to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, _nonce]
+     * @returns Array[encodedData]
+     */
+    this.encodeTransactionData = async (args) => {
+      return [await this.read("encodeTransactionData", args)];
+    };
+    /**
+     * Returns array of modules.
+     * @param args - Array[start, pageSize]
+     * @returns Array[Array[modules], next]
+     */
+    this.getModulesPaginated = async (args) => {
+      const [array, next] = await this.read("getModulesPaginated", args);
+      return [array, next];
+    };
+    /**
+     * Returns the list of Safe owner accounts.
+     * @returns Array[Array[owners]]
+     */
+    this.getOwners = async () => {
+      return [await this.read("getOwners")];
+    };
+    /**
+     * Reads `length` bytes of storage in the currents contract
+     * @param args - Array[offset, length]
+     * @returns Array[storage]
+     */
+    this.getStorageAt = async (args) => {
+      return [await this.read("getStorageAt", args)];
+    };
+    /**
+     * Returns the Safe threshold.
+     * @returns Array[threshold]
+     */
+    this.getThreshold = async () => {
+      return [await this.read("getThreshold")];
+    };
+    /**
+     * Returns hash to be signed by owners.
+     * @param args - Array[to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, _nonce]
+     * @returns Array[transactionHash]
+     */
+    this.getTransactionHash = async (args) => {
+      return [await this.read("getTransactionHash", args)];
+    };
+    /**
+     * Checks if a specific Safe module is enabled for the current Safe.
+     * @param args - Array[moduleAddress]
+     * @returns Array[isEnabled]
+     */
+    this.isModuleEnabled = async (args) => {
+      return [await this.read("isModuleEnabled", args)];
+    };
+    /**
+     * Checks if a specific address is an owner of the current Safe.
+     * @param args - Array[address]
+     * @returns Array[isOwner]
+     */
+    this.isOwner = async (args) => {
+      return [await this.read("isOwner", args)];
+    };
+    /**
+     * Returns the Safe nonce.
+     * @returns Array[nonce]
+     */
+    this.nonce = async () => {
+      return [await this.read("nonce")];
+    };
+    /**
+     * @param args - Array[messageHash]
+     * @returns Array[signedMessages]
+     */
+    this.signedMessages = async (args) => {
+      return [await this.read("signedMessages", args)];
+    };
+  }
+  /**
+   * Checks whether a given Safe transaction can be executed successfully with no errors.
+   * @param safeTransaction - The Safe transaction to check.
+   * @param options - Optional transaction options.
+   * @returns True, if the given transactions is valid.
+   */
+  async isValidTransaction(safeTransaction, options = {}) {
+    try {
+      const gasLimit = options?.gasLimit || await this.estimateGas(
+        "execTransaction",
+        [
+          safeTransaction.data.to,
+          BigInt(safeTransaction.data.value),
+          asHex(safeTransaction.data.data),
+          safeTransaction.data.operation,
+          BigInt(safeTransaction.data.safeTxGas),
+          BigInt(safeTransaction.data.baseGas),
+          BigInt(safeTransaction.data.gasPrice),
+          safeTransaction.data.gasToken,
+          safeTransaction.data.refundReceiver,
+          asHex(safeTransaction.encodedSignatures())
+        ],
+        options
+      );
+      const converted = this.convertOptions({ ...options, gasLimit });
+      const txResult = await simulateContract4(this.runner, {
+        address: this.contractAddress,
+        functionName: "execTransaction",
+        abi: this.contractAbi,
+        args: [
+          safeTransaction.data.to,
+          BigInt(safeTransaction.data.value),
+          asHex(safeTransaction.data.data),
+          safeTransaction.data.operation,
+          BigInt(safeTransaction.data.safeTxGas),
+          BigInt(safeTransaction.data.baseGas),
+          BigInt(safeTransaction.data.gasPrice),
+          safeTransaction.data.gasToken,
+          safeTransaction.data.refundReceiver,
+          asHex(safeTransaction.encodedSignatures())
+        ],
+        ...converted
+      });
+      return txResult.result;
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * Executes a transaction.
+   * @param safeTransaction - The Safe transaction to execute.
+   * @param options - Transaction options.
+   * @returns Transaction result.
+   */
+  async execTransaction(safeTransaction, options) {
+    const gasLimit = options?.gasLimit || await this.estimateGas(
+      "execTransaction",
+      [
+        safeTransaction.data.to,
+        BigInt(safeTransaction.data.value),
+        asHex(safeTransaction.data.data),
+        safeTransaction.data.operation,
+        BigInt(safeTransaction.data.safeTxGas),
+        BigInt(safeTransaction.data.baseGas),
+        BigInt(safeTransaction.data.gasPrice),
+        safeTransaction.data.gasToken,
+        safeTransaction.data.refundReceiver,
+        asHex(safeTransaction.encodedSignatures())
+      ],
+      options
+    );
+    const args = [
+      safeTransaction.data.to,
+      BigInt(safeTransaction.data.value),
+      asHex(safeTransaction.data.data),
+      safeTransaction.data.operation,
+      BigInt(safeTransaction.data.safeTxGas),
+      BigInt(safeTransaction.data.baseGas),
+      BigInt(safeTransaction.data.gasPrice),
+      safeTransaction.data.gasToken,
+      safeTransaction.data.refundReceiver,
+      asHex(safeTransaction.encodedSignatures())
+    ];
+    return toTxResult(
+      this.runner,
+      await this.write("execTransaction", args, { ...options, gasLimit }),
+      options
+    );
+  }
+  /**
+   * Returns array of first 10 modules.
+   * @returns Array[modules]
+   */
+  async getModules() {
+    const [modules] = await this.getModulesPaginated([SENTINEL_ADDRESS, BigInt(10)]);
+    return [modules.map((module) => module)];
+  }
+  /**
+   * Marks a hash as approved. This can be used to validate a hash that is used by a signature.
+   * @param hash - The hash that should be marked as approved for signatures that are verified by this contract.
+   * @param options - Optional transaction options.
+   * @returns Transaction result.
+   */
+  async approveHash(hash, options) {
+    const gasLimit = options?.gasLimit || await this.estimateGas("approveHash", [asHash(hash)], options);
+    return toTxResult(
+      this.runner,
+      await this.write("approveHash", [asHash(hash)], { ...options, gasLimit }),
+      options
+    );
+  }
+  /**
+   * Returns the chain id of the Safe contract. (Custom method - not defined in the Safe Contract)
+   * @returns Array[chainId]
+   */
+  async getChainId() {
+    return [await Promise.resolve(this.chainId)];
+  }
+  /**
+   * returns the nonce of the Safe contract.
+   *
+   * @returns {Promise<bigint>} A promise that resolves to the nonce of the Safe contract.
+   */
+  async getNonce() {
+    const [nonce] = await this.nonce();
+    return nonce;
+  }
+};
+var SafeContract_v1_3_0_default = SafeContract_v1_3_0;
+
+// src/contracts/Safe/v1.4.1/SafeContract_v1_4_1.ts
+import { simulateContract as simulateContract5 } from "viem/actions";
+import {
+  safe_1_4_1_ContractArtifacts
+} from "@safe-global/types-kit";
+var SafeContract_v1_4_1 = class extends SafeBaseContract_default {
+  /**
+   * Constructs an instance of SafeContract_v1_4_1
+   *
+   * @param chainId - The chain ID where the contract resides.
+   * @param safeProvider - An instance of SafeProvider.
+   * @param isL1SafeSingleton - A flag indicating if the contract is a L1 Safe Singleton.
+   * @param customContractAddress - Optional custom address for the contract. If not provided, the address is derived from the Safe deployments based on the chainId and safeVersion.
+   * @param customContractAbi - Optional custom ABI for the contract. If not provided, the default ABI for version 1.4.1 is used.
+   * @param deploymentType - Optional deployment type for the contract. If not provided, the first deployment retrieved from the safe-deployments array will be used.
+   */
+  constructor(chainId, safeProvider, isL1SafeSingleton, customContractAddress, customContractAbi, deploymentType) {
+    const safeVersion = "1.4.1";
+    const defaultAbi = safe_1_4_1_ContractArtifacts.abi;
+    super(
+      chainId,
+      safeProvider,
+      defaultAbi,
+      safeVersion,
+      isL1SafeSingleton,
+      customContractAddress,
+      customContractAbi,
+      deploymentType
+    );
+    /**
+     * @returns Array[safeContractVersion]
+     */
+    this.VERSION = async () => {
+      return [await this.read("VERSION")];
+    };
+    /**
+     * @param args - Array[owner, txHash]
+     * @returns Array[approvedHashes]
+     */
+    this.approvedHashes = async (args) => {
+      return [await this.read("approvedHashes", args)];
+    };
+    /**
+     * Checks whether the signature provided is valid for the provided data, hash and number of required signatures.
+     * Will revert otherwise.
+     * @param args - Array[dataHash, data, signatures, requiredSignatures]
+     * @returns Empty array
+     */
+    this.checkNSignatures = async (args) => {
+      await this.read("checkNSignatures", args);
+      return [];
+    };
+    /**
+     * Checks whether the signature provided is valid for the provided data and hash. Will revert otherwise.
+     * @param args - Array[dataHash, data, signatures]
+     * @returns Empty array
+     */
+    this.checkSignatures = async (args) => {
+      await this.read("checkSignatures", args);
+      return [];
+    };
+    /**
+     * @returns Array[domainSeparator]
+     */
+    this.domainSeparator = async () => {
+      return [await this.read("domainSeparator")];
+    };
+    /**
+     * Encodes the data for a transaction to the Safe contract.
+     * @param args - Array[to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, _nonce]
+     * @returns Array[encodedData]
+     */
+    this.encodeTransactionData = async (args) => {
+      return [await this.read("encodeTransactionData", args)];
+    };
+    /**
+     * Returns array of modules.
+     * @param args - Array[start, pageSize]
+     * @returns Array[Array[modules], next]
+     */
+    this.getModulesPaginated = async (args) => {
+      const [array, next] = await this.read("getModulesPaginated", args);
+      return [array, next];
+    };
+    /**
+     * Returns the list of Safe owner accounts.
+     * @returns Array[Array[owners]]
+     */
+    this.getOwners = async () => {
+      return [await this.read("getOwners")];
+    };
+    /**
+     * Reads `length` bytes of storage in the currents contract
+     * @param args - Array[offset, length]
+     * @returns Array[storage]
+     */
+    this.getStorageAt = async (args) => {
+      return [await this.read("getStorageAt", args)];
+    };
+    /**
+     * Returns the Safe threshold.
+     * @returns Array[threshold]
+     */
+    this.getThreshold = async () => {
+      return [await this.read("getThreshold")];
+    };
+    /**
+     * Returns hash to be signed by owners.
+     * @param args - Array[to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, _nonce]
+     * @returns Array[transactionHash]
+     */
+    this.getTransactionHash = async (args) => {
+      return [await this.read("getTransactionHash", args)];
+    };
+    /**
+     * Checks if a specific Safe module is enabled for the current Safe.
+     * @param args - Array[moduleAddress]
+     * @returns Array[isEnabled]
+     */
+    this.isModuleEnabled = async (args) => {
+      return [await this.read("isModuleEnabled", args)];
+    };
+    /**
+     * Checks if a specific address is an owner of the current Safe.
+     * @param args - Array[address]
+     * @returns Array[isOwner]
+     */
+    this.isOwner = async (args) => {
+      return [await this.read("isOwner", args)];
+    };
+    /**
+     * Returns the Safe nonce.
+     * @returns Array[nonce]
+     */
+    this.nonce = async () => {
+      return [await this.read("nonce")];
+    };
+    /**
+     * @param args - Array[messageHash]
+     * @returns Array[signedMessages]
+     */
+    this.signedMessages = async (args) => {
+      return [await this.read("signedMessages", args)];
+    };
+  }
+  /**
+   * Checks whether a given Safe transaction can be executed successfully with no errors.
+   * @param safeTransaction - The Safe transaction to check.
+   * @param options - Optional transaction options.
+   * @returns True, if the given transactions is valid.
+   */
+  async isValidTransaction(safeTransaction, options = {}) {
+    try {
+      const gasLimit = options?.gasLimit || await this.estimateGas(
+        "execTransaction",
+        [
+          safeTransaction.data.to,
+          BigInt(safeTransaction.data.value),
+          asHex(safeTransaction.data.data),
+          safeTransaction.data.operation,
+          BigInt(safeTransaction.data.safeTxGas),
+          BigInt(safeTransaction.data.baseGas),
+          BigInt(safeTransaction.data.gasPrice),
+          safeTransaction.data.gasToken,
+          safeTransaction.data.refundReceiver,
+          asHex(safeTransaction.encodedSignatures())
+        ],
+        options
+      );
+      const converted = this.convertOptions({ ...options, gasLimit });
+      const txResult = await simulateContract5(this.runner, {
+        address: this.contractAddress,
+        functionName: "execTransaction",
+        abi: this.contractAbi,
+        args: [
+          safeTransaction.data.to,
+          BigInt(safeTransaction.data.value),
+          asHex(safeTransaction.data.data),
+          safeTransaction.data.operation,
+          BigInt(safeTransaction.data.safeTxGas),
+          BigInt(safeTransaction.data.baseGas),
+          BigInt(safeTransaction.data.gasPrice),
+          safeTransaction.data.gasToken,
+          safeTransaction.data.refundReceiver,
+          asHex(safeTransaction.encodedSignatures())
+        ],
+        ...converted
+      });
+      return txResult.result;
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * Executes a transaction.
+   * @param safeTransaction - The Safe transaction to execute.
+   * @param options - Transaction options.
+   * @returns Transaction result.
+   */
+  async execTransaction(safeTransaction, options) {
+    const gasLimit = options?.gasLimit || await this.estimateGas(
+      "execTransaction",
+      [
+        safeTransaction.data.to,
+        BigInt(safeTransaction.data.value),
+        asHex(safeTransaction.data.data),
+        safeTransaction.data.operation,
+        BigInt(safeTransaction.data.safeTxGas),
+        BigInt(safeTransaction.data.baseGas),
+        BigInt(safeTransaction.data.gasPrice),
+        safeTransaction.data.gasToken,
+        safeTransaction.data.refundReceiver,
+        asHex(safeTransaction.encodedSignatures())
+      ],
+      options
+    );
+    const args = [
+      safeTransaction.data.to,
+      BigInt(safeTransaction.data.value),
+      asHex(safeTransaction.data.data),
+      safeTransaction.data.operation,
+      BigInt(safeTransaction.data.safeTxGas),
+      BigInt(safeTransaction.data.baseGas),
+      BigInt(safeTransaction.data.gasPrice),
+      safeTransaction.data.gasToken,
+      safeTransaction.data.refundReceiver,
+      asHex(safeTransaction.encodedSignatures())
+    ];
+    return toTxResult(
+      this.runner,
+      await this.write("execTransaction", args, { ...options, gasLimit }),
+      options
+    );
+  }
+  /**
+   * Returns array of first 10 modules.
+   * @returns Array[modules]
+   */
+  async getModules() {
+    const [modules] = await this.getModulesPaginated([SENTINEL_ADDRESS, BigInt(10)]);
+    return [modules.map((module) => module)];
+  }
+  /**
+   * Marks a hash as approved. This can be used to validate a hash that is used by a signature.
+   * @param hash - The hash that should be marked as approved for signatures that are verified by this contract.
+   * @param options - Optional transaction options.
+   * @returns Transaction result.
+   */
+  async approveHash(hash, options) {
+    const gasLimit = options?.gasLimit || await this.estimateGas("approveHash", [asHash(hash)], options);
+    return toTxResult(
+      this.runner,
+      await this.write("approveHash", [asHash(hash)], { ...options, gasLimit }),
+      options
+    );
+  }
+  /**
+   * Returns the chain id of the Safe contract. (Custom method - not defined in the Safe Contract)
+   * @returns Array[chainId]
+   */
+  async getChainId() {
+    return [await Promise.resolve(this.chainId)];
+  }
+  /**
+   * returns the nonce of the Safe contract.
+   *
+   * @returns {Promise<bigint>} A promise that resolves to the nonce of the Safe contract.
+   */
+  async getNonce() {
+    const [nonce] = await this.nonce();
+    return nonce;
+  }
+};
+var SafeContract_v1_4_1_default = SafeContract_v1_4_1;
+
+// src/contracts/SafeProxyFactory/SafeProxyFactoryBaseContract.ts
+var SafeProxyFactoryBaseContract = class extends BaseContract_default {
+  /**
+   * @constructor
+   * Constructs an instance of SafeProxyFactoryBaseContract.
+   *
+   * @param chainId - The chain ID of the contract.
+   * @param safeProvider - An instance of SafeProvider.
+   * @param defaultAbi - The default ABI for the Safe contract. It should be compatible with the specific version of the contract.
+   * @param safeVersion - The version of the Safe contract.
+   * @param customContractAddress - Optional custom address for the contract. If not provided, the address is derived from the Safe deployments based on the chainId and safeVersion.
+   * @param customContractAbi - Optional custom ABI for the contract. If not provided, the ABI is derived from the Safe deployments or the defaultAbi is used.
+   * @param deploymentType - Optional deployment type for the contract. If not provided, the first deployment retrieved from the safe-deployments array will be used.
+   */
+  constructor(chainId, safeProvider, defaultAbi, safeVersion, customContractAddress, customContractAbi, deploymentType) {
+    const contractName3 = "safeProxyFactoryVersion";
+    super(
+      contractName3,
+      chainId,
+      safeProvider,
+      defaultAbi,
+      safeVersion,
+      customContractAddress,
+      customContractAbi,
+      deploymentType
+    );
+    this.contractName = contractName3;
+  }
+};
+var SafeProxyFactoryBaseContract_default = SafeProxyFactoryBaseContract;
+
+// src/contracts/SafeProxyFactory/v1.0.0/SafeProxyFactoryContract_v1_0_0.ts
+import {
+  safeProxyFactory_1_0_0_ContractArtifacts
+} from "@safe-global/types-kit";
+var SafeProxyFactoryContract_v1_0_0 = class extends SafeProxyFactoryBaseContract_default {
+  /**
+   * Constructs an instance of SafeProxyFactoryContract_v1_0_0
+   *
+   * @param chainId - The chain ID where the contract resides.
+   * @param safeProvider - An instance of SafeProvider.
+   * @param customContractAddress - Optional custom address for the contract. If not provided, the address is derived from the Safe deployments based on the chainId and safeVersion.
+   * @param customContractAbi - Optional custom ABI for the contract. If not provided, the default ABI for version 1.0.0 is used.
+   * @param deploymentType - Optional deployment type for the contract. If not provided, the first deployment retrieved from the safe-deployments array will be used.
+   */
+  constructor(chainId, safeProvider, customContractAddress, customContractAbi, deploymentType) {
+    const safeVersion = "1.0.0";
+    const defaultAbi = safeProxyFactory_1_0_0_ContractArtifacts.abi;
+    super(
+      chainId,
+      safeProvider,
+      defaultAbi,
+      safeVersion,
+      customContractAddress,
+      customContractAbi,
+      deploymentType
+    );
+    /**
+     * Allows to retrieve the creation code used for the Proxy deployment. With this it is easily possible to calculate predicted address.
+     * @returns Array[creationCode]
+     */
+    this.proxyCreationCode = async () => {
+      return [await this.read("proxyCreationCode")];
+    };
+    /**
+     * Allows to retrieve the runtime code of a deployed Proxy. This can be used to check that the expected Proxy was deployed.
+     * @returns Array[runtimeCode]
+     */
+    this.proxyRuntimeCode = async () => {
+      return [await this.read("proxyRuntimeCode")];
+    };
+    /**
+     * Allows to create new proxy contact and execute a message call to the new proxy within one transaction.
+     * @param args - Array[masterCopy, data]
+     * @returns Array[proxyAddress]
+     */
+    this.createProxy = async (args) => {
+      return [await this.write("createProxy", args)];
+    };
+    /**
+     * Allows to create new proxy contract and execute a message call to the new proxy within one transaction.
+     * @param args - Array[masterCopy, initializer, saltNonce]
+     * @returns Array[proxyAddress]
+     */
+    this.createProxyWithNonce = async (args) => {
+      return [await this.write("createProxyWithNonce", args)];
+    };
+  }
+};
+var SafeProxyFactoryContract_v1_0_0_default = SafeProxyFactoryContract_v1_0_0;
+
+// src/contracts/SafeProxyFactory/v1.1.1/SafeProxyFactoryContract_v1_1_1.ts
+import {
+  safeProxyFactory_1_1_1_ContractArtifacts
+} from "@safe-global/types-kit";
+var SafeProxyFactoryContract_v1_1_1 = class extends SafeProxyFactoryBaseContract_default {
+  /**
+   * Constructs an instance of SafeProxyFactoryContract_v1_1_1
+   *
+   * @param chainId - The chain ID where the contract resides.
+   * @param safeProvider - An instance of SafeProvider.
+   * @param customContractAddress - Optional custom address for the contract. If not provided, the address is derived from the Safe deployments based on the chainId and safeVersion.
+   * @param customContractAbi - Optional custom ABI for the contract. If not provided, the default ABI for version 1.1.1 is used.
+   * @param deploymentType - Optional deployment type for the contract. If not provided, the first deployment retrieved from the safe-deployments array will be used.
+   */
+  constructor(chainId, safeProvider, customContractAddress, customContractAbi, deploymentType) {
+    const safeVersion = "1.1.1";
+    const defaultAbi = safeProxyFactory_1_1_1_ContractArtifacts.abi;
+    super(
+      chainId,
+      safeProvider,
+      defaultAbi,
+      safeVersion,
+      customContractAddress,
+      customContractAbi,
+      deploymentType
+    );
+    /**
+     * Allows to retrieve the creation code used for the Proxy deployment. With this it is easily possible to calculate predicted address.
+     * @returns Array[creationCode]
+     */
+    this.proxyCreationCode = async () => {
+      return [await this.read("proxyCreationCode")];
+    };
+    /**
+     * Allows to retrieve the runtime code of a deployed Proxy. This can be used to check that the expected Proxy was deployed.
+     * @returns Array[runtimeCode]
+     */
+    this.proxyRuntimeCode = async () => {
+      return [await this.read("proxyRuntimeCode")];
+    };
+    /**
+     * Allows to get the address for a new proxy contact created via `createProxyWithNonce`.
+     * @param args - Array[masterCopy, initializer, saltNonceBigInt]
+     * @returns Array[proxyAddress]
+     */
+    this.calculateCreateProxyWithNonceAddress = async (args) => {
+      return [await this.write("calculateCreateProxyWithNonceAddress", args)];
+    };
+    /**
+     * Allows to create new proxy contact and execute a message call to the new proxy within one transaction.
+     * @param args - Array[masterCopy, data]
+     * @returns Array[proxyAddress]
+     */
+    this.createProxy = async (args) => {
+      return [await this.write("createProxy", args)];
+    };
+    /**
+     * Allows to create new proxy contract, execute a message call to the new proxy and call a specified callback within one transaction.
+     * @param args - Array[masterCopy, initializer, saltNonce, callback]
+     * @returns Array[proxyAddress]
+     */
+    this.createProxyWithCallback = async (args) => {
+      return [await this.write("createProxyWithCallback", args)];
+    };
+    /**
+     * Allows to create new proxy contract and execute a message call to the new proxy within one transaction.
+     * @param args - Array[masterCopy, initializer, saltNonce]
+     * @returns Array[proxyAddress]
+     */
+    this.createProxyWithNonce = async (args) => {
+      return [await this.write("createProxyWithNonce", args)];
+    };
+  }
+};
+var SafeProxyFactoryContract_v1_1_1_default = SafeProxyFactoryContract_v1_1_1;
+
+// src/contracts/SafeProxyFactory/v1.3.0/SafeProxyFactoryContract_v1_3_0.ts
+import {
+  safeProxyFactory_1_3_0_ContractArtifacts
+} from "@safe-global/types-kit";
+var SafeProxyFactoryContract_v1_3_0 = class extends SafeProxyFactoryBaseContract_default {
+  /**
+   * Constructs an instance of SafeProxyFactoryContract_v1_3_0
+   *
+   * @param chainId - The chain ID where the contract resides.
+   * @param safeProvider - An instance of SafeProvider.
+   * @param customContractAddress - Optional custom address for the contract. If not provided, the address is derived from the Safe deployments based on the chainId and safeVersion.
+   * @param customContractAbi - Optional custom ABI for the contract. If not provided, the default ABI for version 1.3.0 is used.
+   * @param deploymentType - Optional deployment type for the contract. If not provided, the first deployment retrieved from the safe-deployments array will be used.
+   */
+  constructor(chainId, safeProvider, customContractAddress, customContractAbi, deploymentType) {
+    const safeVersion = "1.3.0";
+    const defaultAbi = safeProxyFactory_1_3_0_ContractArtifacts.abi;
+    super(
+      chainId,
+      safeProvider,
+      defaultAbi,
+      safeVersion,
+      customContractAddress,
+      customContractAbi,
+      deploymentType
+    );
+    /**
+     * Allows to retrieve the creation code used for the Proxy deployment. With this it is easily possible to calculate predicted address.
+     * @returns Array[creationCode]
+     */
+    this.proxyCreationCode = async () => {
+      return [await this.read("proxyCreationCode")];
+    };
+    /**
+     * Allows to retrieve the runtime code of a deployed Proxy. This can be used to check that the expected Proxy was deployed.
+     * @returns Array[runtimeCode]
+     */
+    this.proxyRuntimeCode = async () => {
+      return [await this.read("proxyRuntimeCode")];
+    };
+    /**
+     * Allows to get the address for a new proxy contact created via `createProxyWithNonce`.
+     * @param args - Array[singleton, initializer, saltNonce]
+     * @returns Array[proxyAddress]
+     */
+    this.calculateCreateProxyWithNonceAddress = async (args) => {
+      return [await this.write("calculateCreateProxyWithNonceAddress", args)];
+    };
+    /**
+     * Allows to create new proxy contact and execute a message call to the new proxy within one transaction.
+     * @param args - Array[singleton, data]
+     * @returns Array[proxyAddress]
+     */
+    this.createProxy = async (args) => {
+      return [await this.write("createProxy", args)];
+    };
+    /**
+     * Allows to create new proxy contract, execute a message call to the new proxy and call a specified callback within one transaction.
+     * @param args - Array[singleton, initializer, saltNonce, callback]
+     * @returns Array[proxyAddress]
+     */
+    this.createProxyWithCallback = async (args) => {
+      return [await this.write("createProxyWithCallback", args)];
+    };
+    /**
+     * Allows to create new proxy contract and execute a message call to the new proxy within one transaction.
+     * @param args - Array[singleton, initializer, saltNonce]
+     * @returns Array[proxyAddress]
+     */
+    this.createProxyWithNonce = async (args) => {
+      return [await this.write("createProxyWithNonce", args)];
+    };
+  }
+};
+var SafeProxyFactoryContract_v1_3_0_default = SafeProxyFactoryContract_v1_3_0;
+
+// src/contracts/SafeProxyFactory/v1.4.1/SafeProxyFactoryContract_v1_4_1.ts
+import {
+  safeProxyFactory_1_4_1_ContractArtifacts
+} from "@safe-global/types-kit";
+var SafeProxyFactoryContract_v1_4_1 = class extends SafeProxyFactoryBaseContract_default {
+  /**
+   * Constructs an instance of SafeProxyFactoryContract_v1_4_1
+   *
+   * @param chainId - The chain ID where the contract resides.
+   * @param safeProvider - An instance of SafeProvider.
+   * @param customContractAddress - Optional custom address for the contract. If not provided, the address is derived from the Safe deployments based on the chainId and safeVersion.
+   * @param customContractAbi - Optional custom ABI for the contract. If not provided, the default ABI for version 1.4.1 is used.
+   * @param deploymentType - Optional deployment type for the contract. If not provided, the first deployment retrieved from the safe-deployments array will be used.
+   */
+  constructor(chainId, safeProvider, customContractAddress, customContractAbi, deploymentType) {
+    const safeVersion = "1.4.1";
+    const defaultAbi = safeProxyFactory_1_4_1_ContractArtifacts.abi;
+    super(
+      chainId,
+      safeProvider,
+      defaultAbi,
+      safeVersion,
+      customContractAddress,
+      customContractAbi,
+      deploymentType
+    );
+    /**
+     * Returns the ID of the chain the contract is currently deployed on.
+     * @returns Array[chainId]
+     */
+    this.getChainId = async () => {
+      return [await this.read("getChainId")];
+    };
+    /**
+     * Allows to retrieve the creation code used for the Proxy deployment. With this it is easily possible to calculate predicted address.
+     * @returns Array[creationCode]
+     */
+    this.proxyCreationCode = async () => {
+      return [await this.read("proxyCreationCode")];
+    };
+    /**
+     * Deploys a new chain-specific proxy with singleton and salt. Optionally executes an initializer call to a new proxy.
+     * @param args - Array[singleton, initializer, saltNonce]
+     * @returns Array[proxy]
+     */
+    this.createChainSpecificProxyWithNonce = async (args) => {
+      return [await this.write("createChainSpecificProxyWithNonce", args)];
+    };
+    /**
+     * Deploy a new proxy with singleton and salt.
+     * Optionally executes an initializer call to a new proxy and calls a specified callback address.
+     * @param args - Array[singleton, initializer, saltNonce, callback]
+     * @returns Array[proxy]
+     */
+    this.createProxyWithCallback = async (args) => {
+      return [await this.write("createProxyWithCallback", args)];
+    };
+    /**
+     * Deploys a new proxy with singleton and salt. Optionally executes an initializer call to a new proxy.
+     * @param args - Array[singleton, initializer, saltNonce]
+     * @returns Array[proxy]
+     */
+    this.createProxyWithNonce = async (args) => {
+      return [await this.write("createProxyWithNonce", args)];
+    };
+  }
+};
+var SafeProxyFactoryContract_v1_4_1_default = SafeProxyFactoryContract_v1_4_1;
+
+// src/contracts/SimulateTxAccessor/v1.3.0/SimulateTxAccessorContract_v1_3_0.ts
+import {
+  simulateTxAccessor_1_3_0_ContractArtifacts
+} from "@safe-global/types-kit";
+
+// src/contracts/SimulateTxAccessor/v1.4.1/SimulateTxAccessorContract_v1_4_1.ts
+import {
+  simulateTxAccessor_1_4_1_ContractArtifacts
+} from "@safe-global/types-kit";
+
+// src/contracts/CompatibilityFallbackHandler/CompatibilityFallbackHandlerBaseContract.ts
+var CompatibilityFallbackHandlerBaseContract = class extends BaseContract_default {
+  /**
+   * @constructor
+   * Constructs an instance of  CompatibilityFallbackHandlerBaseContract.
+   *
+   * @param chainId - The chain ID of the contract.
+   * @param safeProvider - An instance of SafeProvider.
+   * @param defaultAbi - The default ABI for the CompatibilityFallbackHandler contract. It should be compatible with the specific version of the contract.
+   * @param safeVersion - The version of the Safe contract.
+   * @param customContractAddress - Optional custom address for the contract. If not provided, the address is derived from the Safe deployments based on the chainId and safeVersion.
+   * @param customContractAbi - Optional custom ABI for the contract. If not provided, the ABI is derived from the Safe deployments or the defaultAbi is used.
+   * @param deploymentType - Optional deployment type for the contract. If not provided, the first deployment retrieved from the safe-deployments array will be used.
+   */
+  constructor(chainId, safeProvider, defaultAbi, safeVersion, customContractAddress, customContractAbi, deploymentType) {
+    const contractName3 = "compatibilityFallbackHandler";
+    super(
+      contractName3,
+      chainId,
+      safeProvider,
+      defaultAbi,
+      safeVersion,
+      customContractAddress,
+      customContractAbi,
+      deploymentType
+    );
+    this.contractName = contractName3;
+  }
+};
+var CompatibilityFallbackHandlerBaseContract_default = CompatibilityFallbackHandlerBaseContract;
+
+// src/contracts/CompatibilityFallbackHandler/v1.3.0/CompatibilityFallbackHandlerContract_v1_3_0.ts
+import {
+  compatibilityFallbackHandler_1_3_0_ContractArtifacts
+} from "@safe-global/types-kit";
+var CompatibilityFallbackHandlerContract_v1_3_0 = class extends CompatibilityFallbackHandlerBaseContract_default {
+  /**
+   * Constructs an instance of CompatibilityFallbackHandlerContract_v1_3_0
+   *
+   * @param chainId - The chain ID where the contract resides.
+   * @param safeProvider - An instance of SafeProvider.
+   * @param customContractAddress - Optional custom address for the contract. If not provided, the address is derived from the CompatibilityFallbackHandler deployments based on the chainId and safeVersion.
+   * @param customContractAbi - Optional custom ABI for the contract. If not provided, the default ABI for version 1.3.0 is used.
+   * @param deploymentType - Optional deployment type for the contract. If not provided, the first deployment retrieved from the safe-deployments array will be used.
+   */
+  constructor(chainId, safeProvider, customContractAddress, customContractAbi, deploymentType) {
+    const safeVersion = "1.3.0";
+    const defaultAbi = compatibilityFallbackHandler_1_3_0_ContractArtifacts.abi;
+    super(
+      chainId,
+      safeProvider,
+      defaultAbi,
+      safeVersion,
+      customContractAddress,
+      customContractAbi,
+      deploymentType
+    );
+  }
+};
+var CompatibilityFallbackHandlerContract_v1_3_0_default = CompatibilityFallbackHandlerContract_v1_3_0;
+
+// src/contracts/CompatibilityFallbackHandler/v1.4.1/CompatibilityFallbackHandlerContract_v1_4_1.ts
+import {
+  compatibilityFallbackHandler_1_4_1_ContractArtifacts
+} from "@safe-global/types-kit";
+var CompatibilityFallbackHandlerContract_v1_4_1 = class extends CompatibilityFallbackHandlerBaseContract_default {
+  /**
+   * Constructs an instance of CompatibilityFallbackHandlerContract_v1_4_1
+   *
+   * @param chainId - The chain ID where the contract resides.
+   * @param safeProvider - An instance of SafeProvider.
+   * @param customContractAddress - Optional custom address for the contract. If not provided, the address is derived from the CompatibilityFallbackHandler deployments based on the chainId and safeVersion.
+   * @param customContractAbi - Optional custom ABI for the contract. If not provided, the default ABI for version 1.4.1 is used.
+   * @param deploymentType - Optional deployment type for the contract. If not provided, the first deployment retrieved from the safe-deployments array will be used.
+   */
+  constructor(chainId, safeProvider, customContractAddress, customContractAbi, deploymentType) {
+    const safeVersion = "1.4.1";
+    const defaultAbi = compatibilityFallbackHandler_1_4_1_ContractArtifacts.abi;
+    super(
+      chainId,
+      safeProvider,
+      defaultAbi,
+      safeVersion,
+      customContractAddress,
+      customContractAbi,
+      deploymentType
+    );
+  }
+};
+var CompatibilityFallbackHandlerContract_v1_4_1_default = CompatibilityFallbackHandlerContract_v1_4_1;
+
+// src/contracts/SafeWebAuthnSignerFactory/SafeWebAuthnSignerFactoryBaseContract.ts
+var SafeWebAuthnSignerFactoryBaseContract = class extends BaseContract_default {
+  /**
+   * @constructor
+   * Constructs an instance of SafeWebAuthnSignerFactoryBaseContract.
+   *
+   * @param chainId - The chain ID of the contract.
+   * @param safeProvider - An instance of SafeProvider.
+   * @param defaultAbi - The default ABI for the Safe contract. It should be compatible with the specific version of the contract.
+   * @param safeVersion - The version of the Safe contract.
+   * @param customContractAddress - Optional custom address for the contract. If not provided, the address is derived from the Safe deployments based on the chainId and safeVersion.
+   * @param customContractAbi - Optional custom ABI for the contract. If not provided, the ABI is derived from the Safe deployments or the defaultAbi is used.
+   * @param deploymentType - Optional deployment type for the contract. If not provided, the first deployment retrieved from the safe-deployments array will be used.
+   */
+  constructor(chainId, safeProvider, defaultAbi, safeVersion, customContractAddress, customContractAbi, deploymentType) {
+    const contractName3 = "safeWebAuthnSignerFactoryVersion";
+    super(
+      contractName3,
+      chainId,
+      safeProvider,
+      defaultAbi,
+      safeVersion,
+      customContractAddress,
+      customContractAbi,
+      deploymentType
+    );
+    this.contractName = contractName3;
+  }
+};
+var SafeWebAuthnSignerFactoryBaseContract_default = SafeWebAuthnSignerFactoryBaseContract;
+
+// src/contracts/SafeWebAuthnSignerFactory/v0.2.1/SafeWebAuthnSignerFactoryContract_v0_2_1.ts
+import {
+  SafeWebAuthnSignerFactory_0_2_1_ContractArtifacts
+} from "@safe-global/types-kit";
+var SafeWebAuthnSignerFactoryContract_v0_2_1 = class extends SafeWebAuthnSignerFactoryBaseContract_default {
+  /**
+   * Constructs an instance of SafeWebAuthnSignerFactoryContract_v0_2_1
+   *
+   * @param chainId - The chain ID where the contract resides.
+   * @param safeProvider - An instance of SafeProvider.
+   * @param safeVersion - The version of the Safe contract.
+   * @param customContractAddress - Optional custom address for the contract. If not provided, the address is derived from the Safe deployments based on the chainId and safeVersion.
+   * @param customContractAbi - Optional custom ABI for the contract. If not provided, the default ABI for version 0.2.1 is used.
+   * @param deploymentType - Optional deployment type for the contract. If not provided, the first deployment retrieved from the safe-deployments array will be used.
+   */
+  constructor(chainId, safeProvider, safeVersion, customContractAddress, customContractAbi, deploymentType) {
+    const defaultAbi = SafeWebAuthnSignerFactory_0_2_1_ContractArtifacts.abi;
+    super(
+      chainId,
+      safeProvider,
+      defaultAbi,
+      safeVersion,
+      customContractAddress,
+      customContractAbi,
+      deploymentType
+    );
+    /**
+     * Returns the address of the Signer.
+     * @param args - Array[x, y, verifiers]
+     * @returns Array[signer]
+     */
+    this.getSigner = async (args) => {
+      return [await this.read("getSigner", args)];
+    };
+    /**
+     * Returns the address of the Signer and deploy the signer contract if its not deployed yet.
+     * @param args - Array[x, y, verifiers]
+     * @returns Array[signer]
+     */
+    this.createSigner = async (args) => {
+      return [await this.write("createSigner", args)];
+    };
+    this.isValidSignatureForSigner = async (args) => {
+      return [await this.read("isValidSignatureForSigner", args)];
+    };
+  }
+};
+var SafeWebAuthnSignerFactoryContract_v0_2_1_default = SafeWebAuthnSignerFactoryContract_v0_2_1;
+
+// src/contracts/SafeWebAuthnSharedSigner/SafeWebAuthnSharedSignerBaseContract.ts
+var SafeWebAuthnSharedSignerBaseContract = class extends BaseContract_default {
+  /**
+   * @constructor
+   * Constructs an instance of SafeWebAuthnSharedSignerBaseContract.
+   *
+   * @param chainId - The chain ID of the contract.
+   * @param safeProvider - An instance of SafeProvider.
+   * @param defaultAbi - The default ABI for the Safe contract. It should be compatible with the specific version of the contract.
+   * @param safeVersion - The version of the Safe contract.
+   * @param customContractAddress - Optional custom address for the contract. If not provided, the address is derived from the Safe deployments based on the chainId and safeVersion.
+   * @param customContractAbi - Optional custom ABI for the contract. If not provided, the ABI is derived from the Safe deployments or the defaultAbi is used.
+   * @param deploymentType - Optional deployment type for the contract. If not provided, the first deployment retrieved from the safe-deployments array will be used.
+   */
+  constructor(chainId, safeProvider, defaultAbi, safeVersion, customContractAddress, customContractAbi, deploymentType) {
+    const contractName3 = "safeWebAuthnSharedSignerVersion";
+    super(
+      contractName3,
+      chainId,
+      safeProvider,
+      defaultAbi,
+      safeVersion,
+      customContractAddress,
+      customContractAbi,
+      deploymentType
+    );
+    this.contractName = contractName3;
+  }
+};
+var SafeWebAuthnSharedSignerBaseContract_default = SafeWebAuthnSharedSignerBaseContract;
+
+// src/contracts/SafeWebAuthnSharedSigner/v0.2.1/SafeWebAuthnSharedSignerContract_v0_2_1.ts
+import {
+  SafeWebAuthnSharedSigner_0_2_1_ContractArtifacts
+} from "@safe-global/types-kit";
+var SafeWebAuthnSharedSignerContract_v0_2_1 = class extends SafeWebAuthnSharedSignerBaseContract_default {
+  /**
+   * Constructs an instance of SafeWebAuthnSharedSignerContract_v0_2_1
+   *
+   * @param chainId - The chain ID where the contract resides.
+   * @param safeProvider - An instance of SafeProvider.
+   * @param safeVersion - The version of the Safe contract.
+   * @param customContractAddress - Optional custom address for the contract. If not provided, the address is derived from the Safe deployments based on the chainId and safeVersion.
+   * @param customContractAbi - Optional custom ABI for the contract. If not provided, the default ABI for version 0.2.1 is used.
+   * @param deploymentType - Optional deployment type for the contract. If not provided, the first deployment retrieved from the safe-deployments array will be used.
+   */
+  constructor(chainId, safeProvider, safeVersion, customContractAddress, customContractAbi, deploymentType) {
+    const defaultAbi = SafeWebAuthnSharedSigner_0_2_1_ContractArtifacts.abi;
+    super(
+      chainId,
+      safeProvider,
+      defaultAbi,
+      safeVersion,
+      customContractAddress,
+      customContractAbi,
+      deploymentType
+    );
+    /**
+     * Return the signer configuration for the specified account.
+     * @param args - Array[address]
+     * @returns Array[signer]
+     */
+    this.getConfiguration = async (args) => {
+      return [await this.read("getConfiguration", args)];
+    };
+    /**
+     * Sets the signer configuration for the calling account.
+     * @param args - Array[signer]
+     * @returns Array[]
+     */
+    this.configure = async (args) => {
+      await this.write("configure", args);
+      return [];
+    };
+    this.isValidSignature = async (args) => {
+      return [await this.read("isValidSignature", args)];
+    };
+    /**
+     * @returns The starting storage slot on the account containing the signer data.
+     */
+    this.SIGNER_SLOT = async () => {
+      return [await this.read("SIGNER_SLOT")];
+    };
+  }
+};
+var SafeWebAuthnSharedSignerContract_v0_2_1_default = SafeWebAuthnSharedSignerContract_v0_2_1;
+
+// src/contracts/contractInstances.ts
+async function getSafeContractInstance(safeVersion, safeProvider, contractAddress, customContractAbi, isL1SafeSingleton, deploymentType) {
+  const chainId = await safeProvider.getChainId();
+  let safeContractInstance;
+  switch (safeVersion) {
+    case "1.4.1":
+      safeContractInstance = new SafeContract_v1_4_1_default(
+        chainId,
+        safeProvider,
+        isL1SafeSingleton,
+        contractAddress,
+        customContractAbi,
+        deploymentType
+      );
+      break;
+    case "1.3.0":
+      safeContractInstance = new SafeContract_v1_3_0_default(
+        chainId,
+        safeProvider,
+        isL1SafeSingleton,
+        contractAddress,
+        customContractAbi,
+        deploymentType
+      );
+      break;
+    case "1.2.0":
+      safeContractInstance = new SafeContract_v1_2_0_default(
+        chainId,
+        safeProvider,
+        isL1SafeSingleton,
+        contractAddress,
+        customContractAbi,
+        deploymentType
+      );
+      break;
+    case "1.1.1":
+      safeContractInstance = new SafeContract_v1_1_1_default(
+        chainId,
+        safeProvider,
+        isL1SafeSingleton,
+        contractAddress,
+        customContractAbi,
+        deploymentType
+      );
+      break;
+    case "1.0.0":
+      safeContractInstance = new SafeContract_v1_0_0_default(
+        chainId,
+        safeProvider,
+        isL1SafeSingleton,
+        contractAddress,
+        customContractAbi,
+        deploymentType
+      );
+      break;
+    default:
+      throw new Error("Invalid Safe version");
+  }
+  await safeContractInstance.init();
+  return safeContractInstance;
+}
+async function getCompatibilityFallbackHandlerContractInstance(safeVersion, safeProvider, contractAddress, customContractAbi, deploymentType) {
+  const chainId = await safeProvider.getChainId();
+  let compatibilityFallbackHandlerInstance;
+  switch (safeVersion) {
+    case "1.4.1":
+      compatibilityFallbackHandlerInstance = new CompatibilityFallbackHandlerContract_v1_4_1_default(
+        chainId,
+        safeProvider,
+        contractAddress,
+        customContractAbi,
+        deploymentType
+      );
+      break;
+    case "1.3.0":
+    case "1.2.0":
+    case "1.1.1":
+      compatibilityFallbackHandlerInstance = new CompatibilityFallbackHandlerContract_v1_3_0_default(
+        chainId,
+        safeProvider,
+        contractAddress,
+        customContractAbi,
+        deploymentType
+      );
+      break;
+    default:
+      throw new Error("Invalid Safe version");
+  }
+  await compatibilityFallbackHandlerInstance.init();
+  return compatibilityFallbackHandlerInstance;
+}
+async function getSafeProxyFactoryContractInstance(safeVersion, safeProvider, contractAddress, customContractAbi, deploymentType) {
+  const chainId = await safeProvider.getChainId();
+  let safeProxyFactoryContractInstance;
+  switch (safeVersion) {
+    case "1.4.1":
+      safeProxyFactoryContractInstance = new SafeProxyFactoryContract_v1_4_1_default(
+        chainId,
+        safeProvider,
+        contractAddress,
+        customContractAbi,
+        deploymentType
+      );
+      break;
+    case "1.3.0":
+      safeProxyFactoryContractInstance = new SafeProxyFactoryContract_v1_3_0_default(
+        chainId,
+        safeProvider,
+        contractAddress,
+        customContractAbi,
+        deploymentType
+      );
+      break;
+    case "1.2.0":
+    case "1.1.1":
+      safeProxyFactoryContractInstance = new SafeProxyFactoryContract_v1_1_1_default(
+        chainId,
+        safeProvider,
+        contractAddress,
+        customContractAbi,
+        deploymentType
+      );
+      break;
+    case "1.0.0":
+      safeProxyFactoryContractInstance = new SafeProxyFactoryContract_v1_0_0_default(
+        chainId,
+        safeProvider,
+        contractAddress,
+        customContractAbi,
+        deploymentType
+      );
+      break;
+    default:
+      throw new Error("Invalid Safe version");
+  }
+  await safeProxyFactoryContractInstance.init();
+  return safeProxyFactoryContractInstance;
+}
+async function getSafeWebAuthnSignerFactoryContractInstance(safeVersion, safeProvider, contractAddress, customContractAbi, deploymentType) {
+  const chainId = await safeProvider.getChainId();
+  switch (safeVersion) {
+    case "1.4.1":
+    case "1.3.0":
+      const safeWebAuthnSignerFactoryContractInstance = new SafeWebAuthnSignerFactoryContract_v0_2_1_default(
+        chainId,
+        safeProvider,
+        safeVersion,
+        contractAddress,
+        customContractAbi,
+        deploymentType
+      );
+      await safeWebAuthnSignerFactoryContractInstance.init();
+      return safeWebAuthnSignerFactoryContractInstance;
+    default:
+      throw new Error("Invalid Safe version");
+  }
+}
+async function getSafeWebAuthnSharedSignerContractInstance(safeVersion, safeProvider, contractAddress, customContractAbi, deploymentType) {
+  const chainId = await safeProvider.getChainId();
+  switch (safeVersion) {
+    case "1.4.1":
+    case "1.3.0":
+      const safeWebAuthnSharedSignerContractInstance = new SafeWebAuthnSharedSignerContract_v0_2_1_default(
+        chainId,
+        safeProvider,
+        safeVersion,
+        contractAddress,
+        customContractAbi,
+        deploymentType
+      );
+      await safeWebAuthnSharedSignerContractInstance.init();
+      return safeWebAuthnSharedSignerContractInstance;
+    default:
+      throw new Error("Invalid Safe version");
+  }
+}
+
+// src/contracts/safeDeploymentContracts.ts
+async function getSafeContract({
+  safeProvider,
+  safeVersion,
+  customSafeAddress,
+  isL1SafeSingleton,
+  customContracts,
+  deploymentType
+}) {
+  const safeContract = await getSafeContractInstance(
+    safeVersion,
+    safeProvider,
+    customSafeAddress ?? customContracts?.safeSingletonAddress,
+    customContracts?.safeSingletonAbi,
+    isL1SafeSingleton,
+    deploymentType
+  );
+  const isContractDeployed = await safeProvider.isContractDeployed(safeContract.getAddress());
+  if (!isContractDeployed) {
+    throw new Error("SafeProxy contract is not deployed on the current network");
+  }
+  return safeContract;
+}
+async function getSafeProxyFactoryContract({
+  safeProvider,
+  safeVersion,
+  customContracts,
+  deploymentType
+}) {
+  const safeProxyFactoryContract = await getSafeProxyFactoryContractInstance(
+    safeVersion,
+    safeProvider,
+    customContracts?.safeProxyFactoryAddress,
+    customContracts?.safeProxyFactoryAbi,
+    deploymentType
+  );
+  const isContractDeployed = await safeProvider.isContractDeployed(
+    safeProxyFactoryContract.getAddress()
+  );
+  if (!isContractDeployed) {
+    throw new Error("SafeProxyFactory contract is not deployed on the current network");
+  }
+  return safeProxyFactoryContract;
+}
+async function getCompatibilityFallbackHandlerContract({
+  safeProvider,
+  safeVersion,
+  customContracts,
+  deploymentType
+}) {
+  const fallbackHandlerContract = await getCompatibilityFallbackHandlerContractInstance(
+    safeVersion,
+    safeProvider,
+    customContracts?.fallbackHandlerAddress,
+    customContracts?.fallbackHandlerAbi,
+    deploymentType
+  );
+  const isContractDeployed = await safeProvider.isContractDeployed(
+    fallbackHandlerContract.getAddress()
+  );
+  if (!isContractDeployed) {
+    throw new Error("CompatibilityFallbackHandler contract is not deployed on the current network");
+  }
+  return fallbackHandlerContract;
+}
+async function getSafeWebAuthnSignerFactoryContract({
+  safeProvider,
+  safeVersion,
+  customContracts,
+  deploymentType
+}) {
+  const safeWebAuthnSignerFactoryContract = await getSafeWebAuthnSignerFactoryContractInstance(
+    safeVersion,
+    safeProvider,
+    customContracts?.safeWebAuthnSignerFactoryAddress,
+    customContracts?.safeWebAuthnSignerFactoryAbi,
+    deploymentType
+  );
+  const isContractDeployed = await safeProvider.isContractDeployed(
+    safeWebAuthnSignerFactoryContract.getAddress()
+  );
+  if (!isContractDeployed) {
+    throw new Error("safeWebAuthnSignerFactory contract is not deployed on the current network");
+  }
+  return safeWebAuthnSignerFactoryContract;
+}
+async function getSafeWebAuthnSharedSignerContract({
+  safeProvider,
+  safeVersion,
+  customContracts,
+  deploymentType
+}) {
+  const safeWebAuthnSharedSignerContract = await getSafeWebAuthnSharedSignerContractInstance(
+    safeVersion,
+    safeProvider,
+    customContracts?.safeWebAuthnSharedSignerAddress,
+    customContracts?.safeWebAuthnSharedSignerAbi,
+    deploymentType
+  );
+  const isContractDeployed = await safeProvider.isContractDeployed(
+    safeWebAuthnSharedSignerContract.getAddress()
+  );
+  if (!isContractDeployed) {
+    throw new Error("safeWebAuthnSharedSigner contract is not deployed on the current network");
+  }
+  return safeWebAuthnSharedSignerContract;
+}
+
+// src/utils/transactions/gas.ts
+var CALL_DATA_BYTE_GAS_COST = 16;
+var ECRECOVER_GAS_COST = 6e3;
+var GAS_COST_PER_SIGNATURE = 1 * CALL_DATA_BYTE_GAS_COST + 2 * 32 * CALL_DATA_BYTE_GAS_COST + ECRECOVER_GAS_COST;
+
+// src/utils/transactions/utils.ts
+import {
+  OperationType as OperationType2
+} from "@safe-global/types-kit";
+import semverSatisfies6 from "semver/functions/satisfies.js";
+import {
+  toBytes as toBytes3,
+  getAddress as getAddress2,
+  encodePacked,
+  bytesToHex,
+  decodeFunctionData,
+  parseAbi as parseAbi3
+} from "viem";
+import { waitForTransactionReceipt as waitForTransactionReceiptViem } from "viem/actions";
+function toEstimateGasParameters(tx) {
+  const params = isLegacyTransaction(tx) ? createLegacyTxOptions(tx) : createTxOptions(tx);
+  if (tx.value) {
+    params.value = BigInt(tx.value);
+  }
+  if (tx.to) {
+    params.to = tx.to;
+  }
+  if (tx.data) {
+    params.data = asHex(tx.data);
+  }
+  return params;
+}
+function toTransactionRequest(tx) {
+  const params = isLegacyTransaction(tx) ? createLegacyTxOptions(tx) : createTxOptions(tx);
+  if (tx.to) {
+    params.to = tx.to;
+  }
+  if (tx.data) {
+    params.data = asHex(tx.data);
+  }
+  return params;
+}
+function convertTransactionOptions(options) {
+  return isLegacyTransaction(options) ? createLegacyTxOptions(options) : createTxOptions(options);
+}
+function isLegacyTransaction(options) {
+  return !!options?.gasPrice;
+}
+function createLegacyTxOptions(options) {
+  const converted = {};
+  if (options?.from) {
+    converted.account = options.from;
+  }
+  if (options?.gasLimit) {
+    converted.gas = BigInt(options.gasLimit);
+  }
+  if (options?.gasPrice) {
+    converted.gasPrice = BigInt(options.gasPrice);
+  }
+  if (options?.nonce) {
+    converted.nonce = options.nonce;
+  }
+  return converted;
+}
+function createTxOptions(options) {
+  const converted = {};
+  if (options?.from) {
+    converted.account = options.from;
+  }
+  if (options?.gasLimit) {
+    converted.gas = BigInt(options.gasLimit);
+  }
+  if (options?.maxFeePerGas) {
+    converted.maxFeePerGas = BigInt(options.maxFeePerGas);
+  }
+  if (options?.maxPriorityFeePerGas) {
+    converted.maxPriorityFeePerGas = BigInt(options.maxPriorityFeePerGas);
+  }
+  if (options?.nonce) {
+    converted.nonce = options.nonce;
+  }
+  return converted;
+}
+
+// test-utils/passkeys.ts
+var singleInstance;
+function getWebAuthnCredentials() {
+  if (!singleInstance) {
+    singleInstance = new WebAuthnCredentials();
+  }
+  return singleInstance;
+}
+async function deployPasskeysContract(passkeys, signer) {
+  const toDeploy = passkeys.map(async (client) => {
+    const { data, to, value } = client.createDeployTxRequest();
+    const createPasskeySignerTransaction = {
+      to,
+      value: BigInt(value),
+      data: asHex(data)
+    };
+    return await signer.sendTransaction(createPasskeySignerTransaction);
+  });
+  return Promise.all(toDeploy);
+}
+async function createMockPasskey(name, webAuthnCredentials) {
+  const credentialsInstance = webAuthnCredentials ?? getWebAuthnCredentials();
+  const passkeyCredential = credentialsInstance.create({
+    publicKey: {
+      rp: {
+        name: "Safe",
+        id: "safe.global"
+      },
+      user: {
+        id: toBytes4(keccak2563(toBytes4(name))),
+        name,
+        displayName: name
+      },
+      challenge: toBytes4(Date.now()),
+      pubKeyCredParams: [{ type: "public-key", alg: -7 }]
+    }
+  });
+  const algorithm = {
+    name: "ECDSA",
+    namedCurve: "P-256",
+    hash: { name: "SHA-256" }
+  };
+  const key = await crypto.subtle.importKey(
+    "raw",
+    passkeyCredential.response.getPublicKey(),
+    algorithm,
+    true,
+    ["verify"]
+  );
+  const exportedPublicKey = await crypto.subtle.exportKey("spki", key);
+  const rawId = Buffer.from(passkeyCredential.rawId).toString("hex");
+  const coordinates = await decodePublicKeyForWeb(exportedPublicKey);
+  const passkey = {
+    rawId,
+    coordinates
+  };
+  return passkey;
+}
+export {
+  WebAuthnCredentials,
+  base64UrlEncode,
+  createMockPasskey,
+  deployPasskeysContract,
+  encodeWebAuthnSigningMessage,
+  getWebAuthnCredentials,
+  userVerificationFlag
+};