damm-sdk 1.4.11 → 1.4.12

package/dist/index.cjs

@@ -244,6 +244,36 @@ var init_fromHex = __esm(() => {
 });
 
 // node_modules/viem/_esm/utils/encoding/toHex.js
+function toHex(value, opts = {}) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return numberToHex(value, opts);
+  if (typeof value === "string") {
+    return stringToHex(value, opts);
+  }
+  if (typeof value === "boolean")
+    return boolToHex(value, opts);
+  return bytesToHex(value, opts);
+}
+function boolToHex(value, opts = {}) {
+  const hex = `0x${Number(value)}`;
+  if (typeof opts.size === "number") {
+    assertSize(hex, { size: opts.size });
+    return pad(hex, { size: opts.size });
+  }
+  return hex;
+}
+function bytesToHex(value, opts = {}) {
+  let string = "";
+  for (let i = 0;i < value.length; i++) {
+    string += hexes[value[i]];
+  }
+  const hex = `0x${string}`;
+  if (typeof opts.size === "number") {
+    assertSize(hex, { size: opts.size });
+    return pad(hex, { dir: "right", size: opts.size });
+  }
+  return hex;
+}
 function numberToHex(value_, opts = {}) {
   const { signed, size: size2 } = opts;
   const value = BigInt(value_);
@@ -272,9 +302,497 @@ function numberToHex(value_, opts = {}) {
     return pad(hex, { size: size2 });
   return hex;
 }
+function stringToHex(value_, opts = {}) {
+  const value = encoder.encode(value_);
+  return bytesToHex(value, opts);
+}
+var hexes, encoder;
 var init_toHex = __esm(() => {
   init_encoding();
   init_pad();
+  init_fromHex();
+  hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
+  encoder = /* @__PURE__ */ new TextEncoder;
+});
+
+// node_modules/viem/_esm/utils/encoding/toBytes.js
+function toBytes(value, opts = {}) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return numberToBytes(value, opts);
+  if (typeof value === "boolean")
+    return boolToBytes(value, opts);
+  if (isHex(value))
+    return hexToBytes(value, opts);
+  return stringToBytes(value, opts);
+}
+function boolToBytes(value, opts = {}) {
+  const bytes = new Uint8Array(1);
+  bytes[0] = Number(value);
+  if (typeof opts.size === "number") {
+    assertSize(bytes, { size: opts.size });
+    return pad(bytes, { size: opts.size });
+  }
+  return bytes;
+}
+function charCodeToBase16(char) {
+  if (char >= charCodeMap.zero && char <= charCodeMap.nine)
+    return char - charCodeMap.zero;
+  if (char >= charCodeMap.A && char <= charCodeMap.F)
+    return char - (charCodeMap.A - 10);
+  if (char >= charCodeMap.a && char <= charCodeMap.f)
+    return char - (charCodeMap.a - 10);
+  return;
+}
+function hexToBytes(hex_, opts = {}) {
+  let hex = hex_;
+  if (opts.size) {
+    assertSize(hex, { size: opts.size });
+    hex = pad(hex, { dir: "right", size: opts.size });
+  }
+  let hexString = hex.slice(2);
+  if (hexString.length % 2)
+    hexString = `0${hexString}`;
+  const length = hexString.length / 2;
+  const bytes = new Uint8Array(length);
+  for (let index = 0, j = 0;index < length; index++) {
+    const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
+    const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
+    if (nibbleLeft === undefined || nibbleRight === undefined) {
+      throw new BaseError(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
+    }
+    bytes[index] = nibbleLeft * 16 + nibbleRight;
+  }
+  return bytes;
+}
+function numberToBytes(value, opts) {
+  const hex = numberToHex(value, opts);
+  return hexToBytes(hex);
+}
+function stringToBytes(value, opts = {}) {
+  const bytes = encoder2.encode(value);
+  if (typeof opts.size === "number") {
+    assertSize(bytes, { size: opts.size });
+    return pad(bytes, { dir: "right", size: opts.size });
+  }
+  return bytes;
+}
+var encoder2, charCodeMap;
+var init_toBytes = __esm(() => {
+  init_base();
+  init_pad();
+  init_fromHex();
+  init_toHex();
+  encoder2 = /* @__PURE__ */ new TextEncoder;
+  charCodeMap = {
+    zero: 48,
+    nine: 57,
+    A: 65,
+    F: 70,
+    a: 97,
+    f: 102
+  };
+});
+
+// node_modules/@noble/hashes/esm/_u64.js
+function fromBig(n, le = false) {
+  if (le)
+    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split(lst, le = false) {
+  const len = lst.length;
+  let Ah = new Uint32Array(len);
+  let Al = new Uint32Array(len);
+  for (let i = 0;i < len; i++) {
+    const { h, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h, l];
+  }
+  return [Ah, Al];
+}
+var U32_MASK64, _32n, rotlSH = (h, l, s) => h << s | l >>> 32 - s, rotlSL = (h, l, s) => l << s | h >>> 32 - s, rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s, rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+var init__u64 = __esm(() => {
+  U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+  _32n = /* @__PURE__ */ BigInt(32);
+});
+
+// node_modules/@noble/hashes/esm/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error("positive integer expected, got " + n);
+}
+function abytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
+}
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function clean(...arrays) {
+  for (let i = 0;i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function byteSwap(word) {
+  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+}
+function byteSwap32(arr) {
+  for (let i = 0;i < arr.length; i++) {
+    arr[i] = byteSwap(arr[i]);
+  }
+  return arr;
+}
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes2(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
+}
+
+class Hash {
+}
+function createHasher(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+var isLE, swap32IfBE;
+var init_utils = __esm(() => {
+  /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+  isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+  swap32IfBE = isLE ? (u) => u : byteSwap32;
+});
+
+// node_modules/@noble/hashes/esm/sha3.js
+function keccakP(s, rounds = 24) {
+  const B = new Uint32Array(5 * 2);
+  for (let round = 24 - rounds;round < 24; round++) {
+    for (let x = 0;x < 10; x++)
+      B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+    for (let x = 0;x < 10; x += 2) {
+      const idx1 = (x + 8) % 10;
+      const idx0 = (x + 2) % 10;
+      const B0 = B[idx0];
+      const B1 = B[idx0 + 1];
+      const Th = rotlH(B0, B1, 1) ^ B[idx1];
+      const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+      for (let y = 0;y < 50; y += 10) {
+        s[x + y] ^= Th;
+        s[x + y + 1] ^= Tl;
+      }
+    }
+    let curH = s[2];
+    let curL = s[3];
+    for (let t = 0;t < 24; t++) {
+      const shift = SHA3_ROTL[t];
+      const Th = rotlH(curH, curL, shift);
+      const Tl = rotlL(curH, curL, shift);
+      const PI = SHA3_PI[t];
+      curH = s[PI];
+      curL = s[PI + 1];
+      s[PI] = Th;
+      s[PI + 1] = Tl;
+    }
+    for (let y = 0;y < 50; y += 10) {
+      for (let x = 0;x < 10; x++)
+        B[x] = s[y + x];
+      for (let x = 0;x < 10; x++)
+        s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+    }
+    s[0] ^= SHA3_IOTA_H[round];
+    s[1] ^= SHA3_IOTA_L[round];
+  }
+  clean(B);
+}
+var _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_PI, SHA3_ROTL, _SHA3_IOTA, IOTAS, SHA3_IOTA_H, SHA3_IOTA_L, rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s), rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s), Keccak, gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen)), keccak_256;
+var init_sha3 = __esm(() => {
+  init__u64();
+  init_utils();
+  _0n = BigInt(0);
+  _1n = BigInt(1);
+  _2n = BigInt(2);
+  _7n = BigInt(7);
+  _256n = BigInt(256);
+  _0x71n = BigInt(113);
+  SHA3_PI = [];
+  SHA3_ROTL = [];
+  _SHA3_IOTA = [];
+  for (let round = 0, R = _1n, x = 1, y = 0;round < 24; round++) {
+    [x, y] = [y, (2 * x + 3 * y) % 5];
+    SHA3_PI.push(2 * (5 * y + x));
+    SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+    let t = _0n;
+    for (let j = 0;j < 7; j++) {
+      R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
+      if (R & _2n)
+        t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
+    }
+    _SHA3_IOTA.push(t);
+  }
+  IOTAS = split(_SHA3_IOTA, true);
+  SHA3_IOTA_H = IOTAS[0];
+  SHA3_IOTA_L = IOTAS[1];
+  Keccak = class Keccak extends Hash {
+    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+      super();
+      this.pos = 0;
+      this.posOut = 0;
+      this.finished = false;
+      this.destroyed = false;
+      this.enableXOF = false;
+      this.blockLen = blockLen;
+      this.suffix = suffix;
+      this.outputLen = outputLen;
+      this.enableXOF = enableXOF;
+      this.rounds = rounds;
+      anumber(outputLen);
+      if (!(0 < blockLen && blockLen < 200))
+        throw new Error("only keccak-f1600 function is supported");
+      this.state = new Uint8Array(200);
+      this.state32 = u32(this.state);
+    }
+    clone() {
+      return this._cloneInto();
+    }
+    keccak() {
+      swap32IfBE(this.state32);
+      keccakP(this.state32, this.rounds);
+      swap32IfBE(this.state32);
+      this.posOut = 0;
+      this.pos = 0;
+    }
+    update(data) {
+      aexists(this);
+      data = toBytes2(data);
+      abytes(data);
+      const { blockLen, state } = this;
+      const len = data.length;
+      for (let pos = 0;pos < len; ) {
+        const take = Math.min(blockLen - this.pos, len - pos);
+        for (let i = 0;i < take; i++)
+          state[this.pos++] ^= data[pos++];
+        if (this.pos === blockLen)
+          this.keccak();
+      }
+      return this;
+    }
+    finish() {
+      if (this.finished)
+        return;
+      this.finished = true;
+      const { state, suffix, pos, blockLen } = this;
+      state[pos] ^= suffix;
+      if ((suffix & 128) !== 0 && pos === blockLen - 1)
+        this.keccak();
+      state[blockLen - 1] ^= 128;
+      this.keccak();
+    }
+    writeInto(out) {
+      aexists(this, false);
+      abytes(out);
+      this.finish();
+      const bufferOut = this.state;
+      const { blockLen } = this;
+      for (let pos = 0, len = out.length;pos < len; ) {
+        if (this.posOut >= blockLen)
+          this.keccak();
+        const take = Math.min(blockLen - this.posOut, len - pos);
+        out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+        this.posOut += take;
+        pos += take;
+      }
+      return out;
+    }
+    xofInto(out) {
+      if (!this.enableXOF)
+        throw new Error("XOF is not possible for this instance");
+      return this.writeInto(out);
+    }
+    xof(bytes) {
+      anumber(bytes);
+      return this.xofInto(new Uint8Array(bytes));
+    }
+    digestInto(out) {
+      aoutput(out, this);
+      if (this.finished)
+        throw new Error("digest() was already called");
+      this.writeInto(out);
+      this.destroy();
+      return out;
+    }
+    digest() {
+      return this.digestInto(new Uint8Array(this.outputLen));
+    }
+    destroy() {
+      this.destroyed = true;
+      clean(this.state);
+    }
+    _cloneInto(to) {
+      const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+      to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+      to.state32.set(this.state32);
+      to.pos = this.pos;
+      to.posOut = this.posOut;
+      to.finished = this.finished;
+      to.rounds = rounds;
+      to.suffix = suffix;
+      to.outputLen = outputLen;
+      to.enableXOF = enableXOF;
+      to.destroyed = this.destroyed;
+      return to;
+    }
+  };
+  keccak_256 = /* @__PURE__ */ (() => gen(1, 136, 256 / 8))();
+});
+
+// node_modules/viem/_esm/utils/hash/keccak256.js
+function keccak256(value, to_) {
+  const to = to_ || "hex";
+  const bytes = keccak_256(isHex(value, { strict: false }) ? toBytes(value) : value);
+  if (to === "bytes")
+    return bytes;
+  return toHex(bytes);
+}
+var init_keccak256 = __esm(() => {
+  init_sha3();
+  init_toBytes();
+  init_toHex();
+});
+
+// node_modules/viem/_esm/errors/address.js
+var InvalidAddressError;
+var init_address = __esm(() => {
+  init_base();
+  InvalidAddressError = class InvalidAddressError extends BaseError {
+    constructor({ address }) {
+      super(`Address "${address}" is invalid.`, {
+        metaMessages: [
+          "- Address must be a hex value of 20 bytes (40 hex characters).",
+          "- Address must match its checksum counterpart."
+        ],
+        name: "InvalidAddressError"
+      });
+    }
+  };
+});
+
+// node_modules/viem/_esm/utils/lru.js
+var LruMap;
+var init_lru = __esm(() => {
+  LruMap = class LruMap extends Map {
+    constructor(size2) {
+      super();
+      Object.defineProperty(this, "maxSize", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      this.maxSize = size2;
+    }
+    get(key) {
+      const value = super.get(key);
+      if (super.has(key) && value !== undefined) {
+        this.delete(key);
+        super.set(key, value);
+      }
+      return value;
+    }
+    set(key, value) {
+      super.set(key, value);
+      if (this.maxSize && this.size > this.maxSize) {
+        const firstKey = this.keys().next().value;
+        if (firstKey)
+          this.delete(firstKey);
+      }
+      return this;
+    }
+  };
+});
+
+// node_modules/viem/_esm/utils/address/getAddress.js
+function checksumAddress(address_, chainId) {
+  if (checksumAddressCache.has(`${address_}.${chainId}`))
+    return checksumAddressCache.get(`${address_}.${chainId}`);
+  const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
+  const hash = keccak256(stringToBytes(hexAddress), "bytes");
+  const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
+  for (let i = 0;i < 40; i += 2) {
+    if (hash[i >> 1] >> 4 >= 8 && address[i]) {
+      address[i] = address[i].toUpperCase();
+    }
+    if ((hash[i >> 1] & 15) >= 8 && address[i + 1]) {
+      address[i + 1] = address[i + 1].toUpperCase();
+    }
+  }
+  const result = `0x${address.join("")}`;
+  checksumAddressCache.set(`${address_}.${chainId}`, result);
+  return result;
+}
+function getAddress(address, chainId) {
+  if (!isAddress(address, { strict: false }))
+    throw new InvalidAddressError({ address });
+  return checksumAddress(address, chainId);
+}
+var checksumAddressCache;
+var init_getAddress = __esm(() => {
+  init_address();
+  init_toBytes();
+  init_keccak256();
+  init_lru();
+  init_isAddress();
+  checksumAddressCache = /* @__PURE__ */ new LruMap(8192);
+});
+
+// node_modules/viem/_esm/utils/address/isAddress.js
+function isAddress(address, options) {
+  const { strict = true } = options ?? {};
+  const cacheKey = `${address}.${strict}`;
+  if (isAddressCache.has(cacheKey))
+    return isAddressCache.get(cacheKey);
+  const result = (() => {
+    if (!addressRegex.test(address))
+      return false;
+    if (address.toLowerCase() === address)
+      return true;
+    if (strict)
+      return checksumAddress(address) === address;
+    return true;
+  })();
+  isAddressCache.set(cacheKey, result);
+  return result;
+}
+var addressRegex, isAddressCache;
+var init_isAddress = __esm(() => {
+  init_lru();
+  init_getAddress();
+  addressRegex = /^0x[a-fA-F0-9]{40}$/;
+  isAddressCache = /* @__PURE__ */ new LruMap(8192);
 });
 
 // node_modules/viem/_esm/constants/number.js
@@ -438,8 +956,8 @@ function fromByteArray(uint8) {
     tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1], parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
   return parts.join("");
 }
-function read(buffer, offset, isLE, mLen, nBytes) {
-  var e, m, eLen = nBytes * 8 - mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1, nBits = -7, i2 = isLE ? nBytes - 1 : 0, d = isLE ? -1 : 1, s = buffer[offset + i2];
+function read(buffer, offset, isLE2, mLen, nBytes) {
+  var e, m, eLen = nBytes * 8 - mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1, nBits = -7, i2 = isLE2 ? nBytes - 1 : 0, d = isLE2 ? -1 : 1, s = buffer[offset + i2];
   i2 += d, e = s & (1 << -nBits) - 1, s >>= -nBits, nBits += eLen;
   for (;nBits > 0; e = e * 256 + buffer[offset + i2], i2 += d, nBits -= 8)
     ;
@@ -454,8 +972,8 @@ function read(buffer, offset, isLE, mLen, nBytes) {
     m = m + Math.pow(2, mLen), e = e - eBias;
   return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
 }
-function write(buffer, value, offset, isLE, mLen, nBytes) {
-  var e, m, c, eLen = nBytes * 8 - mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1, rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, i2 = isLE ? 0 : nBytes - 1, d = isLE ? 1 : -1, s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+function write(buffer, value, offset, isLE2, mLen, nBytes) {
+  var e, m, c, eLen = nBytes * 8 - mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1, rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, i2 = isLE2 ? 0 : nBytes - 1, d = isLE2 ? 1 : -1, s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
   if (value = Math.abs(value), isNaN(value) || value === 1 / 0)
     m = isNaN(value) ? 1 : 0, e = eMax;
   else {
@@ -627,7 +1145,7 @@ function byteLength(string, encoding) {
         return len2;
       case "utf8":
       case "utf-8":
-        return utf8ToBytes(string).length;
+        return utf8ToBytes2(string).length;
       case "ucs2":
       case "ucs-2":
       case "utf16le":
@@ -639,7 +1157,7 @@ function byteLength(string, encoding) {
         return base64ToBytes(string).length;
       default:
         if (loweredCase)
-          return mustMatch ? -1 : utf8ToBytes(string).length;
+          return mustMatch ? -1 : utf8ToBytes2(string).length;
         encoding = ("" + encoding).toLowerCase(), loweredCase = true;
     }
 }
@@ -790,7 +1308,7 @@ function hexWrite(buf, string, offset, length) {
   return i2;
 }
 function utf8Write(buf, string, offset, length) {
-  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
+  return blitBuffer(utf8ToBytes2(string, buf.length - offset), buf, offset, length);
 }
 function asciiWrite(buf, string, offset, length) {
   return blitBuffer(asciiToBytes(string), buf, offset, length);
@@ -972,7 +1490,7 @@ function base64clean(str) {
     str = str + "=";
   return str;
 }
-function utf8ToBytes(string, units) {
+function utf8ToBytes2(string, units) {
   units = units || 1 / 0;
   let codePoint, length = string.length, leadSurrogate = null, bytes = [];
   for (let i2 = 0;i2 < length; ++i2) {
@@ -4720,12 +5238,12 @@ var require_sha3 = __commonJS((exports2, module2) => {
     }
     var createOutputMethod = function(bits2, padding, outputType) {
       return function(message) {
-        return new Keccak(bits2, padding, bits2).update(message)[outputType]();
+        return new Keccak2(bits2, padding, bits2).update(message)[outputType]();
       };
     };
     var createShakeOutputMethod = function(bits2, padding, outputType) {
       return function(message, outputBits) {
-        return new Keccak(bits2, padding, outputBits).update(message)[outputType]();
+        return new Keccak2(bits2, padding, outputBits).update(message)[outputType]();
       };
     };
     var createCshakeOutputMethod = function(bits2, padding, outputType) {
@@ -4748,7 +5266,7 @@ var require_sha3 = __commonJS((exports2, module2) => {
     var createMethod = function(bits2, padding) {
       var method = createOutputMethod(bits2, padding, "hex");
       method.create = function() {
-        return new Keccak(bits2, padding, bits2);
+        return new Keccak2(bits2, padding, bits2);
       };
       method.update = function(message) {
         return method.create().update(message);
@@ -4758,7 +5276,7 @@ var require_sha3 = __commonJS((exports2, module2) => {
     var createShakeMethod = function(bits2, padding) {
       var method = createShakeOutputMethod(bits2, padding, "hex");
       method.create = function(outputBits) {
-        return new Keccak(bits2, padding, outputBits);
+        return new Keccak2(bits2, padding, outputBits);
       };
       method.update = function(message, outputBits) {
         return method.create(outputBits).update(message);
@@ -4772,7 +5290,7 @@ var require_sha3 = __commonJS((exports2, module2) => {
         if (!n && !s) {
           return methods["shake" + bits2].create(outputBits);
         } else {
-          return new Keccak(bits2, padding, outputBits).bytepad([n, s], w);
+          return new Keccak2(bits2, padding, outputBits).bytepad([n, s], w);
         }
       };
       method.update = function(message, outputBits, n, s) {
@@ -4813,7 +5331,7 @@ var require_sha3 = __commonJS((exports2, module2) => {
         }
       }
     }
-    function Keccak(bits2, padding, outputBits) {
+    function Keccak2(bits2, padding, outputBits) {
       this.blocks = [];
       this.s = [];
       this.padding = padding;
@@ -4830,7 +5348,7 @@ var require_sha3 = __commonJS((exports2, module2) => {
         this.s[i3] = 0;
       }
     }
-    Keccak.prototype.update = function(message) {
+    Keccak2.prototype.update = function(message) {
       if (this.finalized) {
         throw new Error(FINALIZE_ERROR);
       }
@@ -4900,7 +5418,7 @@ var require_sha3 = __commonJS((exports2, module2) => {
       }
       return this;
     };
-    Keccak.prototype.encode = function(x, right) {
+    Keccak2.prototype.encode = function(x, right) {
       var o = x & 255, n = 1;
       var bytes = [o];
       x = x >> 8;
@@ -4919,7 +5437,7 @@ var require_sha3 = __commonJS((exports2, module2) => {
       this.update(bytes);
       return bytes.length;
     };
-    Keccak.prototype.encodeString = function(str) {
+    Keccak2.prototype.encodeString = function(str) {
       var notString, type = typeof str;
       if (type !== "string") {
         if (type === "object") {
@@ -4959,7 +5477,7 @@ var require_sha3 = __commonJS((exports2, module2) => {
       this.update(str);
       return bytes;
     };
-    Keccak.prototype.bytepad = function(strs, w) {
+    Keccak2.prototype.bytepad = function(strs, w) {
       var bytes = this.encode(w);
       for (var i3 = 0;i3 < strs.length; ++i3) {
         bytes += this.encodeString(strs[i3]);
@@ -4970,7 +5488,7 @@ var require_sha3 = __commonJS((exports2, module2) => {
       this.update(zeros2);
       return this;
     };
-    Keccak.prototype.finalize = function() {
+    Keccak2.prototype.finalize = function() {
       if (this.finalized) {
         return;
       }
@@ -4989,7 +5507,7 @@ var require_sha3 = __commonJS((exports2, module2) => {
       }
       f(s);
     };
-    Keccak.prototype.toString = Keccak.prototype.hex = function() {
+    Keccak2.prototype.toString = Keccak2.prototype.hex = function() {
       this.finalize();
       var blockCount = this.blockCount, s = this.s, outputBlocks = this.outputBlocks, extraBytes = this.extraBytes, i3 = 0, j2 = 0;
       var hex = "", block;
@@ -5015,7 +5533,7 @@ var require_sha3 = __commonJS((exports2, module2) => {
       }
       return hex;
     };
-    Keccak.prototype.arrayBuffer = function() {
+    Keccak2.prototype.arrayBuffer = function() {
       this.finalize();
       var blockCount = this.blockCount, s = this.s, outputBlocks = this.outputBlocks, extraBytes = this.extraBytes, i3 = 0, j2 = 0;
       var bytes = this.outputBits >> 3;
@@ -5040,8 +5558,8 @@ var require_sha3 = __commonJS((exports2, module2) => {
       }
       return buffer;
     };
-    Keccak.prototype.buffer = Keccak.prototype.arrayBuffer;
-    Keccak.prototype.digest = Keccak.prototype.array = function() {
+    Keccak2.prototype.buffer = Keccak2.prototype.arrayBuffer;
+    Keccak2.prototype.digest = Keccak2.prototype.array = function() {
       this.finalize();
       var blockCount = this.blockCount, s = this.s, outputBlocks = this.outputBlocks, extraBytes = this.extraBytes, i3 = 0, j2 = 0;
       var array = [], offset, block;
@@ -5072,12 +5590,12 @@ var require_sha3 = __commonJS((exports2, module2) => {
       return array;
     };
     function Kmac(bits2, padding, outputBits) {
-      Keccak.call(this, bits2, padding, outputBits);
+      Keccak2.call(this, bits2, padding, outputBits);
     }
-    Kmac.prototype = new Keccak;
+    Kmac.prototype = new Keccak2;
     Kmac.prototype.finalize = function() {
       this.encode(this.outputBits, true);
-      return Keccak.prototype.finalize.call(this);
+      return Keccak2.prototype.finalize.call(this);
     };
     var f = function(s) {
       var h, l, n, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47, b48, b49;
@@ -7192,13 +7710,13 @@ var require_lib2 = __commonJS((exports2) => {
     return array;
   }
   function isBytesLike2(value) {
-    return isHexString2(value) && !(value.length % 2) || isBytes2(value);
+    return isHexString2(value) && !(value.length % 2) || isBytes3(value);
   }
   exports2.isBytesLike = isBytesLike2;
   function isInteger2(value) {
     return typeof value === "number" && value == value && value % 1 === 0;
   }
-  function isBytes2(value) {
+  function isBytes3(value) {
     if (value == null) {
       return false;
     }
@@ -7219,7 +7737,7 @@ var require_lib2 = __commonJS((exports2) => {
     }
     return true;
   }
-  exports2.isBytes = isBytes2;
+  exports2.isBytes = isBytes3;
   function arrayify2(value, options) {
     if (!options) {
       options = {};
@@ -7259,7 +7777,7 @@ var require_lib2 = __commonJS((exports2) => {
       }
       return addSlice2(new Uint8Array(result));
     }
-    if (isBytes2(value)) {
+    if (isBytes3(value)) {
       return addSlice2(new Uint8Array(value));
     }
     return logger20.throwArgumentError("invalid arrayify value", "value", value);
@@ -7360,7 +7878,7 @@ var require_lib2 = __commonJS((exports2) => {
       }
       return value.toLowerCase();
     }
-    if (isBytes2(value)) {
+    if (isBytes3(value)) {
       var result = "0x";
       for (var i2 = 0;i2 < value.length; i2++) {
         var v = value[i2];
@@ -7693,7 +8211,7 @@ var require_lib4 = __commonJS((exports2) => {
   } });
 });
 
-// node_modules/aes-js/index.js
+// node_modules/@ethersproject/json-wallets/node_modules/aes-js/index.js
 var require_aes_js = __commonJS((exports2, module2) => {
   (function(root) {
     function checkInt2(value) {
@@ -7746,7 +8264,7 @@ var require_aes_js = __commonJS((exports2, module2) => {
       targetArray.set(sourceArray, targetStart);
     }
     var convertUtf8 = function() {
-      function toBytes(text) {
+      function toBytes3(text) {
         var result = [], i2 = 0;
         text = encodeURI(text);
         while (i2 < text.length) {
@@ -7778,12 +8296,12 @@ var require_aes_js = __commonJS((exports2, module2) => {
         return result.join("");
       }
       return {
-        toBytes,
+        toBytes: toBytes3,
         fromBytes
       };
     }();
     var convertHex = function() {
-      function toBytes(text) {
+      function toBytes3(text) {
         var result = [];
         for (var i2 = 0;i2 < text.length; i2 += 2) {
           result.push(parseInt(text.substr(i2, 2), 16));
@@ -7800,7 +8318,7 @@ var require_aes_js = __commonJS((exports2, module2) => {
         return result.join("");
       }
       return {
-        toBytes,
+        toBytes: toBytes3,
         fromBytes
       };
     }();
@@ -8776,13 +9294,13 @@ var require_bech32 = __commonJS((exports2, module2) => {
     if (str !== lowered && str !== uppered)
       return "Mixed-case string " + str;
     str = lowered;
-    var split = str.lastIndexOf("1");
-    if (split === -1)
+    var split2 = str.lastIndexOf("1");
+    if (split2 === -1)
       return "No separator character for " + str;
-    if (split === 0)
+    if (split2 === 0)
       return "Missing prefix for " + str;
-    var prefix = str.slice(0, split);
-    var wordChars = str.slice(split + 1);
+    var prefix = str.slice(0, split2);
+    var wordChars = str.slice(split2 + 1);
     if (wordChars.length < 6)
       return "Data too short";
     var chk = prefixChk(prefix);
@@ -13727,10 +14245,10 @@ var require_lib7 = __commonJS((exports2) => {
   exports2.keccak256 = undefined;
   var js_sha3_1 = __importDefault(require_sha3());
   var bytes_1 = require_lib2();
-  function keccak2563(data) {
+  function keccak2564(data) {
     return "0x" + js_sha3_1.default.keccak_256((0, bytes_1.arrayify)(data));
   }
-  exports2.keccak256 = keccak2563;
+  exports2.keccak256 = keccak2564;
 });
 
 // node_modules/@ethersproject/rlp/lib/_version.js
@@ -13931,7 +14449,7 @@ var require_lib9 = __commonJS((exports2) => {
     }
     return checksum;
   }
-  function getAddress2(address) {
+  function getAddress3(address) {
     var result = null;
     if (typeof address !== "string") {
       logger47.throwArgumentError("invalid address", "address", address);
@@ -13958,17 +14476,17 @@ var require_lib9 = __commonJS((exports2) => {
     }
     return result;
   }
-  exports2.getAddress = getAddress2;
-  function isAddress2(address) {
+  exports2.getAddress = getAddress3;
+  function isAddress3(address) {
     try {
-      getAddress2(address);
+      getAddress3(address);
       return true;
     } catch (error) {}
     return false;
   }
-  exports2.isAddress = isAddress2;
+  exports2.isAddress = isAddress3;
   function getIcapAddress2(address) {
-    var base36 = (0, bignumber_1._base16To36)(getAddress2(address).substring(2)).toUpperCase();
+    var base36 = (0, bignumber_1._base16To36)(getAddress3(address).substring(2)).toUpperCase();
     while (base36.length < 30) {
       base36 = "0" + base36;
     }
@@ -13978,12 +14496,12 @@ var require_lib9 = __commonJS((exports2) => {
   function getContractAddress2(transaction) {
     var from2 = null;
     try {
-      from2 = getAddress2(transaction.from);
+      from2 = getAddress3(transaction.from);
     } catch (error) {
       logger47.throwArgumentError("missing from address", "transaction", transaction);
     }
     var nonce = (0, bytes_1.stripZeros)((0, bytes_1.arrayify)(bignumber_1.BigNumber.from(transaction.nonce).toHexString()));
-    return getAddress2((0, bytes_1.hexDataSlice)((0, keccak256_1.keccak256)((0, rlp_1.encode)([from2, nonce])), 12));
+    return getAddress3((0, bytes_1.hexDataSlice)((0, keccak256_1.keccak256)((0, rlp_1.encode)([from2, nonce])), 12));
   }
   exports2.getContractAddress = getContractAddress2;
   function getCreate2Address2(from2, salt, initCodeHash) {
@@ -13993,7 +14511,7 @@ var require_lib9 = __commonJS((exports2) => {
     if ((0, bytes_1.hexDataLength)(initCodeHash) !== 32) {
       logger47.throwArgumentError("initCodeHash must be 32 bytes", "initCodeHash", initCodeHash);
     }
-    return getAddress2((0, bytes_1.hexDataSlice)((0, keccak256_1.keccak256)((0, bytes_1.concat)(["0xff", getAddress2(from2), salt, initCodeHash])), 12));
+    return getAddress3((0, bytes_1.hexDataSlice)((0, keccak256_1.keccak256)((0, bytes_1.concat)(["0xff", getAddress3(from2), salt, initCodeHash])), 12));
   }
   exports2.getCreate2Address = getCreate2Address2;
 });
@@ -16215,8 +16733,8 @@ var require_typed_data = __commonJS((exports2) => {
           if (baseType === name_12) {
             logger47.throwArgumentError("circular type reference to " + JSON.stringify(baseType), "types", types2);
           }
-          var encoder = getBaseEncoder2(baseType);
-          if (encoder) {
+          var encoder3 = getBaseEncoder2(baseType);
+          if (encoder3) {
             return;
           }
           if (!parents[baseType]) {
@@ -16266,18 +16784,18 @@ var require_typed_data = __commonJS((exports2) => {
       }
     }
     TypedDataEncoder3.prototype.getEncoder = function(type) {
-      var encoder = this._encoderCache[type];
-      if (!encoder) {
-        encoder = this._encoderCache[type] = this._getEncoder(type);
+      var encoder3 = this._encoderCache[type];
+      if (!encoder3) {
+        encoder3 = this._encoderCache[type] = this._getEncoder(type);
       }
-      return encoder;
+      return encoder3;
     };
     TypedDataEncoder3.prototype._getEncoder = function(type) {
       var _this = this;
       {
-        var encoder = getBaseEncoder2(type);
-        if (encoder) {
-          return encoder;
+        var encoder3 = getBaseEncoder2(type);
+        if (encoder3) {
+          return encoder3;
         }
       }
       var match = type.match(/^(.*)(\x5b(\d*)\x5d)$/);
@@ -16336,8 +16854,8 @@ var require_typed_data = __commonJS((exports2) => {
     TypedDataEncoder3.prototype._visit = function(type, value, callback) {
       var _this = this;
       {
-        var encoder = getBaseEncoder2(type);
-        if (encoder) {
+        var encoder3 = getBaseEncoder2(type);
+        if (encoder3) {
           return callback(type, value);
         }
       }
@@ -16400,7 +16918,7 @@ var require_typed_data = __commonJS((exports2) => {
     };
     TypedDataEncoder3.resolveNames = function(domain, types2, value, resolveName2) {
       return __awaiter17(this, undefined, undefined, function() {
-        var ensCache, encoder, _a, _b, _i, name_4, _c, _d;
+        var ensCache, encoder3, _a, _b, _i, name_4, _c, _d;
         return __generator(this, function(_e) {
           switch (_e.label) {
             case 0:
@@ -16409,8 +16927,8 @@ var require_typed_data = __commonJS((exports2) => {
               if (domain.verifyingContract && !(0, bytes_1.isHexString)(domain.verifyingContract, 20)) {
                 ensCache[domain.verifyingContract] = "0x";
               }
-              encoder = TypedDataEncoder3.from(types2);
-              encoder.visit(value, function(type, value2) {
+              encoder3 = TypedDataEncoder3.from(types2);
+              encoder3.visit(value, function(type, value2) {
                 if (type === "address" && !(0, bytes_1.isHexString)(value2, 20)) {
                   ensCache[value2] = "0x";
                 }
@@ -16438,7 +16956,7 @@ var require_typed_data = __commonJS((exports2) => {
               if (domain.verifyingContract && ensCache[domain.verifyingContract]) {
                 domain.verifyingContract = ensCache[domain.verifyingContract];
               }
-              value = encoder.visit(value, function(type, value2) {
+              value = encoder3.visit(value, function(type, value2) {
                 if (type === "address" && ensCache[value2]) {
                   return ensCache[value2];
                 }
@@ -16461,19 +16979,19 @@ var require_typed_data = __commonJS((exports2) => {
         domainValues[name] = domainChecks2[name](value2);
         domainTypes.push({ name, type: domainFieldTypes2[name] });
       });
-      var encoder = TypedDataEncoder3.from(types2);
+      var encoder3 = TypedDataEncoder3.from(types2);
       var typesWithDomain = (0, properties_1.shallowCopy)(types2);
       if (typesWithDomain.EIP712Domain) {
         logger47.throwArgumentError("types must not contain EIP712Domain type", "types.EIP712Domain", types2);
       } else {
         typesWithDomain.EIP712Domain = domainTypes;
       }
-      encoder.encode(value);
+      encoder3.encode(value);
       return {
         types: typesWithDomain,
         domain: domainValues,
-        primaryType: encoder.primaryType,
-        message: encoder.visit(value, function(type, value2) {
+        primaryType: encoder3.primaryType,
+        message: encoder3.visit(value, function(type, value2) {
           if (type.match(/^bytes(\d*)/)) {
             return (0, bytes_1.hexlify)((0, bytes_1.arrayify)(value2));
           }
@@ -27308,12 +27826,12 @@ var init_crypto = __esm(() => {
     ShortCurve2.prototype._endoWnafMulAdd = function _endoWnafMulAdd(points, coeffs, jacobianResult) {
       var npoints = this._endoWnafT1, ncoeffs = this._endoWnafT2;
       for (var i2 = 0;i2 < points.length; i2++) {
-        var split = this._endoSplit(coeffs[i2]), p = points[i2], beta = p._getBeta();
-        if (split.k1.negative)
-          split.k1.ineg(), p = p.neg(true);
-        if (split.k2.negative)
-          split.k2.ineg(), beta = beta.neg(true);
-        npoints[i2 * 2] = p, npoints[i2 * 2 + 1] = beta, ncoeffs[i2 * 2] = split.k1, ncoeffs[i2 * 2 + 1] = split.k2;
+        var split2 = this._endoSplit(coeffs[i2]), p = points[i2], beta = p._getBeta();
+        if (split2.k1.negative)
+          split2.k1.ineg(), p = p.neg(true);
+        if (split2.k2.negative)
+          split2.k2.ineg(), beta = beta.neg(true);
+        npoints[i2 * 2] = p, npoints[i2 * 2 + 1] = beta, ncoeffs[i2 * 2] = split2.k1, ncoeffs[i2 * 2 + 1] = split2.k2;
       }
       var res = this._wnafMulAdd(1, npoints, ncoeffs, i2 * 2, jacobianResult);
       for (var j = 0;j < i2 * 2; j++)
@@ -37002,21 +37520,21 @@ var require_short2 = __commonJS((exports2, module2) => {
     var npoints = this._endoWnafT1;
     var ncoeffs = this._endoWnafT2;
     for (var i2 = 0;i2 < points.length; i2++) {
-      var split = this._endoSplit(coeffs[i2]);
+      var split2 = this._endoSplit(coeffs[i2]);
       var p = points[i2];
       var beta = p._getBeta();
-      if (split.k1.negative) {
-        split.k1.ineg();
+      if (split2.k1.negative) {
+        split2.k1.ineg();
         p = p.neg(true);
       }
-      if (split.k2.negative) {
-        split.k2.ineg();
+      if (split2.k2.negative) {
+        split2.k2.ineg();
         beta = beta.neg(true);
       }
       npoints[i2 * 2] = p;
       npoints[i2 * 2 + 1] = beta;
-      ncoeffs[i2 * 2] = split.k1;
-      ncoeffs[i2 * 2 + 1] = split.k2;
+      ncoeffs[i2 * 2] = split2.k1;
+      ncoeffs[i2 * 2 + 1] = split2.k2;
     }
     var res = this._wnafMulAdd(1, npoints, ncoeffs, i2 * 2, jacobianResult);
     for (var j = 0;j < i2 * 2; j++) {
@@ -42045,10 +42563,10 @@ var require_lib23 = __commonJS((exports2) => {
     return (0, bytes_1.hexlify)((0, bytes_1.concat)(tight));
   }
   exports2.pack = pack4;
-  function keccak2563(types3, values) {
+  function keccak2564(types3, values) {
     return (0, keccak256_1.keccak256)(pack4(types3, values));
   }
-  exports2.keccak256 = keccak2563;
+  exports2.keccak256 = keccak2564;
   function sha2563(types3, values) {
     return (0, sha2_1.sha256)(pack4(types3, values));
   }
@@ -44952,6 +45470,7 @@ var zeroAddress = "0x0000000000000000000000000000000000000000";
 init_number();
 init_toHex();
 init_fromHex();
+init_getAddress();
 init_pad();
 
 // src/types/primitives.ts
@@ -45302,12 +45821,12 @@ function addSlice(array) {
   return array;
 }
 function isBytesLike(value) {
-  return isHexString(value) && !(value.length % 2) || isBytes(value);
+  return isHexString(value) && !(value.length % 2) || isBytes2(value);
 }
 function isInteger(value) {
   return typeof value === "number" && value == value && value % 1 === 0;
 }
-function isBytes(value) {
+function isBytes2(value) {
   if (value == null) {
     return false;
   }
@@ -45367,7 +45886,7 @@ function arrayify(value, options) {
     }
     return addSlice(new Uint8Array(result));
   }
-  if (isBytes(value)) {
+  if (isBytes2(value)) {
     return addSlice(new Uint8Array(value));
   }
   return logger.throwArgumentError("invalid arrayify value", "value", value);
@@ -45459,7 +45978,7 @@ function hexlify(value, options) {
     }
     return value.toLowerCase();
   }
-  if (isBytes(value)) {
+  if (isBytes2(value)) {
     let result = "0x";
     for (let i2 = 0;i2 < value.length; i2++) {
       let v = value[i2];
@@ -45660,7 +46179,7 @@ var logger2 = new Logger(version4);
 var _constructorGuard = {};
 var MAX_SAFE = 9007199254740991;
 function isBigNumberish(value) {
-  return value != null && (BigNumber.isBigNumber(value) || typeof value === "number" && value % 1 === 0 || typeof value === "string" && !!value.match(/^-?[0-9]+$/) || isHexString(value) || typeof value === "bigint" || isBytes(value));
+  return value != null && (BigNumber.isBigNumber(value) || typeof value === "number" && value % 1 === 0 || typeof value === "string" && !!value.match(/^-?[0-9]+$/) || isHexString(value) || typeof value === "bigint" || isBytes2(value));
 }
 var _warnedToStringRadix = false;
 
@@ -45840,7 +46359,7 @@ class BigNumber {
     if (typeof anyValue === "bigint") {
       return BigNumber.from(anyValue.toString());
     }
-    if (isBytes(anyValue)) {
+    if (isBytes2(anyValue)) {
       return BigNumber.from(hexlify(anyValue));
     }
     if (anyValue) {
@@ -46240,7 +46759,7 @@ class FixedNumber {
     if (typeof value === "string") {
       return FixedNumber.fromString(value, format);
     }
-    if (isBytes(value)) {
+    if (isBytes2(value)) {
       return FixedNumber.fromBytes(value, format);
     }
     try {
@@ -47350,7 +47869,7 @@ class Reader {
 
 // node_modules/@ethersproject/keccak256/lib.esm/index.js
 var import_js_sha3 = __toESM(require_sha3());
-function keccak256(data) {
+function keccak2562(data) {
   return "0x" + import_js_sha3.default.keccak_256(arrayify(data));
 }
 
@@ -47489,7 +48008,7 @@ function getChecksumAddress(address) {
   for (let i2 = 0;i2 < 40; i2++) {
     expanded[i2] = chars[i2].charCodeAt(0);
   }
-  const hashed = arrayify(keccak256(expanded));
+  const hashed = arrayify(keccak2562(expanded));
   for (let i2 = 0;i2 < 40; i2 += 2) {
     if (hashed[i2 >> 1] >> 4 >= 8) {
       chars[i2] = chars[i2].toUpperCase();
@@ -47531,7 +48050,7 @@ function ibanChecksum(address) {
   }
   return checksum;
 }
-function getAddress(address) {
+function getAddress2(address) {
   let result = null;
   if (typeof address !== "string") {
     logger8.throwArgumentError("invalid address", "address", address);
@@ -47558,15 +48077,15 @@ function getAddress(address) {
   }
   return result;
 }
-function isAddress(address) {
+function isAddress2(address) {
   try {
-    getAddress(address);
+    getAddress2(address);
     return true;
   } catch (error) {}
   return false;
 }
 function getIcapAddress(address) {
-  let base36 = _base16To36(getAddress(address).substring(2)).toUpperCase();
+  let base36 = _base16To36(getAddress2(address).substring(2)).toUpperCase();
   while (base36.length < 30) {
     base36 = "0" + base36;
   }
@@ -47575,12 +48094,12 @@ function getIcapAddress(address) {
 function getContractAddress(transaction) {
   let from2 = null;
   try {
-    from2 = getAddress(transaction.from);
+    from2 = getAddress2(transaction.from);
   } catch (error) {
     logger8.throwArgumentError("missing from address", "transaction", transaction);
   }
   const nonce = stripZeros(arrayify(BigNumber.from(transaction.nonce).toHexString()));
-  return getAddress(hexDataSlice(keccak256(encode([from2, nonce])), 12));
+  return getAddress2(hexDataSlice(keccak2562(encode([from2, nonce])), 12));
 }
 function getCreate2Address(from2, salt, initCodeHash) {
   if (hexDataLength(salt) !== 32) {
@@ -47589,7 +48108,7 @@ function getCreate2Address(from2, salt, initCodeHash) {
   if (hexDataLength(initCodeHash) !== 32) {
     logger8.throwArgumentError("initCodeHash must be 32 bytes", "initCodeHash", initCodeHash);
   }
-  return getAddress(hexDataSlice(keccak256(concat2(["0xff", getAddress(from2), salt, initCodeHash])), 12));
+  return getAddress2(hexDataSlice(keccak2562(concat2(["0xff", getAddress2(from2), salt, initCodeHash])), 12));
 }
 
 // node_modules/@ethersproject/abi/lib.esm/coders/address.js
@@ -47602,14 +48121,14 @@ class AddressCoder extends Coder {
   }
   encode(writer, value) {
     try {
-      value = getAddress(value);
+      value = getAddress2(value);
     } catch (error) {
       this._throwError(error.message, value);
     }
     return writer.writeValue(value);
   }
   decode(reader) {
-    return getAddress(hexZeroPad(reader.readValue().toHexString(), 20));
+    return getAddress2(hexZeroPad(reader.readValue().toHexString(), 20));
   }
 }
 
@@ -48523,7 +49042,7 @@ var defaultAbiCoder = new AbiCoder;
 
 // node_modules/@ethersproject/hash/lib.esm/id.js
 function id(text) {
-  return keccak256(toUtf8Bytes(text));
+  return keccak2562(toUtf8Bytes(text));
 }
 
 // node_modules/@ethersproject/hash/lib.esm/_version.js
@@ -48922,7 +49441,7 @@ function namehash(name) {
   let result = Zeros;
   const comps = ensNameSplit(name);
   while (comps.length) {
-    result = keccak256(concat2([result, keccak256(comps.pop())]));
+    result = keccak2562(concat2([result, keccak2562(comps.pop())]));
   }
   return hexlify(result);
 }
@@ -48945,7 +49464,7 @@ function hashMessage(message) {
   if (typeof message === "string") {
     message = toUtf8Bytes(message);
   }
-  return keccak256(concat2([
+  return keccak2562(concat2([
     toUtf8Bytes(messagePrefix),
     toUtf8Bytes(String(message.length)),
     message
@@ -49030,7 +49549,7 @@ var domainChecks = {
   },
   verifyingContract: function(value) {
     try {
-      return getAddress(value).toLowerCase();
+      return getAddress2(value).toLowerCase();
     } catch (error) {}
     return logger13.throwArgumentError(`invalid domain value "verifyingContract"`, "domain.verifyingContract", value);
   },
@@ -49084,7 +49603,7 @@ function getBaseEncoder(type) {
   switch (type) {
     case "address":
       return function(value) {
-        return hexZeroPad(getAddress(value), 32);
+        return hexZeroPad(getAddress2(value), 32);
       };
     case "bool":
       return function(value) {
@@ -49092,7 +49611,7 @@ function getBaseEncoder(type) {
       };
     case "bytes":
       return function(value) {
-        return keccak256(value);
+        return keccak2562(value);
       };
     case "string":
       return function(value) {
@@ -49129,8 +49648,8 @@ class TypedDataEncoder {
         if (baseType === name) {
           logger13.throwArgumentError(`circular type reference to ${JSON.stringify(baseType)}`, "types", types);
         }
-        const encoder = getBaseEncoder(baseType);
-        if (encoder) {
+        const encoder3 = getBaseEncoder(baseType);
+        if (encoder3) {
           return;
         }
         if (!parents[baseType]) {
@@ -49171,17 +49690,17 @@ class TypedDataEncoder {
     }
   }
   getEncoder(type) {
-    let encoder = this._encoderCache[type];
-    if (!encoder) {
-      encoder = this._encoderCache[type] = this._getEncoder(type);
+    let encoder3 = this._encoderCache[type];
+    if (!encoder3) {
+      encoder3 = this._encoderCache[type] = this._getEncoder(type);
     }
-    return encoder;
+    return encoder3;
   }
   _getEncoder(type) {
     {
-      const encoder = getBaseEncoder(type);
-      if (encoder) {
-        return encoder;
+      const encoder3 = getBaseEncoder(type);
+      if (encoder3) {
+        return encoder3;
       }
     }
     const match = type.match(/^(.*)(\x5b(\d*)\x5d)$/);
@@ -49195,9 +49714,9 @@ class TypedDataEncoder {
         }
         let result = value.map(subEncoder);
         if (this._types[subtype]) {
-          result = result.map(keccak256);
+          result = result.map(keccak2562);
         }
-        return keccak256(hexConcat(result));
+        return keccak2562(hexConcat(result));
       };
     }
     const fields = this.types[type];
@@ -49207,7 +49726,7 @@ class TypedDataEncoder {
         const values = fields.map(({ name, type: type2 }) => {
           const result = this.getEncoder(type2)(value[name]);
           if (this._types[type2]) {
-            return keccak256(result);
+            return keccak2562(result);
           }
           return result;
         });
@@ -49228,7 +49747,7 @@ class TypedDataEncoder {
     return this.getEncoder(type)(value);
   }
   hashStruct(name, value) {
-    return keccak256(this.encodeData(name, value));
+    return keccak2562(this.encodeData(name, value));
   }
   encode(value) {
     return this.encodeData(this.primaryType, value);
@@ -49238,8 +49757,8 @@ class TypedDataEncoder {
   }
   _visit(type, value, callback) {
     {
-      const encoder = getBaseEncoder(type);
-      if (encoder) {
+      const encoder3 = getBaseEncoder(type);
+      if (encoder3) {
         return callback(type, value);
       }
     }
@@ -49295,7 +49814,7 @@ class TypedDataEncoder {
     ]);
   }
   static hash(domain, types, value) {
-    return keccak256(TypedDataEncoder.encode(domain, types, value));
+    return keccak2562(TypedDataEncoder.encode(domain, types, value));
   }
   static resolveNames(domain, types, value, resolveName) {
     return __awaiter2(this, undefined, undefined, function* () {
@@ -49304,8 +49823,8 @@ class TypedDataEncoder {
       if (domain.verifyingContract && !isHexString(domain.verifyingContract, 20)) {
         ensCache[domain.verifyingContract] = "0x";
       }
-      const encoder = TypedDataEncoder.from(types);
-      encoder.visit(value, (type, value2) => {
+      const encoder3 = TypedDataEncoder.from(types);
+      encoder3.visit(value, (type, value2) => {
         if (type === "address" && !isHexString(value2, 20)) {
           ensCache[value2] = "0x";
         }
@@ -49317,7 +49836,7 @@ class TypedDataEncoder {
       if (domain.verifyingContract && ensCache[domain.verifyingContract]) {
         domain.verifyingContract = ensCache[domain.verifyingContract];
       }
-      value = encoder.visit(value, (type, value2) => {
+      value = encoder3.visit(value, (type, value2) => {
         if (type === "address" && ensCache[value2]) {
           return ensCache[value2];
         }
@@ -49338,19 +49857,19 @@ class TypedDataEncoder {
       domainValues[name] = domainChecks[name](value2);
       domainTypes.push({ name, type: domainFieldTypes[name] });
     });
-    const encoder = TypedDataEncoder.from(types);
+    const encoder3 = TypedDataEncoder.from(types);
     const typesWithDomain = shallowCopy(types);
     if (typesWithDomain.EIP712Domain) {
       logger13.throwArgumentError("types must not contain EIP712Domain type", "types.EIP712Domain", types);
     } else {
       typesWithDomain.EIP712Domain = domainTypes;
     }
-    encoder.encode(value);
+    encoder3.encode(value);
     return {
       types: typesWithDomain,
       domain: domainValues,
-      primaryType: encoder.primaryType,
-      message: encoder.visit(value, (type, value2) => {
+      primaryType: encoder3.primaryType,
+      message: encoder3.visit(value, (type, value2) => {
         if (type.match(/^bytes(\d*)/)) {
           return hexlify(arrayify(value2));
         }
@@ -49470,7 +49989,7 @@ class Interface {
     return defaultAbiCoder;
   }
   static getAddress(address) {
-    return getAddress(address);
+    return getAddress2(address);
   }
   static getSighash(fragment) {
     return hexDataSlice(id(fragment.format()), 0, 4);
@@ -49698,7 +50217,7 @@ class Interface {
       if (param.type === "string") {
         return id(value);
       } else if (param.type === "bytes") {
-        return keccak256(hexlify(value));
+        return keccak2562(hexlify(value));
       }
       if (param.type === "bool" && typeof value === "boolean") {
         value = value ? "0x01" : "0x00";
@@ -49753,7 +50272,7 @@ class Interface {
         if (param.type === "string") {
           topics.push(id(value));
         } else if (param.type === "bytes") {
-          topics.push(keccak256(value));
+          topics.push(keccak2562(value));
         } else if (param.baseType === "tuple" || param.baseType === "array") {
           throw new Error("not implemented");
         } else {
@@ -50904,21 +51423,21 @@ ShortCurve.prototype._endoWnafMulAdd = function _endoWnafMulAdd(points, coeffs,
   var npoints = this._endoWnafT1;
   var ncoeffs = this._endoWnafT2;
   for (var i2 = 0;i2 < points.length; i2++) {
-    var split = this._endoSplit(coeffs[i2]);
+    var split2 = this._endoSplit(coeffs[i2]);
     var p = points[i2];
     var beta = p._getBeta();
-    if (split.k1.negative) {
-      split.k1.ineg();
+    if (split2.k1.negative) {
+      split2.k1.ineg();
       p = p.neg(true);
     }
-    if (split.k2.negative) {
-      split.k2.ineg();
+    if (split2.k2.negative) {
+      split2.k2.ineg();
       beta = beta.neg(true);
     }
     npoints[i2 * 2] = p;
     npoints[i2 * 2 + 1] = beta;
-    ncoeffs[i2 * 2] = split.k1;
-    ncoeffs[i2 * 2 + 1] = split.k2;
+    ncoeffs[i2 * 2] = split2.k1;
+    ncoeffs[i2 * 2 + 1] = split2.k2;
   }
   var res = this._wnafMulAdd(1, npoints, ncoeffs, i2 * 2, jacobianResult);
   for (var j = 0;j < i2 * 2; j++) {
@@ -52174,7 +52693,7 @@ function handleAddress(value) {
   if (value === "0x") {
     return null;
   }
-  return getAddress(value);
+  return getAddress2(value);
 }
 function handleNumber(value) {
   if (value === "0x") {
@@ -52202,7 +52721,7 @@ var allowedTransactionKeys2 = {
 };
 function computeAddress(key2) {
   const publicKey = computePublicKey(key2);
-  return getAddress(hexDataSlice(keccak256(hexDataSlice(publicKey, 1)), 12));
+  return getAddress2(hexDataSlice(keccak2562(hexDataSlice(publicKey, 1)), 12));
 }
 function recoverAddress(digest, signature2) {
   return computeAddress(recoverPublicKey(arrayify(digest), signature2));
@@ -52216,7 +52735,7 @@ function formatNumber(value, name) {
 }
 function accessSetify(addr, storageKeys) {
   return {
-    address: getAddress(addr),
+    address: getAddress2(addr),
     storageKeys: (storageKeys || []).map((storageKey, index) => {
       if (hexDataLength(storageKey) !== 32) {
         logger18.throwArgumentError("invalid access list storageKey", `accessList[${addr}:${index}]`, storageKey);
@@ -52267,7 +52786,7 @@ function _serializeEip1559(transaction, signature2) {
     formatNumber(transaction.maxPriorityFeePerGas || 0, "maxPriorityFeePerGas"),
     formatNumber(transaction.maxFeePerGas || 0, "maxFeePerGas"),
     formatNumber(transaction.gasLimit || 0, "gasLimit"),
-    transaction.to != null ? getAddress(transaction.to) : "0x",
+    transaction.to != null ? getAddress2(transaction.to) : "0x",
     formatNumber(transaction.value || 0, "value"),
     transaction.data || "0x",
     formatAccessList(transaction.accessList || [])
@@ -52286,7 +52805,7 @@ function _serializeEip2930(transaction, signature2) {
     formatNumber(transaction.nonce || 0, "nonce"),
     formatNumber(transaction.gasPrice || 0, "gasPrice"),
     formatNumber(transaction.gasLimit || 0, "gasLimit"),
-    transaction.to != null ? getAddress(transaction.to) : "0x",
+    transaction.to != null ? getAddress2(transaction.to) : "0x",
     formatNumber(transaction.value || 0, "value"),
     transaction.data || "0x",
     formatAccessList(transaction.accessList || [])
@@ -52388,7 +52907,7 @@ function _parseEipSignature(tx, fields, serialize2) {
   tx.r = hexZeroPad(fields[1], 32);
   tx.s = hexZeroPad(fields[2], 32);
   try {
-    const digest = keccak256(serialize2(tx));
+    const digest = keccak2562(serialize2(tx));
     tx.from = recoverAddress(digest, { r: tx.r, s: tx.s, recoveryParam: tx.v });
   } catch (error) {}
 }
@@ -52415,7 +52934,7 @@ function _parseEip1559(payload) {
   if (transaction.length === 9) {
     return tx;
   }
-  tx.hash = keccak256(payload);
+  tx.hash = keccak2562(payload);
   _parseEipSignature(tx, transaction.slice(9), _serializeEip1559);
   return tx;
 }
@@ -52438,7 +52957,7 @@ function _parseEip2930(payload) {
   if (transaction.length === 8) {
     return tx;
   }
-  tx.hash = keccak256(payload);
+  tx.hash = keccak2562(payload);
   _parseEipSignature(tx, transaction.slice(8), _serializeEip2930);
   return tx;
 }
@@ -52482,11 +53001,11 @@ function _parse(rawTransaction) {
       raw.push("0x");
       recoveryParam -= tx.chainId * 2 + 8;
     }
-    const digest = keccak256(encode(raw));
+    const digest = keccak2562(encode(raw));
     try {
       tx.from = recoverAddress(digest, { r: hexlify(tx.r), s: hexlify(tx.s), recoveryParam });
     } catch (error) {}
-    tx.hash = keccak256(rawTransaction);
+    tx.hash = keccak2562(rawTransaction);
   }
   tx.type = null;
   return tx;
@@ -52565,7 +53084,7 @@ function resolveName(resolver, nameOrPromise) {
       logger19.throwArgumentError("invalid address or ENS name", "name", name);
     }
     try {
-      return getAddress(name);
+      return getAddress2(name);
     } catch (error) {}
     if (!resolver) {
       logger19.throwError("a provider or signer is needed to resolve ENS names", Logger.errors.UNSUPPORTED_OPERATION, {
@@ -52617,7 +53136,7 @@ function populateTransaction(contract, fragment, args) {
           override: resolveName(contract.signer, overrides.from),
           signer: contract.signer.getAddress()
         }).then((check) => __awaiter5(this, undefined, undefined, function* () {
-          if (getAddress(check.signer) !== check.override) {
+          if (getAddress2(check.signer) !== check.override) {
             logger19.throwError("Contract with a Signer cannot override from", Logger.errors.UNSUPPORTED_OPERATION, {
               operation: "overrides.from"
             });
@@ -53008,7 +53527,7 @@ class BaseContract {
       defineReadOnly(this, "resolvedAddress", resolveName(this.provider, addressOrName));
     } else {
       try {
-        defineReadOnly(this, "resolvedAddress", Promise.resolve(getAddress(addressOrName)));
+        defineReadOnly(this, "resolvedAddress", Promise.resolve(getAddress2(addressOrName)));
       } catch (error) {
         logger19.throwError("provider is required to use ENS name as contract address", Logger.errors.UNSUPPORTED_OPERATION, {
           operation: "new Contract"
@@ -53334,7 +53853,7 @@ class ContractFactory {
     let bytecodeHex = null;
     if (typeof bytecode === "string") {
       bytecodeHex = bytecode;
-    } else if (isBytes(bytecode)) {
+    } else if (isBytes2(bytecode)) {
       bytecodeHex = hexlify(bytecode);
     } else if (bytecode && typeof bytecode.object === "string") {
       bytecodeHex = bytecode.object;
@@ -54024,7 +54543,7 @@ class CrowdsaleAccount extends Description {
 function decrypt(json, password) {
   const data = JSON.parse(json);
   password = getPassword(password);
-  const ethaddr = getAddress(searchPath(data, "ethaddr"));
+  const ethaddr = getAddress2(searchPath(data, "ethaddr"));
   const encseed = looseArrayify(searchPath(data, "encseed"));
   if (!encseed || encseed.length % 16 !== 0) {
     logger24.throwArgumentError("invalid encseed", "json", json);
@@ -54039,7 +54558,7 @@ function decrypt(json, password) {
     seedHex += String.fromCharCode(seed[i2]);
   }
   const seedHexBytes = toUtf8Bytes(seedHex);
-  const privateKey = keccak256(seedHexBytes);
+  const privateKey = keccak2562(seedHexBytes);
   return new CrowdsaleAccount({
     _isCrowdsaleAccount: true,
     address: ethaddr,
@@ -54072,14 +54591,14 @@ function isKeystoreWallet(json) {
 function getJsonWalletAddress(json) {
   if (isCrowdsaleWallet(json)) {
     try {
-      return getAddress(JSON.parse(json).ethaddr);
+      return getAddress2(JSON.parse(json).ethaddr);
     } catch (error) {
       return null;
     }
   }
   if (isKeystoreWallet(json)) {
     try {
-      return getAddress(JSON.parse(json).address);
+      return getAddress2(JSON.parse(json).address);
     } catch (error) {
       return null;
     }
@@ -54140,7 +54659,7 @@ function _decrypt(data, key2, ciphertext) {
 }
 function _getAccount(data, key2) {
   const ciphertext = looseArrayify(searchPath(data, "crypto/ciphertext"));
-  const computedMAC = hexlify(keccak256(concat2([key2.slice(16, 32), ciphertext]))).substring(2);
+  const computedMAC = hexlify(keccak2562(concat2([key2.slice(16, 32), ciphertext]))).substring(2);
   if (computedMAC !== searchPath(data, "crypto/mac").toLowerCase()) {
     throw new Error("invalid password");
   }
@@ -54157,7 +54676,7 @@ function _getAccount(data, key2) {
     if (check.substring(0, 2) !== "0x") {
       check = "0x" + check;
     }
-    if (getAddress(check) !== address) {
+    if (getAddress2(check) !== address) {
       throw new Error("address mismatch");
     }
   }
@@ -54253,7 +54772,7 @@ function decrypt2(json, password, progressCallback) {
 }
 function encrypt(account, password, options, progressCallback) {
   try {
-    if (getAddress(account.address) !== computeAddress(account.privateKey)) {
+    if (getAddress2(account.address) !== computeAddress(account.privateKey)) {
       throw new Error("address/privateKey mismatch");
     }
     if (hasMnemonic(account)) {
@@ -54332,7 +54851,7 @@ function encrypt(account, password, options, progressCallback) {
     const counter = new import_aes_js2.default.Counter(iv);
     const aesCtr = new import_aes_js2.default.ModeOfOperation.ctr(derivedKey, counter);
     const ciphertext = arrayify(aesCtr.encrypt(privateKey));
-    const mac = keccak256(concat2([macPrefix, ciphertext]));
+    const mac = keccak2562(concat2([macPrefix, ciphertext]));
     const data = {
       address: account.address.substring(2).toLowerCase(),
       id: uuidV4(uuidRandom),
@@ -54449,7 +54968,7 @@ class Wallet extends Signer {
       const signingKey = new SigningKey(privateKey.privateKey);
       defineReadOnly(this, "_signingKey", () => signingKey);
       defineReadOnly(this, "address", computeAddress(this.publicKey));
-      if (this.address !== getAddress(privateKey.address)) {
+      if (this.address !== getAddress2(privateKey.address)) {
         logger26.throwArgumentError("privateKey/address mismatch", "privateKey", "[REDACTED]");
       }
       if (hasMnemonic2(privateKey)) {
@@ -54508,12 +55027,12 @@ class Wallet extends Signer {
   signTransaction(transaction) {
     return resolveProperties(transaction).then((tx) => {
       if (tx.from != null) {
-        if (getAddress(tx.from) !== this.address) {
+        if (getAddress2(tx.from) !== this.address) {
           logger26.throwArgumentError("transaction from address mismatch", "transaction.from", transaction.from);
         }
         delete tx.from;
       }
-      const signature2 = this._signingKey().signDigest(keccak256(serialize(tx)));
+      const signature2 = this._signingKey().signDigest(keccak2562(serialize(tx)));
       return serialize(tx, signature2);
     });
   }
@@ -54555,7 +55074,7 @@ class Wallet extends Signer {
       options = {};
     }
     if (options.extraEntropy) {
-      entropy = arrayify(hexDataSlice(keccak256(concat2([entropy, options.extraEntropy])), 0, 16));
+      entropy = arrayify(hexDataSlice(keccak2562(concat2([entropy, options.extraEntropy])), 0, 16));
     }
     const mnemonic = entropyToMnemonic(entropy, options.locale);
     return Wallet.fromMnemonic(mnemonic, options.path, options.locale);
@@ -55480,13 +55999,13 @@ class Formatter {
     return result;
   }
   address(value) {
-    return getAddress(value);
+    return getAddress2(value);
   }
   callAddress(value) {
     if (!isHexString(value, 32)) {
       return null;
     }
-    const address = getAddress(hexDataSlice(value, 12));
+    const address = getAddress2(hexDataSlice(value, 12));
     return address === AddressZero ? null : address;
   }
   contractAddress(value) {
@@ -60123,7 +60642,7 @@ __export(exports_utils, {
   splitSignature: () => splitSignature,
   soliditySha256: () => sha2562,
   solidityPack: () => pack2,
-  solidityKeccak256: () => keccak2562,
+  solidityKeccak256: () => keccak2563,
   shuffled: () => shuffled,
   shallowCopy: () => shallowCopy,
   sha512: () => sha512,
@@ -60143,14 +60662,14 @@ __export(exports_utils, {
   namehash: () => namehash,
   mnemonicToSeed: () => mnemonicToSeed,
   mnemonicToEntropy: () => mnemonicToEntropy,
-  keccak256: () => keccak256,
+  keccak256: () => keccak2562,
   joinSignature: () => joinSignature,
   isValidName: () => isValidName,
   isValidMnemonic: () => isValidMnemonic,
   isHexString: () => isHexString,
   isBytesLike: () => isBytesLike,
-  isBytes: () => isBytes,
-  isAddress: () => isAddress,
+  isBytes: () => isBytes2,
+  isAddress: () => isAddress2,
   id: () => id,
   hexlify: () => hexlify,
   hexZeroPad: () => hexZeroPad,
@@ -60165,7 +60684,7 @@ __export(exports_utils, {
   getIcapAddress: () => getIcapAddress,
   getCreate2Address: () => getCreate2Address,
   getContractAddress: () => getContractAddress,
-  getAddress: () => getAddress,
+  getAddress: () => getAddress2,
   getAccountPath: () => getAccountPath,
   formatUnits: () => formatUnits,
   formatEther: () => formatEther,
@@ -60292,8 +60811,8 @@ function pack2(types, values) {
   });
   return hexlify(concat2(tight));
 }
-function keccak2562(types, values) {
-  return keccak256(pack2(types, values));
+function keccak2563(types, values) {
+  return keccak2562(pack2(types, values));
 }
 function sha2562(types, values) {
   return sha256(pack2(types, values));
@@ -60996,7 +61515,6 @@ var contractsRegistry_default = {
       v1_4_1: {
         safeL1Singleton: "0x41675C099F32341bf84BFc5382aF534df5C7461a",
         multisend: "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526",
-        multisendCallOnly: "0x9641d764fc13c8B624c04430C7356C1C7C8102e2",
         safeL2Singleton: "0x29fcB43b46531BcA003ddC8FCB67FFE91900C762",
         proxyFactory: "0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67"
       }
@@ -61091,7 +61609,6 @@ var contractsRegistry_default = {
       v1_4_1: {
         safeL1Singleton: "0x41675C099F32341bf84BFc5382aF534df5C7461a",
         multisend: "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526",
-        multisendCallOnly: "0x9641d764fc13c8B624c04430C7356C1C7C8102e2",
         safeL2Singleton: "0x29fcB43b46531BcA003ddC8FCB67FFE91900C762",
         proxyFactory: "0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67"
       }
@@ -61180,7 +61697,6 @@ var contractsRegistry_default = {
       v1_4_1: {
         safeL1Singleton: "0x41675C099F32341bf84BFc5382aF534df5C7461a",
         multisend: "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526",
-        multisendCallOnly: "0x9641d764fc13c8B624c04430C7356C1C7C8102e2",
         safeL2Singleton: "0x29fcB43b46531BcA003ddC8FCB67FFE91900C762",
         proxyFactory: "0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67"
       }
@@ -61251,7 +61767,6 @@ var contractsRegistry_default = {
       v1_4_1: {
         safeL1Singleton: "0x41675C099F32341bf84BFc5382aF534df5C7461a",
         multisend: "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526",
-        multisendCallOnly: "0x9641d764fc13c8B624c04430C7356C1C7C8102e2",
         safeL2Singleton: "0x29fcB43b46531BcA003ddC8FCB67FFE91900C762",
         proxyFactory: "0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67"
       }
@@ -61317,7 +61832,6 @@ var contractsRegistry_default = {
       v1_4_1: {
         safeL1Singleton: "0x41675C099F32341bf84BFc5382aF534df5C7461a",
         multisend: "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526",
-        multisendCallOnly: "0x9641d764fc13c8B624c04430C7356C1C7C8102e2",
         safeL2Singleton: "0x29fcB43b46531BcA003ddC8FCB67FFE91900C762",
         proxyFactory: "0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67"
       }
@@ -61417,7 +61931,6 @@ var contractsRegistry_default = {
       v1_4_1: {
         safeL1Singleton: "0x41675C099F32341bf84BFc5382aF534df5C7461a",
         multisend: "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526",
-        multisendCallOnly: "0x9641d764fc13c8B624c04430C7356C1C7C8102e2",
         safeL2Singleton: "0x29fcB43b46531BcA003ddC8FCB67FFE91900C762",
         proxyFactory: "0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67"
       }
@@ -61587,7 +62100,6 @@ var contractsRegistry_default = {
       v1_4_1: {
         safeL1Singleton: "0x41675C099F32341bf84BFc5382aF534df5C7461a",
         multisend: "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526",
-        multisendCallOnly: "0x9641d764fc13c8B624c04430C7356C1C7C8102e2",
         safeL2Singleton: "0x29fcB43b46531BcA003ddC8FCB67FFE91900C762",
         proxyFactory: "0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67"
       }
@@ -61629,7 +62141,6 @@ var contractsRegistry_default = {
       v1_4_1: {
         safeL1Singleton: "0x41675C099F32341bf84BFc5382aF534df5C7461a",
         multisend: "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526",
-        multisendCallOnly: "0x9641d764fc13c8B624c04430C7356C1C7C8102e2",
         safeL2Singleton: "0x29fcB43b46531BcA003ddC8FCB67FFE91900C762",
         proxyFactory: "0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67"
       }
@@ -61716,7 +62227,6 @@ var contractsRegistry_default = {
       v1_4_1: {
         safeL1Singleton: "0x41675C099F32341bf84BFc5382aF534df5C7461a",
         multisend: "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526",
-        multisendCallOnly: "0x9641d764fc13c8B624c04430C7356C1C7C8102e2",
         safeL2Singleton: "0x29fcB43b46531BcA003ddC8FCB67FFE91900C762",
         proxyFactory: "0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67"
       }
@@ -61757,7 +62267,6 @@ var contractsRegistry_default = {
       v1_4_1: {
         safeL1Singleton: "0x41675C099F32341bf84BFc5382aF534df5C7461a",
         multisend: "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526",
-        multisendCallOnly: "0x9641d764fc13c8B624c04430C7356C1C7C8102e2",
         safeL2Singleton: "0x29fcB43b46531BcA003ddC8FCB67FFE91900C762",
         proxyFactory: "0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67"
       }
@@ -61797,7 +62306,6 @@ var contractsRegistry_default = {
       v1_4_1: {
         safeL1Singleton: "0x41675C099F32341bf84BFc5382aF534df5C7461a",
         multisend: "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526",
-        multisendCallOnly: "0x9641d764fc13c8B624c04430C7356C1C7C8102e2",
         safeL2Singleton: "0x29fcB43b46531BcA003ddC8FCB67FFE91900C762",
         proxyFactory: "0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67"
       }
@@ -61856,7 +62364,6 @@ var contractsRegistry_default = {
       v1_4_1: {
         safeL1Singleton: "0x41675C099F32341bf84BFc5382aF534df5C7461a",
         multisend: "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526",
-        multisendCallOnly: "0x9641d764fc13c8B624c04430C7356C1C7C8102e2",
         safeL2Singleton: "0x29fcB43b46531BcA003ddC8FCB67FFE91900C762",
         proxyFactory: "0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67"
       }
@@ -61888,7 +62395,6 @@ var contractsRegistry_default = {
       v1_4_1: {
         safeL1Singleton: "0x41675C099F32341bf84BFc5382aF534df5C7461a",
         multisend: "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526",
-        multisendCallOnly: "0x9641d764fc13c8B624c04430C7356C1C7C8102e2",
         safeL2Singleton: "0x29fcB43b46531BcA003ddC8FCB67FFE91900C762",
         proxyFactory: "0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67"
       }
@@ -61957,7 +62463,7 @@ function getAddressOrThrow(chainId, key2) {
   if (typeof current !== "string") {
     throw new Error(`DAMM-sdk: Key "${key2}" does not resolve to an address for chainId ${chainId} (${chainName})`);
   }
-  return current;
+  return getAddress(current);
 }
 function findAddressPath(obj, targetAddress, currentPath = []) {
   if (typeof obj === "string") {
@@ -62015,12 +62521,10 @@ var pack3 = (payload) => {
 class MultisendBuilder {
   payload;
   multisendAddress;
-  defaultOperation;
   value;
-  constructor(multisendAddress, defaultOperation, payload, value) {
+  constructor(multisendAddress, payload, value) {
     this.payload = payload || [];
     this.multisendAddress = multisendAddress;
-    this.defaultOperation = defaultOperation;
     this.value = value;
   }
   addSubcall(call) {
@@ -62028,10 +62532,10 @@ class MultisendBuilder {
       ...call,
       dataLength: numberToHex(call.data.slice(2).length / 2, { size: 32 })
     };
-    return new MultisendBuilder(this.multisendAddress, this.defaultOperation, add3(callWithLength, this.payload), this.value);
+    return new MultisendBuilder(this.multisendAddress, add3(callWithLength, this.payload), this.value);
   }
   setValue(value) {
-    return new MultisendBuilder(this.multisendAddress, this.defaultOperation, this.payload, value);
+    return new MultisendBuilder(this.multisendAddress, this.payload, value);
   }
   build(config) {
     const inter = new exports_ethers.utils.Interface(multisend_abi_default);
@@ -62039,15 +62543,12 @@ class MultisendBuilder {
     return createCall({
       to: this.multisendAddress,
       value: config?.value || this.value || 0n,
-      operation: config?.operation || this.defaultOperation,
+      operation: config?.operation || 1,
       data
     });
   }
   static new(chainId, version28 = "v1_4_1") {
-    return new MultisendBuilder(getAddressOrThrow(chainId, `gnosisSafe.${version28}.multisend`), 1);
-  }
-  static newCallOnly(chainId, version28 = "v1_4_1") {
-    return new MultisendBuilder(getAddressOrThrow(chainId, `gnosisSafe.${version28}.multisendCallOnly`), 0);
+    return new MultisendBuilder(getAddressOrThrow(chainId, `gnosisSafe.${version28}.multisend`));
   }
 }
 // src/integrations/gnosis/safe.L2.abi.ts
@@ -66846,7 +67347,7 @@ var NativeCurrency = /* @__PURE__ */ function(_BaseCurrency) {
 }(BaseCurrency);
 function validateAndParseAddress(address) {
   try {
-    return getAddress(address);
+    return getAddress2(address);
   } catch (error) {
     throw new Error(address + " is not a valid address.");
   }
@@ -70265,9 +70766,9 @@ var SwapRouter_default = {
 };
 
 // node_modules/@uniswap/v3-sdk/dist/v3-sdk.esm.js
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key2, arg) {
+function asyncGeneratorStep(gen2, resolve, reject, _next, _throw, key2, arg) {
   try {
-    var info = gen[key2](arg);
+    var info = gen2[key2](arg);
     var value = info.value;
   } catch (error) {
     reject(error);
@@ -70283,12 +70784,12 @@ function _asyncToGenerator(fn) {
   return function() {
     var self2 = this, args = arguments;
     return new Promise(function(resolve, reject) {
-      var gen = fn.apply(self2, args);
+      var gen2 = fn.apply(self2, args);
       function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+        asyncGeneratorStep(gen2, resolve, reject, _next, _throw, "next", value);
       }
       function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+        asyncGeneratorStep(gen2, resolve, reject, _next, _throw, "throw", err);
       }
       _next(undefined);
     });
@@ -70879,7 +71380,7 @@ var Q192 = /* @__PURE__ */ import_jsbi2.default.exponentiate(Q96, /* @__PURE__ *
 function computePoolAddress(_ref) {
   var { factoryAddress, tokenA, tokenB, fee, initCodeHashManualOverride } = _ref;
   var _ref2 = tokenA.sortsBefore(tokenB) ? [tokenA, tokenB] : [tokenB, tokenA], token0 = _ref2[0], token1 = _ref2[1];
-  return getCreate2Address(factoryAddress, keccak2562(["bytes"], [defaultAbiCoder.encode(["address", "address", "uint24"], [token0.address, token1.address, fee])]), initCodeHashManualOverride != null ? initCodeHashManualOverride : POOL_INIT_CODE_HASH);
+  return getCreate2Address(factoryAddress, keccak2563(["bytes"], [defaultAbiCoder.encode(["address", "address", "uint24"], [token0.address, token1.address, fee])]), initCodeHashManualOverride != null ? initCodeHashManualOverride : POOL_INIT_CODE_HASH);
 }
 var LiquidityMath = /* @__PURE__ */ function() {
   function LiquidityMath2() {}
@@ -72952,7 +73453,7 @@ var NativeCurrency2 = /* @__PURE__ */ function(_BaseCurrency) {
 }(BaseCurrency3);
 function validateAndParseAddress2(address) {
   try {
-    return getAddress(address);
+    return getAddress2(address);
   } catch (error) {
     throw new Error(address + " is not a valid address.");
   }
@@ -73056,10 +73557,10 @@ function computeZksyncCreate2Address(sender, bytecodeHash, salt, input) {
   if (input === undefined) {
     input = "0x";
   }
-  var prefix2 = keccak256(toUtf8Bytes("zksyncCreate2"));
-  var inputHash = keccak256(input);
-  var addressBytes = keccak256(concat2([prefix2, hexZeroPad(sender, 32), salt, bytecodeHash, inputHash])).slice(26);
-  return getAddress(addressBytes);
+  var prefix2 = keccak2562(toUtf8Bytes("zksyncCreate2"));
+  var inputHash = keccak2562(input);
+  var addressBytes = keccak2562(concat2([prefix2, hexZeroPad(sender, 32), salt, bytecodeHash, inputHash])).slice(26);
+  return getAddress2(addressBytes);
 }
 var MAX_SAFE_INTEGER3 = /* @__PURE__ */ import_jsbi3.default.BigInt(Number.MAX_SAFE_INTEGER);
 var ZERO3 = /* @__PURE__ */ import_jsbi3.default.BigInt(0);
@@ -73527,7 +74028,7 @@ var Q1922 = /* @__PURE__ */ import_jsbi4.default.exponentiate(Q962, /* @__PURE__
 function computePoolAddress2(_ref) {
   var { factoryAddress, tokenA, tokenB, fee, initCodeHashManualOverride, chainId } = _ref;
   var _ref2 = tokenA.sortsBefore(tokenB) ? [tokenA, tokenB] : [tokenB, tokenA], token0 = _ref2[0], token1 = _ref2[1];
-  var salt = keccak2562(["bytes"], [defaultAbiCoder.encode(["address", "address", "uint24"], [token0.address, token1.address, fee])]);
+  var salt = keccak2563(["bytes"], [defaultAbiCoder.encode(["address", "address", "uint24"], [token0.address, token1.address, fee])]);
   var initCodeHash = initCodeHashManualOverride != null ? initCodeHashManualOverride : poolInitCodeHash(chainId);
   switch (chainId) {
     case ChainId2.ZKSYNC:
@@ -74941,7 +75442,7 @@ var SwapRouter2 = /* @__PURE__ */ function() {
 SwapRouter2.INTERFACE = /* @__PURE__ */ new Interface(SwapRouter_default.abi);
 
 // node_modules/@uniswap/v4-sdk/dist/v4-sdk.esm.js
-var import_utils3 = __toESM(require_utils6());
+var import_utils4 = __toESM(require_utils6());
 var import_jsbi5 = __toESM(require_jsbi_umd());
 function _arrayLikeToArray3(r2, a) {
   (a == null || a > r2.length) && (a = r2.length);
@@ -75413,7 +75914,7 @@ var Hook = /* @__PURE__ */ function() {
     return !!(parseInt(address, 16) & 1 << hookFlagIndex[hookOption]);
   };
   Hook2._checkAddress = function _checkAddress(address) {
-    !import_utils3.isAddress(address) && invariant(false, "invalid address");
+    !import_utils4.isAddress(address) && invariant(false, "invalid address");
   };
   return Hook2;
 }();
@@ -75452,7 +75953,7 @@ var Pool3 = /* @__PURE__ */ function() {
     if (ticks === undefined) {
       ticks = NO_TICK_DATA_PROVIDER_DEFAULT3;
     }
-    !import_utils3.isAddress(hooks) && invariant(false, "Invalid hook address");
+    !import_utils4.isAddress(hooks) && invariant(false, "Invalid hook address");
     !(Number.isInteger(fee) && (fee === DYNAMIC_FEE_FLAG || fee < 1e6)) && invariant(false, "FEE");
     if (fee === DYNAMIC_FEE_FLAG) {
       !(Number(hooks) > 0) && invariant(false, "Dynamic fee pool requires a hook");
@@ -75474,7 +75975,7 @@ var Pool3 = /* @__PURE__ */ function() {
     this.poolId = Pool4.getPoolId(this.currency0, this.currency1, this.fee, this.tickSpacing, this.hooks);
   }
   Pool4.getPoolKey = function getPoolKey(currencyA, currencyB, fee, tickSpacing, hooks) {
-    !import_utils3.isAddress(hooks) && invariant(false, "Invalid hook address");
+    !import_utils4.isAddress(hooks) && invariant(false, "Invalid hook address");
     var _ref2 = sortsBefore(currencyA, currencyB) ? [currencyA, currencyB] : [currencyB, currencyA], currency0 = _ref2[0], currency1 = _ref2[1];
     var currency0Addr = currency0.isNative ? ADDRESS_ZERO3 : currency0.wrapped.address;
     var currency1Addr = currency1.isNative ? ADDRESS_ZERO3 : currency1.wrapped.address;
@@ -75490,7 +75991,7 @@ var Pool3 = /* @__PURE__ */ function() {
     var _ref3 = sortsBefore(currencyA, currencyB) ? [currencyA, currencyB] : [currencyB, currencyA], currency0 = _ref3[0], currency1 = _ref3[1];
     var currency0Addr = currency0.isNative ? ADDRESS_ZERO3 : currency0.wrapped.address;
     var currency1Addr = currency1.isNative ? ADDRESS_ZERO3 : currency1.wrapped.address;
-    return keccak2562(["bytes"], [import_utils3.defaultAbiCoder.encode(["address", "address", "uint24", "int24", "address"], [currency0Addr, currency1Addr, fee, tickSpacing, hooks])]);
+    return keccak2563(["bytes"], [import_utils4.defaultAbiCoder.encode(["address", "address", "uint24", "int24", "address"], [currency0Addr, currency1Addr, fee, tickSpacing, hooks])]);
   };
   var _proto = Pool4.prototype;
   _proto.involvesCurrency = function involvesCurrency(currency) {
@@ -76080,7 +76581,7 @@ var V4Planner = /* @__PURE__ */ function() {
     return this;
   };
   _proto.finalize = function finalize() {
-    return import_utils3.defaultAbiCoder.encode(["bytes", "bytes[]"], [this.actions, this.params]);
+    return import_utils4.defaultAbiCoder.encode(["bytes", "bytes[]"], [this.actions, this.params]);
   };
   return V4Planner2;
 }();
@@ -76088,7 +76589,7 @@ function currencyAddress(currency) {
   return currency.isNative ? ADDRESS_ZERO3 : currency.wrapped.address;
 }
 function createAction(action, parameters) {
-  var encodedInput = import_utils3.defaultAbiCoder.encode(V4_BASE_ACTIONS_ABI_DEFINITION[action].map(function(v) {
+  var encodedInput = import_utils4.defaultAbiCoder.encode(V4_BASE_ACTIONS_ABI_DEFINITION[action].map(function(v) {
     return v.type;
   }), parameters);
   return {
@@ -77387,7 +77888,7 @@ var SwapExactInputSingleCalldataV4 = ({
   hookData = "0x",
   recipient
 }) => {
-  const getAddress2 = (currency) => {
+  const getAddress3 = (currency) => {
     return currency.address;
   };
   const commands = exports_ethers.utils.solidityPack(["uint8"], [16 /* V4_SWAP */]);
@@ -77395,15 +77896,15 @@ var SwapExactInputSingleCalldataV4 = ({
   const params = [
     exports_ethers.utils.defaultAbiCoder.encode(["tuple(tuple(address,address,uint24,int24,address),bool,uint128,uint128,bytes)"], [
       [
-        [getAddress2(pool.currency0), getAddress2(pool.currency1), pool.fee, pool.tickSpacing, pool.hooks],
+        [getAddress3(pool.currency0), getAddress3(pool.currency1), pool.fee, pool.tickSpacing, pool.hooks],
         zeroForOne,
         amountIn,
         amountOutMinimum,
         hookData
       ]
     ]),
-    exports_ethers.utils.defaultAbiCoder.encode(["address", "uint256"], [zeroForOne ? getAddress2(pool.currency0) : getAddress2(pool.currency1), amountIn]),
-    exports_ethers.utils.defaultAbiCoder.encode(["address", "uint256"], [zeroForOne ? getAddress2(pool.currency1) : getAddress2(pool.currency0), amountOutMinimum])
+    exports_ethers.utils.defaultAbiCoder.encode(["address", "uint256"], [zeroForOne ? getAddress3(pool.currency0) : getAddress3(pool.currency1), amountIn]),
+    exports_ethers.utils.defaultAbiCoder.encode(["address", "uint256"], [zeroForOne ? getAddress3(pool.currency1) : getAddress3(pool.currency0), amountOutMinimum])
   ];
   const actionsList = [];
   actionsList.push(Actions2.SWAP_EXACT_IN_SINGLE);
@@ -84730,7 +85231,7 @@ var silo_abi_default = [
   }
 ];
 // src/integrations/lagoonV1/lagoon.v1.ts
-var import_utils4 = __toESM(require_utils6());
+var import_utils5 = __toESM(require_utils6());
 var factoryInterface = new exports_ethers.utils.Interface(factory_abi_default);
 var vaultInterface = new exports_ethers.utils.Interface(vault_abi_default);
 var CreateVaultProxyCalldata = ({
@@ -84882,7 +85383,7 @@ var calculateDeterministicVaultAddress = ({
   wrappedNativeToken,
   initStruct
 }) => {
-  const initEncoded = import_utils4.defaultAbiCoder.encode(["tuple(address,string,string,address,address,address,address,address,uint16,uint16,bool,uint256)"], [
+  const initEncoded = import_utils5.defaultAbiCoder.encode(["tuple(address,string,string,address,address,address,address,address,uint16,uint16,bool,uint256)"], [
     [
       initStruct.underlying,
       initStruct.name,
@@ -84902,11 +85403,11 @@ var calculateDeterministicVaultAddress = ({
     "function initialize(bytes data, address feeRegistry, address wrappedNativeToken)"
   ]);
   const initCall = iface.encodeFunctionData("initialize", [initEncoded, registry, wrappedNativeToken]);
-  const constructorEncoded = import_utils4.defaultAbiCoder.encode(["address", "address", "address", "uint256", "bytes"], [initStruct.logic, registry, initStruct.initialOwner, initStruct.initialDelay, initCall]);
+  const constructorEncoded = import_utils5.defaultAbiCoder.encode(["address", "address", "address", "uint256", "bytes"], [initStruct.logic, registry, initStruct.initialOwner, initStruct.initialDelay, initCall]);
   const initCode = OPTIN_PROXY_CREATION_BYTECODE + constructorEncoded.slice(2);
-  const create2Inputs = import_utils4.solidityPack(["bytes1", "address", "bytes32", "bytes32"], ["0xff", factoryAddress, initStruct.salt, import_utils4.keccak256(initCode)]);
-  const computedAddress = `0x${import_utils4.keccak256(create2Inputs).slice(-40)}`;
-  return import_utils4.getAddress(computedAddress);
+  const create2Inputs = import_utils5.solidityPack(["bytes1", "address", "bytes32", "bytes32"], ["0xff", factoryAddress, initStruct.salt, import_utils5.keccak256(initCode)]);
+  const computedAddress = `0x${import_utils5.keccak256(create2Inputs).slice(-40)}`;
+  return import_utils5.getAddress(computedAddress);
 };
 // src/integrations/lendleV1/lendle.pool.abi.ts
 var lendle_pool_abi_default = [
@@ -95019,4 +95520,4 @@ var simulateOrThrow = async (env2) => {
   };
 };
 
-//# debugId=E81EA515B45DFEA664756E2164756E21
+//# debugId=A76B0AA86E5BA3B264756E2164756E21