@awarizon/web3 1.3.3 → 1.3.4

package/dist/index.js

@@ -1,12 +1,3276 @@
 'use strict';
 
 var viem = require('viem');
-var walletEngine = require('@awarizon/wallet-engine');
-var txEngine = require('@awarizon/tx-engine');
+var accounts = require('viem/accounts');
+var nc = require('crypto');
 var chains = require('viem/chains');
-var abiEngine = require('@awarizon/abi-engine');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var nc__namespace = /*#__PURE__*/_interopNamespace(nc);
 
 // src/sdk.ts
+var crypto = nc__namespace && typeof nc__namespace === "object" && "webcrypto" in nc__namespace ? nc__namespace.webcrypto : nc__namespace && typeof nc__namespace === "object" && "randomBytes" in nc__namespace ? nc__namespace : void 0;
+
+// ../../node_modules/.pnpm/@noble+hashes@1.8.0/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 clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
+}
+var Hash = class {
+};
+function createHasher(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+function randomBytes(bytesLength = 32) {
+  if (crypto && typeof crypto.getRandomValues === "function") {
+    return crypto.getRandomValues(new Uint8Array(bytesLength));
+  }
+  if (crypto && typeof crypto.randomBytes === "function") {
+    return Uint8Array.from(crypto.randomBytes(bytesLength));
+  }
+  throw new Error("crypto.getRandomValues must be defined");
+}
+
+// ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/_md.js
+function setBigUint64(view, byteOffset, value, isLE) {
+  if (typeof view.setBigUint64 === "function")
+    return view.setBigUint64(byteOffset, value, isLE);
+  const _32n = BigInt(32);
+  const _u32_max = BigInt(4294967295);
+  const wh = Number(value >> _32n & _u32_max);
+  const wl = Number(value & _u32_max);
+  const h = isLE ? 4 : 0;
+  const l = isLE ? 0 : 4;
+  view.setUint32(byteOffset + h, wh, isLE);
+  view.setUint32(byteOffset + l, wl, isLE);
+}
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+var HashMD = class extends Hash {
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    super();
+    this.finished = false;
+    this.length = 0;
+    this.pos = 0;
+    this.destroyed = false;
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    data = toBytes(data);
+    abytes(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to || (to = new this.constructor());
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha2.js
+var SHA256_K = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+var SHA256 = class extends HashMD {
+  constructor(outputLen = 32) {
+    super(64, outputLen, 8, false);
+    this.A = SHA256_IV[0] | 0;
+    this.B = SHA256_IV[1] | 0;
+    this.C = SHA256_IV[2] | 0;
+    this.D = SHA256_IV[3] | 0;
+    this.E = SHA256_IV[4] | 0;
+    this.F = SHA256_IV[5] | 0;
+    this.G = SHA256_IV[6] | 0;
+    this.H = SHA256_IV[7] | 0;
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  // prettier-ignore
+  set(A, B, C, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4)
+      SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16; i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i = 0; i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    clean(SHA256_W);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+};
+var sha256 = /* @__PURE__ */ createHasher(() => new SHA256());
+
+// ../../node_modules/.pnpm/@scure+base@1.2.6/node_modules/@scure/base/lib/esm/index.js
+function isBytes2(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function isArrayOf(isString, arr) {
+  if (!Array.isArray(arr))
+    return false;
+  if (arr.length === 0)
+    return true;
+  if (isString) {
+    return arr.every((item) => typeof item === "string");
+  } else {
+    return arr.every((item) => Number.isSafeInteger(item));
+  }
+}
+function afn(input) {
+  if (typeof input !== "function")
+    throw new Error("function expected");
+  return true;
+}
+function astr(label, input) {
+  if (typeof input !== "string")
+    throw new Error(`${label}: string expected`);
+  return true;
+}
+function anumber2(n) {
+  if (!Number.isSafeInteger(n))
+    throw new Error(`invalid integer: ${n}`);
+}
+function aArr(input) {
+  if (!Array.isArray(input))
+    throw new Error("array expected");
+}
+function astrArr(label, input) {
+  if (!isArrayOf(true, input))
+    throw new Error(`${label}: array of strings expected`);
+}
+function anumArr(label, input) {
+  if (!isArrayOf(false, input))
+    throw new Error(`${label}: array of numbers expected`);
+}
+// @__NO_SIDE_EFFECTS__
+function chain(...args) {
+  const id = (a) => a;
+  const wrap = (a, b) => (c) => a(b(c));
+  const encode = args.map((x) => x.encode).reduceRight(wrap, id);
+  const decode = args.map((x) => x.decode).reduce(wrap, id);
+  return { encode, decode };
+}
+// @__NO_SIDE_EFFECTS__
+function alphabet(letters) {
+  const lettersA = typeof letters === "string" ? letters.split("") : letters;
+  const len = lettersA.length;
+  astrArr("alphabet", lettersA);
+  const indexes = new Map(lettersA.map((l, i) => [l, i]));
+  return {
+    encode: (digits) => {
+      aArr(digits);
+      return digits.map((i) => {
+        if (!Number.isSafeInteger(i) || i < 0 || i >= len)
+          throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
+        return lettersA[i];
+      });
+    },
+    decode: (input) => {
+      aArr(input);
+      return input.map((letter) => {
+        astr("alphabet.decode", letter);
+        const i = indexes.get(letter);
+        if (i === void 0)
+          throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
+        return i;
+      });
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function join(separator = "") {
+  astr("join", separator);
+  return {
+    encode: (from) => {
+      astrArr("join.decode", from);
+      return from.join(separator);
+    },
+    decode: (to) => {
+      astr("join.decode", to);
+      return to.split(separator);
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function padding(bits, chr = "=") {
+  anumber2(bits);
+  astr("padding", chr);
+  return {
+    encode(data) {
+      astrArr("padding.encode", data);
+      while (data.length * bits % 8)
+        data.push(chr);
+      return data;
+    },
+    decode(input) {
+      astrArr("padding.decode", input);
+      let end = input.length;
+      if (end * bits % 8)
+        throw new Error("padding: invalid, string should have whole number of bytes");
+      for (; end > 0 && input[end - 1] === chr; end--) {
+        const last = end - 1;
+        const byte = last * bits;
+        if (byte % 8 === 0)
+          throw new Error("padding: invalid, string has too much padding");
+      }
+      return input.slice(0, end);
+    }
+  };
+}
+function convertRadix(data, from, to) {
+  if (from < 2)
+    throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);
+  if (to < 2)
+    throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);
+  aArr(data);
+  if (!data.length)
+    return [];
+  let pos = 0;
+  const res = [];
+  const digits = Array.from(data, (d) => {
+    anumber2(d);
+    if (d < 0 || d >= from)
+      throw new Error(`invalid integer: ${d}`);
+    return d;
+  });
+  const dlen = digits.length;
+  while (true) {
+    let carry = 0;
+    let done = true;
+    for (let i = pos; i < dlen; i++) {
+      const digit = digits[i];
+      const fromCarry = from * carry;
+      const digitBase = fromCarry + digit;
+      if (!Number.isSafeInteger(digitBase) || fromCarry / from !== carry || digitBase - digit !== fromCarry) {
+        throw new Error("convertRadix: carry overflow");
+      }
+      const div = digitBase / to;
+      carry = digitBase % to;
+      const rounded = Math.floor(div);
+      digits[i] = rounded;
+      if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)
+        throw new Error("convertRadix: carry overflow");
+      if (!done)
+        continue;
+      else if (!rounded)
+        pos = i;
+      else
+        done = false;
+    }
+    res.push(carry);
+    if (done)
+      break;
+  }
+  for (let i = 0; i < data.length - 1 && data[i] === 0; i++)
+    res.push(0);
+  return res.reverse();
+}
+var gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+var radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - gcd(from, to));
+var powers = /* @__PURE__ */ (() => {
+  let res = [];
+  for (let i = 0; i < 40; i++)
+    res.push(2 ** i);
+  return res;
+})();
+function convertRadix2(data, from, to, padding2) {
+  aArr(data);
+  if (from <= 0 || from > 32)
+    throw new Error(`convertRadix2: wrong from=${from}`);
+  if (to <= 0 || to > 32)
+    throw new Error(`convertRadix2: wrong to=${to}`);
+  if (/* @__PURE__ */ radix2carry(from, to) > 32) {
+    throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${/* @__PURE__ */ radix2carry(from, to)}`);
+  }
+  let carry = 0;
+  let pos = 0;
+  const max = powers[from];
+  const mask = powers[to] - 1;
+  const res = [];
+  for (const n of data) {
+    anumber2(n);
+    if (n >= max)
+      throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
+    carry = carry << from | n;
+    if (pos + from > 32)
+      throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
+    pos += from;
+    for (; pos >= to; pos -= to)
+      res.push((carry >> pos - to & mask) >>> 0);
+    const pow = powers[pos];
+    if (pow === void 0)
+      throw new Error("invalid carry");
+    carry &= pow - 1;
+  }
+  carry = carry << to - pos & mask;
+  if (!padding2 && pos >= from)
+    throw new Error("Excess padding");
+  if (!padding2 && carry > 0)
+    throw new Error(`Non-zero padding: ${carry}`);
+  if (padding2 && pos > 0)
+    res.push(carry >>> 0);
+  return res;
+}
+// @__NO_SIDE_EFFECTS__
+function radix(num) {
+  anumber2(num);
+  const _256 = 2 ** 8;
+  return {
+    encode: (bytes) => {
+      if (!isBytes2(bytes))
+        throw new Error("radix.encode input should be Uint8Array");
+      return convertRadix(Array.from(bytes), _256, num);
+    },
+    decode: (digits) => {
+      anumArr("radix.decode", digits);
+      return Uint8Array.from(convertRadix(digits, num, _256));
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function radix2(bits, revPadding = false) {
+  anumber2(bits);
+  if (bits <= 0 || bits > 32)
+    throw new Error("radix2: bits should be in (0..32]");
+  if (/* @__PURE__ */ radix2carry(8, bits) > 32 || /* @__PURE__ */ radix2carry(bits, 8) > 32)
+    throw new Error("radix2: carry overflow");
+  return {
+    encode: (bytes) => {
+      if (!isBytes2(bytes))
+        throw new Error("radix2.encode input should be Uint8Array");
+      return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
+    },
+    decode: (digits) => {
+      anumArr("radix2.decode", digits);
+      return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
+    }
+  };
+}
+function checksum(len, fn) {
+  anumber2(len);
+  afn(fn);
+  return {
+    encode(data) {
+      if (!isBytes2(data))
+        throw new Error("checksum.encode: input should be Uint8Array");
+      const sum = fn(data).slice(0, len);
+      const res = new Uint8Array(data.length + len);
+      res.set(data);
+      res.set(sum, data.length);
+      return res;
+    },
+    decode(data) {
+      if (!isBytes2(data))
+        throw new Error("checksum.decode: input should be Uint8Array");
+      const payload = data.slice(0, -len);
+      const oldChecksum = data.slice(-len);
+      const newChecksum = fn(payload).slice(0, len);
+      for (let i = 0; i < len; i++)
+        if (newChecksum[i] !== oldChecksum[i])
+          throw new Error("Invalid checksum");
+      return payload;
+    }
+  };
+}
+var utils = {
+  alphabet,
+  chain,
+  checksum,
+  convertRadix,
+  convertRadix2,
+  radix,
+  radix2,
+  join,
+  padding
+};
+
+// ../../node_modules/.pnpm/@scure+bip39@1.6.0/node_modules/@scure/bip39/esm/index.js
+var isJapanese = (wordlist2) => wordlist2[0] === "\u3042\u3044\u3053\u304F\u3057\u3093";
+function nfkd(str) {
+  if (typeof str !== "string")
+    throw new TypeError("invalid mnemonic type: " + typeof str);
+  return str.normalize("NFKD");
+}
+function normalize(str) {
+  const norm = nfkd(str);
+  const words = norm.split(" ");
+  if (![12, 15, 18, 21, 24].includes(words.length))
+    throw new Error("Invalid mnemonic");
+  return { nfkd: norm, words };
+}
+function aentropy(ent) {
+  abytes(ent, 16, 20, 24, 28, 32);
+}
+function generateMnemonic(wordlist2, strength = 128) {
+  anumber(strength);
+  if (strength % 32 !== 0 || strength > 256)
+    throw new TypeError("Invalid entropy");
+  return entropyToMnemonic(randomBytes(strength / 8), wordlist2);
+}
+var calcChecksum = (entropy) => {
+  const bitsLeft = 8 - entropy.length / 4;
+  return new Uint8Array([sha256(entropy)[0] >> bitsLeft << bitsLeft]);
+};
+function getCoder(wordlist2) {
+  if (!Array.isArray(wordlist2) || wordlist2.length !== 2048 || typeof wordlist2[0] !== "string")
+    throw new Error("Wordlist: expected array of 2048 strings");
+  wordlist2.forEach((i) => {
+    if (typeof i !== "string")
+      throw new Error("wordlist: non-string element: " + i);
+  });
+  return utils.chain(utils.checksum(1, calcChecksum), utils.radix2(11, true), utils.alphabet(wordlist2));
+}
+function mnemonicToEntropy(mnemonic, wordlist2) {
+  const { words } = normalize(mnemonic);
+  const entropy = getCoder(wordlist2).decode(words);
+  aentropy(entropy);
+  return entropy;
+}
+function entropyToMnemonic(entropy, wordlist2) {
+  aentropy(entropy);
+  const words = getCoder(wordlist2).encode(entropy);
+  return words.join(isJapanese(wordlist2) ? "\u3000" : " ");
+}
+function validateMnemonic(mnemonic, wordlist2) {
+  try {
+    mnemonicToEntropy(mnemonic, wordlist2);
+  } catch (e) {
+    return false;
+  }
+  return true;
+}
+
+// ../../node_modules/.pnpm/@scure+bip39@1.6.0/node_modules/@scure/bip39/esm/wordlists/english.js
+var wordlist = `abandon
+ability
+able
+about
+above
+absent
+absorb
+abstract
+absurd
+abuse
+access
+accident
+account
+accuse
+achieve
+acid
+acoustic
+acquire
+across
+act
+action
+actor
+actress
+actual
+adapt
+add
+addict
+address
+adjust
+admit
+adult
+advance
+advice
+aerobic
+affair
+afford
+afraid
+again
+age
+agent
+agree
+ahead
+aim
+air
+airport
+aisle
+alarm
+album
+alcohol
+alert
+alien
+all
+alley
+allow
+almost
+alone
+alpha
+already
+also
+alter
+always
+amateur
+amazing
+among
+amount
+amused
+analyst
+anchor
+ancient
+anger
+angle
+angry
+animal
+ankle
+announce
+annual
+another
+answer
+antenna
+antique
+anxiety
+any
+apart
+apology
+appear
+apple
+approve
+april
+arch
+arctic
+area
+arena
+argue
+arm
+armed
+armor
+army
+around
+arrange
+arrest
+arrive
+arrow
+art
+artefact
+artist
+artwork
+ask
+aspect
+assault
+asset
+assist
+assume
+asthma
+athlete
+atom
+attack
+attend
+attitude
+attract
+auction
+audit
+august
+aunt
+author
+auto
+autumn
+average
+avocado
+avoid
+awake
+aware
+away
+awesome
+awful
+awkward
+axis
+baby
+bachelor
+bacon
+badge
+bag
+balance
+balcony
+ball
+bamboo
+banana
+banner
+bar
+barely
+bargain
+barrel
+base
+basic
+basket
+battle
+beach
+bean
+beauty
+because
+become
+beef
+before
+begin
+behave
+behind
+believe
+below
+belt
+bench
+benefit
+best
+betray
+better
+between
+beyond
+bicycle
+bid
+bike
+bind
+biology
+bird
+birth
+bitter
+black
+blade
+blame
+blanket
+blast
+bleak
+bless
+blind
+blood
+blossom
+blouse
+blue
+blur
+blush
+board
+boat
+body
+boil
+bomb
+bone
+bonus
+book
+boost
+border
+boring
+borrow
+boss
+bottom
+bounce
+box
+boy
+bracket
+brain
+brand
+brass
+brave
+bread
+breeze
+brick
+bridge
+brief
+bright
+bring
+brisk
+broccoli
+broken
+bronze
+broom
+brother
+brown
+brush
+bubble
+buddy
+budget
+buffalo
+build
+bulb
+bulk
+bullet
+bundle
+bunker
+burden
+burger
+burst
+bus
+business
+busy
+butter
+buyer
+buzz
+cabbage
+cabin
+cable
+cactus
+cage
+cake
+call
+calm
+camera
+camp
+can
+canal
+cancel
+candy
+cannon
+canoe
+canvas
+canyon
+capable
+capital
+captain
+car
+carbon
+card
+cargo
+carpet
+carry
+cart
+case
+cash
+casino
+castle
+casual
+cat
+catalog
+catch
+category
+cattle
+caught
+cause
+caution
+cave
+ceiling
+celery
+cement
+census
+century
+cereal
+certain
+chair
+chalk
+champion
+change
+chaos
+chapter
+charge
+chase
+chat
+cheap
+check
+cheese
+chef
+cherry
+chest
+chicken
+chief
+child
+chimney
+choice
+choose
+chronic
+chuckle
+chunk
+churn
+cigar
+cinnamon
+circle
+citizen
+city
+civil
+claim
+clap
+clarify
+claw
+clay
+clean
+clerk
+clever
+click
+client
+cliff
+climb
+clinic
+clip
+clock
+clog
+close
+cloth
+cloud
+clown
+club
+clump
+cluster
+clutch
+coach
+coast
+coconut
+code
+coffee
+coil
+coin
+collect
+color
+column
+combine
+come
+comfort
+comic
+common
+company
+concert
+conduct
+confirm
+congress
+connect
+consider
+control
+convince
+cook
+cool
+copper
+copy
+coral
+core
+corn
+correct
+cost
+cotton
+couch
+country
+couple
+course
+cousin
+cover
+coyote
+crack
+cradle
+craft
+cram
+crane
+crash
+crater
+crawl
+crazy
+cream
+credit
+creek
+crew
+cricket
+crime
+crisp
+critic
+crop
+cross
+crouch
+crowd
+crucial
+cruel
+cruise
+crumble
+crunch
+crush
+cry
+crystal
+cube
+culture
+cup
+cupboard
+curious
+current
+curtain
+curve
+cushion
+custom
+cute
+cycle
+dad
+damage
+damp
+dance
+danger
+daring
+dash
+daughter
+dawn
+day
+deal
+debate
+debris
+decade
+december
+decide
+decline
+decorate
+decrease
+deer
+defense
+define
+defy
+degree
+delay
+deliver
+demand
+demise
+denial
+dentist
+deny
+depart
+depend
+deposit
+depth
+deputy
+derive
+describe
+desert
+design
+desk
+despair
+destroy
+detail
+detect
+develop
+device
+devote
+diagram
+dial
+diamond
+diary
+dice
+diesel
+diet
+differ
+digital
+dignity
+dilemma
+dinner
+dinosaur
+direct
+dirt
+disagree
+discover
+disease
+dish
+dismiss
+disorder
+display
+distance
+divert
+divide
+divorce
+dizzy
+doctor
+document
+dog
+doll
+dolphin
+domain
+donate
+donkey
+donor
+door
+dose
+double
+dove
+draft
+dragon
+drama
+drastic
+draw
+dream
+dress
+drift
+drill
+drink
+drip
+drive
+drop
+drum
+dry
+duck
+dumb
+dune
+during
+dust
+dutch
+duty
+dwarf
+dynamic
+eager
+eagle
+early
+earn
+earth
+easily
+east
+easy
+echo
+ecology
+economy
+edge
+edit
+educate
+effort
+egg
+eight
+either
+elbow
+elder
+electric
+elegant
+element
+elephant
+elevator
+elite
+else
+embark
+embody
+embrace
+emerge
+emotion
+employ
+empower
+empty
+enable
+enact
+end
+endless
+endorse
+enemy
+energy
+enforce
+engage
+engine
+enhance
+enjoy
+enlist
+enough
+enrich
+enroll
+ensure
+enter
+entire
+entry
+envelope
+episode
+equal
+equip
+era
+erase
+erode
+erosion
+error
+erupt
+escape
+essay
+essence
+estate
+eternal
+ethics
+evidence
+evil
+evoke
+evolve
+exact
+example
+excess
+exchange
+excite
+exclude
+excuse
+execute
+exercise
+exhaust
+exhibit
+exile
+exist
+exit
+exotic
+expand
+expect
+expire
+explain
+expose
+express
+extend
+extra
+eye
+eyebrow
+fabric
+face
+faculty
+fade
+faint
+faith
+fall
+false
+fame
+family
+famous
+fan
+fancy
+fantasy
+farm
+fashion
+fat
+fatal
+father
+fatigue
+fault
+favorite
+feature
+february
+federal
+fee
+feed
+feel
+female
+fence
+festival
+fetch
+fever
+few
+fiber
+fiction
+field
+figure
+file
+film
+filter
+final
+find
+fine
+finger
+finish
+fire
+firm
+first
+fiscal
+fish
+fit
+fitness
+fix
+flag
+flame
+flash
+flat
+flavor
+flee
+flight
+flip
+float
+flock
+floor
+flower
+fluid
+flush
+fly
+foam
+focus
+fog
+foil
+fold
+follow
+food
+foot
+force
+forest
+forget
+fork
+fortune
+forum
+forward
+fossil
+foster
+found
+fox
+fragile
+frame
+frequent
+fresh
+friend
+fringe
+frog
+front
+frost
+frown
+frozen
+fruit
+fuel
+fun
+funny
+furnace
+fury
+future
+gadget
+gain
+galaxy
+gallery
+game
+gap
+garage
+garbage
+garden
+garlic
+garment
+gas
+gasp
+gate
+gather
+gauge
+gaze
+general
+genius
+genre
+gentle
+genuine
+gesture
+ghost
+giant
+gift
+giggle
+ginger
+giraffe
+girl
+give
+glad
+glance
+glare
+glass
+glide
+glimpse
+globe
+gloom
+glory
+glove
+glow
+glue
+goat
+goddess
+gold
+good
+goose
+gorilla
+gospel
+gossip
+govern
+gown
+grab
+grace
+grain
+grant
+grape
+grass
+gravity
+great
+green
+grid
+grief
+grit
+grocery
+group
+grow
+grunt
+guard
+guess
+guide
+guilt
+guitar
+gun
+gym
+habit
+hair
+half
+hammer
+hamster
+hand
+happy
+harbor
+hard
+harsh
+harvest
+hat
+have
+hawk
+hazard
+head
+health
+heart
+heavy
+hedgehog
+height
+hello
+helmet
+help
+hen
+hero
+hidden
+high
+hill
+hint
+hip
+hire
+history
+hobby
+hockey
+hold
+hole
+holiday
+hollow
+home
+honey
+hood
+hope
+horn
+horror
+horse
+hospital
+host
+hotel
+hour
+hover
+hub
+huge
+human
+humble
+humor
+hundred
+hungry
+hunt
+hurdle
+hurry
+hurt
+husband
+hybrid
+ice
+icon
+idea
+identify
+idle
+ignore
+ill
+illegal
+illness
+image
+imitate
+immense
+immune
+impact
+impose
+improve
+impulse
+inch
+include
+income
+increase
+index
+indicate
+indoor
+industry
+infant
+inflict
+inform
+inhale
+inherit
+initial
+inject
+injury
+inmate
+inner
+innocent
+input
+inquiry
+insane
+insect
+inside
+inspire
+install
+intact
+interest
+into
+invest
+invite
+involve
+iron
+island
+isolate
+issue
+item
+ivory
+jacket
+jaguar
+jar
+jazz
+jealous
+jeans
+jelly
+jewel
+job
+join
+joke
+journey
+joy
+judge
+juice
+jump
+jungle
+junior
+junk
+just
+kangaroo
+keen
+keep
+ketchup
+key
+kick
+kid
+kidney
+kind
+kingdom
+kiss
+kit
+kitchen
+kite
+kitten
+kiwi
+knee
+knife
+knock
+know
+lab
+label
+labor
+ladder
+lady
+lake
+lamp
+language
+laptop
+large
+later
+latin
+laugh
+laundry
+lava
+law
+lawn
+lawsuit
+layer
+lazy
+leader
+leaf
+learn
+leave
+lecture
+left
+leg
+legal
+legend
+leisure
+lemon
+lend
+length
+lens
+leopard
+lesson
+letter
+level
+liar
+liberty
+library
+license
+life
+lift
+light
+like
+limb
+limit
+link
+lion
+liquid
+list
+little
+live
+lizard
+load
+loan
+lobster
+local
+lock
+logic
+lonely
+long
+loop
+lottery
+loud
+lounge
+love
+loyal
+lucky
+luggage
+lumber
+lunar
+lunch
+luxury
+lyrics
+machine
+mad
+magic
+magnet
+maid
+mail
+main
+major
+make
+mammal
+man
+manage
+mandate
+mango
+mansion
+manual
+maple
+marble
+march
+margin
+marine
+market
+marriage
+mask
+mass
+master
+match
+material
+math
+matrix
+matter
+maximum
+maze
+meadow
+mean
+measure
+meat
+mechanic
+medal
+media
+melody
+melt
+member
+memory
+mention
+menu
+mercy
+merge
+merit
+merry
+mesh
+message
+metal
+method
+middle
+midnight
+milk
+million
+mimic
+mind
+minimum
+minor
+minute
+miracle
+mirror
+misery
+miss
+mistake
+mix
+mixed
+mixture
+mobile
+model
+modify
+mom
+moment
+monitor
+monkey
+monster
+month
+moon
+moral
+more
+morning
+mosquito
+mother
+motion
+motor
+mountain
+mouse
+move
+movie
+much
+muffin
+mule
+multiply
+muscle
+museum
+mushroom
+music
+must
+mutual
+myself
+mystery
+myth
+naive
+name
+napkin
+narrow
+nasty
+nation
+nature
+near
+neck
+need
+negative
+neglect
+neither
+nephew
+nerve
+nest
+net
+network
+neutral
+never
+news
+next
+nice
+night
+noble
+noise
+nominee
+noodle
+normal
+north
+nose
+notable
+note
+nothing
+notice
+novel
+now
+nuclear
+number
+nurse
+nut
+oak
+obey
+object
+oblige
+obscure
+observe
+obtain
+obvious
+occur
+ocean
+october
+odor
+off
+offer
+office
+often
+oil
+okay
+old
+olive
+olympic
+omit
+once
+one
+onion
+online
+only
+open
+opera
+opinion
+oppose
+option
+orange
+orbit
+orchard
+order
+ordinary
+organ
+orient
+original
+orphan
+ostrich
+other
+outdoor
+outer
+output
+outside
+oval
+oven
+over
+own
+owner
+oxygen
+oyster
+ozone
+pact
+paddle
+page
+pair
+palace
+palm
+panda
+panel
+panic
+panther
+paper
+parade
+parent
+park
+parrot
+party
+pass
+patch
+path
+patient
+patrol
+pattern
+pause
+pave
+payment
+peace
+peanut
+pear
+peasant
+pelican
+pen
+penalty
+pencil
+people
+pepper
+perfect
+permit
+person
+pet
+phone
+photo
+phrase
+physical
+piano
+picnic
+picture
+piece
+pig
+pigeon
+pill
+pilot
+pink
+pioneer
+pipe
+pistol
+pitch
+pizza
+place
+planet
+plastic
+plate
+play
+please
+pledge
+pluck
+plug
+plunge
+poem
+poet
+point
+polar
+pole
+police
+pond
+pony
+pool
+popular
+portion
+position
+possible
+post
+potato
+pottery
+poverty
+powder
+power
+practice
+praise
+predict
+prefer
+prepare
+present
+pretty
+prevent
+price
+pride
+primary
+print
+priority
+prison
+private
+prize
+problem
+process
+produce
+profit
+program
+project
+promote
+proof
+property
+prosper
+protect
+proud
+provide
+public
+pudding
+pull
+pulp
+pulse
+pumpkin
+punch
+pupil
+puppy
+purchase
+purity
+purpose
+purse
+push
+put
+puzzle
+pyramid
+quality
+quantum
+quarter
+question
+quick
+quit
+quiz
+quote
+rabbit
+raccoon
+race
+rack
+radar
+radio
+rail
+rain
+raise
+rally
+ramp
+ranch
+random
+range
+rapid
+rare
+rate
+rather
+raven
+raw
+razor
+ready
+real
+reason
+rebel
+rebuild
+recall
+receive
+recipe
+record
+recycle
+reduce
+reflect
+reform
+refuse
+region
+regret
+regular
+reject
+relax
+release
+relief
+rely
+remain
+remember
+remind
+remove
+render
+renew
+rent
+reopen
+repair
+repeat
+replace
+report
+require
+rescue
+resemble
+resist
+resource
+response
+result
+retire
+retreat
+return
+reunion
+reveal
+review
+reward
+rhythm
+rib
+ribbon
+rice
+rich
+ride
+ridge
+rifle
+right
+rigid
+ring
+riot
+ripple
+risk
+ritual
+rival
+river
+road
+roast
+robot
+robust
+rocket
+romance
+roof
+rookie
+room
+rose
+rotate
+rough
+round
+route
+royal
+rubber
+rude
+rug
+rule
+run
+runway
+rural
+sad
+saddle
+sadness
+safe
+sail
+salad
+salmon
+salon
+salt
+salute
+same
+sample
+sand
+satisfy
+satoshi
+sauce
+sausage
+save
+say
+scale
+scan
+scare
+scatter
+scene
+scheme
+school
+science
+scissors
+scorpion
+scout
+scrap
+screen
+script
+scrub
+sea
+search
+season
+seat
+second
+secret
+section
+security
+seed
+seek
+segment
+select
+sell
+seminar
+senior
+sense
+sentence
+series
+service
+session
+settle
+setup
+seven
+shadow
+shaft
+shallow
+share
+shed
+shell
+sheriff
+shield
+shift
+shine
+ship
+shiver
+shock
+shoe
+shoot
+shop
+short
+shoulder
+shove
+shrimp
+shrug
+shuffle
+shy
+sibling
+sick
+side
+siege
+sight
+sign
+silent
+silk
+silly
+silver
+similar
+simple
+since
+sing
+siren
+sister
+situate
+six
+size
+skate
+sketch
+ski
+skill
+skin
+skirt
+skull
+slab
+slam
+sleep
+slender
+slice
+slide
+slight
+slim
+slogan
+slot
+slow
+slush
+small
+smart
+smile
+smoke
+smooth
+snack
+snake
+snap
+sniff
+snow
+soap
+soccer
+social
+sock
+soda
+soft
+solar
+soldier
+solid
+solution
+solve
+someone
+song
+soon
+sorry
+sort
+soul
+sound
+soup
+source
+south
+space
+spare
+spatial
+spawn
+speak
+special
+speed
+spell
+spend
+sphere
+spice
+spider
+spike
+spin
+spirit
+split
+spoil
+sponsor
+spoon
+sport
+spot
+spray
+spread
+spring
+spy
+square
+squeeze
+squirrel
+stable
+stadium
+staff
+stage
+stairs
+stamp
+stand
+start
+state
+stay
+steak
+steel
+stem
+step
+stereo
+stick
+still
+sting
+stock
+stomach
+stone
+stool
+story
+stove
+strategy
+street
+strike
+strong
+struggle
+student
+stuff
+stumble
+style
+subject
+submit
+subway
+success
+such
+sudden
+suffer
+sugar
+suggest
+suit
+summer
+sun
+sunny
+sunset
+super
+supply
+supreme
+sure
+surface
+surge
+surprise
+surround
+survey
+suspect
+sustain
+swallow
+swamp
+swap
+swarm
+swear
+sweet
+swift
+swim
+swing
+switch
+sword
+symbol
+symptom
+syrup
+system
+table
+tackle
+tag
+tail
+talent
+talk
+tank
+tape
+target
+task
+taste
+tattoo
+taxi
+teach
+team
+tell
+ten
+tenant
+tennis
+tent
+term
+test
+text
+thank
+that
+theme
+then
+theory
+there
+they
+thing
+this
+thought
+three
+thrive
+throw
+thumb
+thunder
+ticket
+tide
+tiger
+tilt
+timber
+time
+tiny
+tip
+tired
+tissue
+title
+toast
+tobacco
+today
+toddler
+toe
+together
+toilet
+token
+tomato
+tomorrow
+tone
+tongue
+tonight
+tool
+tooth
+top
+topic
+topple
+torch
+tornado
+tortoise
+toss
+total
+tourist
+toward
+tower
+town
+toy
+track
+trade
+traffic
+tragic
+train
+transfer
+trap
+trash
+travel
+tray
+treat
+tree
+trend
+trial
+tribe
+trick
+trigger
+trim
+trip
+trophy
+trouble
+truck
+true
+truly
+trumpet
+trust
+truth
+try
+tube
+tuition
+tumble
+tuna
+tunnel
+turkey
+turn
+turtle
+twelve
+twenty
+twice
+twin
+twist
+two
+type
+typical
+ugly
+umbrella
+unable
+unaware
+uncle
+uncover
+under
+undo
+unfair
+unfold
+unhappy
+uniform
+unique
+unit
+universe
+unknown
+unlock
+until
+unusual
+unveil
+update
+upgrade
+uphold
+upon
+upper
+upset
+urban
+urge
+usage
+use
+used
+useful
+useless
+usual
+utility
+vacant
+vacuum
+vague
+valid
+valley
+valve
+van
+vanish
+vapor
+various
+vast
+vault
+vehicle
+velvet
+vendor
+venture
+venue
+verb
+verify
+version
+very
+vessel
+veteran
+viable
+vibrant
+vicious
+victory
+video
+view
+village
+vintage
+violin
+virtual
+virus
+visa
+visit
+visual
+vital
+vivid
+vocal
+voice
+void
+volcano
+volume
+vote
+voyage
+wage
+wagon
+wait
+walk
+wall
+walnut
+want
+warfare
+warm
+warrior
+wash
+wasp
+waste
+water
+wave
+way
+wealth
+weapon
+wear
+weasel
+weather
+web
+wedding
+weekend
+weird
+welcome
+west
+wet
+whale
+what
+wheat
+wheel
+when
+where
+whip
+whisper
+wide
+width
+wife
+wild
+will
+win
+window
+wine
+wing
+wink
+winner
+winter
+wire
+wisdom
+wise
+wish
+witness
+wolf
+woman
+wonder
+wood
+wool
+word
+work
+world
+worry
+worth
+wrap
+wreck
+wrestle
+wrist
+write
+wrong
+yard
+year
+yellow
+you
+young
+youth
+zebra
+zero
+zone
+zoo`.split("\n");
+
+// ../wallet-engine/src/errors.ts
+var WalletNotConnectedError = class extends Error {
+  constructor(message = "No wallet connected. Call awarizon.wallet.create(), awarizon.wallet.importPrivateKey(), awarizon.wallet.importMnemonic(), or awarizon.connectWallet(walletClient).") {
+    super(`[wallet-engine] ${message}`);
+    this.code = "WALLET_NOT_CONNECTED";
+    this.name = "WalletNotConnectedError";
+  }
+};
+var InvalidMnemonicError = class extends Error {
+  constructor(message = "The provided mnemonic phrase is invalid.") {
+    super(`[wallet-engine] ${message}`);
+    this.code = "INVALID_MNEMONIC";
+    this.name = "InvalidMnemonicError";
+  }
+};
+var InvalidPrivateKeyError = class extends Error {
+  constructor(message = "The provided private key is invalid.") {
+    super(`[wallet-engine] ${message}`);
+    this.code = "INVALID_PRIVATE_KEY";
+    this.name = "InvalidPrivateKeyError";
+  }
+};
+var ChainSwitchError = class extends Error {
+  constructor(message) {
+    super(`[wallet-engine] ${message}`);
+    this.code = "CHAIN_SWITCH_ERROR";
+    this.name = "ChainSwitchError";
+  }
+};
+var ChainMismatchError = class extends Error {
+  constructor(walletChainId, expectedChainId) {
+    super(
+      `[wallet-engine] Chain mismatch: wallet is on chain ${walletChainId}, SDK is configured for chain ${expectedChainId}. Switch networks in your wallet or call awarizon.switchChain().`
+    );
+    this.code = "CHAIN_MISMATCH";
+    this.name = "ChainMismatchError";
+    this.walletChainId = walletChainId;
+    this.expectedChainId = expectedChainId;
+  }
+};
+
+// ../wallet-engine/src/wallet.ts
+var ETH_PATH = (addressIndex) => `m/44'/60'/0'/0/${addressIndex}`;
+var WalletEngine = class {
+  constructor(config) {
+    this.internalClient = null;
+    this.externalClient = null;
+    this._connectorInfo = null;
+    this._walletListeners = /* @__PURE__ */ new Set();
+    this._chainListeners = /* @__PURE__ */ new Set();
+    this.config = config;
+  }
+  // ─── Internal wallet creation ──────────────────────────────────────────────
+  async create() {
+    const mnemonic = generateMnemonic(wordlist, 128);
+    const path = ETH_PATH(0);
+    const account = accounts.mnemonicToAccount(mnemonic, { accountIndex: 0, addressIndex: 0 });
+    this.internalClient = this._buildInternalClient(account);
+    this._connectorInfo = { type: "internal" };
+    this._emitWalletChange();
+    return { address: account.address, mnemonic, derivationPath: path };
+  }
+  /**
+   * Import a wallet from a BIP-39 mnemonic phrase.
+   *
+   * `addressIndex` maps to MetaMask's account switcher:
+   *   0 → Account 1  (m/44'/60'/0'/0/0)
+   *   1 → Account 2  (m/44'/60'/0'/0/1)
+   *   N → Account N+1
+   */
+  async importMnemonic(mnemonic, addressIndex = 0) {
+    if (!mnemonic || typeof mnemonic !== "string") throw new InvalidMnemonicError();
+    if (!validateMnemonic(mnemonic, wordlist)) {
+      throw new InvalidMnemonicError(
+        `Invalid BIP-39 mnemonic: ${mnemonic.split(" ").slice(0, 2).join(" ")}\u2026`
+      );
+    }
+    let account;
+    try {
+      account = accounts.mnemonicToAccount(mnemonic, { accountIndex: 0, addressIndex });
+    } catch {
+      throw new InvalidMnemonicError(
+        `Could not derive account from mnemonic: ${mnemonic.slice(0, 8)}\u2026`
+      );
+    }
+    this.internalClient = this._buildInternalClient(account);
+    this._connectorInfo = { type: "internal" };
+    this._emitWalletChange();
+    const path = ETH_PATH(addressIndex);
+    return { address: account.address, mnemonic, derivationPath: path };
+  }
+  async importPrivateKey(privateKey) {
+    if (!privateKey || !privateKey.startsWith("0x")) {
+      throw new InvalidPrivateKeyError("Private key must be a 0x-prefixed hex string.");
+    }
+    let account;
+    try {
+      account = accounts.privateKeyToAccount(privateKey);
+    } catch {
+      throw new InvalidPrivateKeyError();
+    }
+    this.internalClient = this._buildInternalClient(account);
+    this._connectorInfo = { type: "internal" };
+    this._emitWalletChange();
+    return { address: account.address };
+  }
+  // ─── External wallet integration ───────────────────────────────────────────
+  /**
+   * Connect any viem WalletClient (wagmi, RainbowKit, custom).
+   * Optionally pass connector metadata to display in the UI.
+   *
+   * External wallets always take priority over internal wallets.
+   */
+  connectExternal(walletClient, info) {
+    if (!walletClient || typeof walletClient !== "object") {
+      throw new TypeError("[wallet-engine] connectExternal: expected a viem WalletClient");
+    }
+    this.externalClient = walletClient;
+    this._connectorInfo = { type: "external", ...info };
+    this._emitWalletChange();
+  }
+  /**
+   * Connect directly from a raw EIP-1193 provider (window.ethereum, WalletConnect, etc.)
+   * without needing wagmi or any wrapper. Calls eth_requestAccounts internally.
+   *
+   * @param provider - Any object implementing the EIP-1193 interface
+   * @param info     - Optional connector metadata (name, icon)
+   */
+  async connectEIP1193(provider, info) {
+    const accounts = await provider.request({
+      method: "eth_requestAccounts"
+    });
+    const account = accounts[0];
+    if (!account) {
+      throw new WalletNotConnectedError(
+        "No accounts returned by EIP-1193 provider. The user may have rejected the connection request."
+      );
+    }
+    const walletClient = viem.createWalletClient({
+      account,
+      chain: this.config.chain,
+      transport: viem.custom(provider)
+    });
+    this.connectExternal(walletClient, info);
+    provider.on?.("accountsChanged", (...args) => {
+      const newAccounts = args[0];
+      if (!newAccounts || newAccounts.length === 0) {
+        this.disconnectExternal();
+        return;
+      }
+      const updated = viem.createWalletClient({
+        account: newAccounts[0],
+        chain: this.config.chain,
+        transport: viem.custom(provider)
+      });
+      this.connectExternal(updated, info);
+    });
+    provider.on?.("chainChanged", (..._args) => {
+      this._emitChainChange();
+    });
+    provider.on?.("disconnect", (..._args) => {
+      this.disconnectExternal();
+    });
+  }
+  /** Remove the external wallet. Falls back to internal wallet if one is loaded. */
+  disconnectExternal() {
+    this.externalClient = null;
+    this._connectorInfo = this.internalClient ? { type: "internal" } : null;
+    this._emitWalletChange();
+  }
+  /** Remove all wallet state — both internal and external. */
+  disconnect() {
+    this.internalClient = null;
+    this.externalClient = null;
+    this._connectorInfo = null;
+    this._emitWalletChange();
+  }
+  // ─── Chain management ──────────────────────────────────────────────────────
+  async switchChain(chain2) {
+    this.config.chain = chain2;
+    this.config.publicClient = viem.createPublicClient({
+      chain: chain2,
+      transport: this._resolveTransport(chain2)
+    });
+    if (this.internalClient?.account) {
+      this.internalClient = this._buildInternalClient(this.internalClient.account);
+    }
+    this._emitChainChange();
+  }
+  // ─── Signing ───────────────────────────────────────────────────────────────
+  /**
+   * Sign a plain text or raw-bytes message with the active wallet.
+   * Supports Sign-In with Ethereum (SIWE) and off-chain auth flows.
+   *
+   * @param message - A UTF-8 string or `{ raw: Hex | Uint8Array }` for raw bytes
+   */
+  async signMessage(message) {
+    const client = this.externalClient ?? this.internalClient;
+    if (!client) throw new WalletNotConnectedError();
+    const account = client.account;
+    if (!account) {
+      throw new WalletNotConnectedError(
+        "No account set on wallet client. The wallet may need to be unlocked or reconnected."
+      );
+    }
+    return client.signMessage({
+      account,
+      message
+    });
+  }
+  /**
+   * Sign EIP-712 typed structured data (permit2, SIWE, Seaport, etc.).
+   *
+   * @param params - domain, types, primaryType, and message fields per EIP-712
+   */
+  async signTypedData(params) {
+    const client = this.externalClient ?? this.internalClient;
+    if (!client) throw new WalletNotConnectedError();
+    const account = client.account;
+    if (!account) {
+      throw new WalletNotConnectedError(
+        "No account set on wallet client. The wallet may need to be unlocked or reconnected."
+      );
+    }
+    return client.signTypedData({
+      account,
+      ...params
+    });
+  }
+  // ─── Chain awareness ───────────────────────────────────────────────────────
+  /**
+   * Returns the chain ID the active wallet is currently on.
+   * For external wallets this queries the wallet directly (may differ from SDK config).
+   * For internal wallets this always returns the SDK-configured chain ID.
+   */
+  async getChainId() {
+    if (this.externalClient) {
+      try {
+        return await this.externalClient.getChainId();
+      } catch {
+        return this.config.chain.id;
+      }
+    }
+    return this.config.chain.id;
+  }
+  /**
+   * Returns true if the external wallet is on a different chain than the SDK.
+   * Always false for internal wallets (they follow the SDK chain automatically).
+   */
+  async isChainMismatch() {
+    if (!this.externalClient) return false;
+    const activeChainId = await this.getChainId();
+    return activeChainId !== this.config.chain.id;
+  }
+  // ─── Event listeners ───────────────────────────────────────────────────────
+  /**
+   * Subscribe to wallet changes (connect, disconnect, account switch).
+   * Returns an unsubscribe function — call it to stop listening.
+   *
+   * @example
+   * const unsub = engine.onWalletChange(({ address, type }) => {
+   *   console.log('wallet changed:', address, type)
+   * })
+   * unsub() // stop listening
+   */
+  onWalletChange(cb) {
+    this._walletListeners.add(cb);
+    return () => this._walletListeners.delete(cb);
+  }
+  /**
+   * Subscribe to chain changes (switchChain calls).
+   * Returns an unsubscribe function — call it to stop listening.
+   */
+  onChainChange(cb) {
+    this._chainListeners.add(cb);
+    return () => this._chainListeners.delete(cb);
+  }
+  // ─── Accessors ─────────────────────────────────────────────────────────────
+  getWalletClient() {
+    const client = this.externalClient ?? this.internalClient;
+    if (!client) throw new WalletNotConnectedError();
+    return client;
+  }
+  getSigner() {
+    return this.getWalletClient();
+  }
+  address() {
+    const client = this.externalClient ?? this.internalClient;
+    const addr = client?.account?.address;
+    if (!addr) throw new WalletNotConnectedError();
+    return addr;
+  }
+  getChain() {
+    return this.config.chain;
+  }
+  getPublicClient() {
+    return this.config.publicClient;
+  }
+  isConnected() {
+    return !!(this.externalClient ?? this.internalClient);
+  }
+  hasExternalWallet() {
+    return this.externalClient !== null;
+  }
+  hasInternalWallet() {
+    return this.internalClient !== null;
+  }
+  /**
+   * Returns metadata about the currently active connector.
+   * Useful for displaying "Connected via MetaMask" in the UI.
+   */
+  getConnectorInfo() {
+    if (this._connectorInfo) return this._connectorInfo;
+    if (this.externalClient) return { type: "external" };
+    if (this.internalClient) return { type: "internal" };
+    return { type: "none" };
+  }
+  // ─── Private helpers ───────────────────────────────────────────────────────
+  _resolveTransport(chain2) {
+    return this.config.getTransport ? this.config.getTransport(chain2) : viem.http(this.config.rpcUrl);
+  }
+  _buildInternalClient(account) {
+    return viem.createWalletClient({
+      account,
+      chain: this.config.chain,
+      transport: this._resolveTransport(this.config.chain)
+    });
+  }
+  _emitWalletChange() {
+    let addr = null;
+    try {
+      addr = this.address();
+    } catch {
+    }
+    const event = {
+      address: addr,
+      type: this.externalClient ? "external" : this.internalClient ? "internal" : "none",
+      name: this._connectorInfo?.name
+    };
+    this._walletListeners.forEach((cb) => {
+      try {
+        cb(event);
+      } catch {
+      }
+    });
+  }
+  _emitChainChange() {
+    const event = {
+      chainId: this.config.chain.id,
+      chain: this.config.chain
+    };
+    this._chainListeners.forEach((cb) => {
+      try {
+        cb(event);
+      } catch {
+      }
+    });
+  }
+};
+
+// ../tx-engine/src/errors.ts
+var ContractExecutionError = class extends Error {
+  constructor(message, options) {
+    super(`[tx-engine] ${message}`);
+    this.code = "CONTRACT_EXECUTION_ERROR";
+    this.name = "ContractExecutionError";
+    this.functionName = options?.functionName;
+    this.cause = options?.cause;
+  }
+};
+var SimulationError = class extends Error {
+  constructor(message, options) {
+    super(`[tx-engine] Simulation failed: ${message}`);
+    this.code = "SIMULATION_ERROR";
+    this.name = "SimulationError";
+    this.functionName = options?.functionName;
+    this.cause = options?.cause;
+  }
+};
+var GasEstimationError = class extends Error {
+  constructor(message, cause) {
+    super(`[tx-engine] Gas estimation failed: ${message}`);
+    this.code = "GAS_ESTIMATION_ERROR";
+    this.name = "GasEstimationError";
+    this.cause = cause;
+  }
+};
+var TransactionTimeoutError = class extends Error {
+  constructor(hash) {
+    super(`[tx-engine] Transaction confirmation timed out${hash ? ` (hash: ${hash})` : ""}`);
+    this.code = "TRANSACTION_TIMEOUT";
+    this.name = "TransactionTimeoutError";
+    this.hash = hash;
+  }
+};
+
+// ../tx-engine/src/transaction.ts
+function extractRevertReason(error) {
+  if (!error || typeof error !== "object") return String(error);
+  const e = error;
+  if (typeof e["reason"] === "string" && e["reason"]) return e["reason"];
+  if (e["data"] && typeof e["data"] === "object") {
+    const data = e["data"];
+    if (typeof data["errorName"] === "string" && data["errorName"]) {
+      const args = Array.isArray(data["args"]) && data["args"].length ? `(${data["args"].join(", ")})` : "";
+      return `${data["errorName"]}${args}`;
+    }
+  }
+  if (typeof e["shortMessage"] === "string" && e["shortMessage"]) return e["shortMessage"];
+  if (e["cause"]) return extractRevertReason(e["cause"]);
+  return error.message ?? String(error);
+}
+var TransactionEngine = class {
+  constructor(publicClient, getWalletClient) {
+    this.publicClient = publicClient;
+    this.getWalletClient = getWalletClient;
+  }
+  // ─── Read ─────────────────────────────────────────────────────────────────
+  /**
+   * Execute a read-only contract call (view / pure functions).
+   * Returns the decoded output — single values or tuples.
+   */
+  async read(params) {
+    try {
+      return await this.publicClient.readContract({
+        address: params.address,
+        abi: params.abi,
+        functionName: params.functionName,
+        args: params.args
+      });
+    } catch (error) {
+      throw new ContractExecutionError(
+        `read(${params.functionName}) failed: ${extractRevertReason(error)}`,
+        { functionName: params.functionName, cause: error }
+      );
+    }
+  }
+  // ─── Write ────────────────────────────────────────────────────────────────
+  /**
+   * Execute a state-mutating contract call:
+   *   1. Simulate the transaction (surfaces revert reasons before spending gas)
+   *   2. Broadcast the signed transaction
+   *   3. Wait for on-chain confirmation
+   *
+   * @returns { hash, receipt } — the tx hash and on-chain receipt
+   */
+  async write(params) {
+    const walletClient = this.getWalletClient();
+    const account = walletClient.account;
+    if (!account) {
+      throw new ContractExecutionError(
+        `write(${params.functionName}): wallet client has no account attached`,
+        { functionName: params.functionName }
+      );
+    }
+    let request;
+    try {
+      const simulation = await this.publicClient.simulateContract({
+        address: params.address,
+        abi: params.abi,
+        functionName: params.functionName,
+        args: params.args,
+        account,
+        value: params.value,
+        gas: params.gas
+      });
+      request = simulation.request;
+    } catch (error) {
+      throw new SimulationError(
+        `${params.functionName}: ${extractRevertReason(error)}`,
+        { functionName: params.functionName, cause: error }
+      );
+    }
+    let hash;
+    try {
+      hash = await walletClient.writeContract(request);
+    } catch (error) {
+      throw new ContractExecutionError(
+        `write(${params.functionName}) broadcast failed: ${error.message}`,
+        { functionName: params.functionName, cause: error }
+      );
+    }
+    let receipt;
+    try {
+      receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+    } catch (error) {
+      throw new ContractExecutionError(
+        `write(${params.functionName}) receipt wait failed: ${error.message}`,
+        { functionName: params.functionName, cause: error }
+      );
+    }
+    return { hash, receipt };
+  }
+  // ─── Gas estimation ───────────────────────────────────────────────────────
+  /**
+   * Estimate gas for a write transaction.
+   * Useful for displaying fee previews before the user confirms.
+   */
+  async estimateGas(params) {
+    const walletClient = this.getWalletClient();
+    const account = walletClient.account;
+    if (!account) {
+      throw new GasEstimationError("Wallet client has no account attached");
+    }
+    try {
+      const gas = await this.publicClient.estimateContractGas({
+        address: params.address,
+        abi: params.abi,
+        functionName: params.functionName,
+        args: params.args,
+        account,
+        value: params.value
+      });
+      let gasCost;
+      try {
+        const gasPrice = await this.publicClient.getGasPrice();
+        gasCost = gas * gasPrice;
+      } catch {
+      }
+      return { gas, gasCost };
+    } catch (error) {
+      throw new GasEstimationError(extractRevertReason(error), error);
+    }
+  }
+};
 var CHAINS = {
   // Mainnet
   mainnet: chains.mainnet,
@@ -58,21 +3322,21 @@ var CHAINS = {
   moonbeam: chains.moonbeam
 };
 var _chainAliases = Object.keys(CHAINS).sort().join(", ");
-function resolveChain(chain) {
-  if (typeof chain === "object" && "id" in chain) {
-    return chain;
+function resolveChain(chain2) {
+  if (typeof chain2 === "object" && "id" in chain2) {
+    return chain2;
   }
-  if (typeof chain === "string") {
-    const resolved = CHAINS[chain.toLowerCase()] ?? CHAINS[chain];
+  if (typeof chain2 === "string") {
+    const resolved = CHAINS[chain2.toLowerCase()] ?? CHAINS[chain2];
     if (!resolved) {
       throw new Error(
-        `[awarizon/web3] Unsupported chain: "${chain}".
+        `[awarizon/web3] Unsupported chain: "${chain2}".
 Available chains: ${_chainAliases}`
       );
     }
     return resolved;
   }
-  throw new TypeError(`[awarizon/web3] chain must be a string or Chain object, got: ${typeof chain}`);
+  throw new TypeError(`[awarizon/web3] chain must be a string or Chain object, got: ${typeof chain2}`);
 }
 function getSupportedChainIds() {
   const seen = /* @__PURE__ */ new Set();
@@ -94,67 +3358,179 @@ var FALLBACK_RPCS = {
   1284: "https://moonbeam.drpc.org"
   // moonbeam
 };
-function getChainTransport(chain, rpcUrlOverride) {
+function getChainTransport(chain2, rpcUrlOverride) {
   if (rpcUrlOverride) return viem.http(rpcUrlOverride);
-  const fallbackUrl = FALLBACK_RPCS[chain.id];
+  const fallbackUrl = FALLBACK_RPCS[chain2.id];
   if (fallbackUrl) {
-    const primaryUrl = chain.rpcUrls.default.http[0];
+    const primaryUrl = chain2.rpcUrls.default.http[0];
     return viem.fallback([viem.http(primaryUrl), viem.http(fallbackUrl)]);
   }
   return viem.http();
 }
-function trackEvent(telemetry, type, chain, functionName, success, start) {
+
+// ../abi-engine/src/errors.ts
+var InvalidABIError = class extends Error {
+  constructor(message) {
+    super(`[abi-engine] ${message}`);
+    this.code = "INVALID_ABI";
+    this.name = "InvalidABIError";
+  }
+};
+var UnsupportedABIItemError = class extends Error {
+  constructor(itemType) {
+    super(`[abi-engine] Unsupported ABI item type: "${itemType}"`);
+    this.code = "UNSUPPORTED_ABI_ITEM";
+    this.name = "UnsupportedABIItemError";
+    this.itemType = itemType;
+  }
+};
+var DuplicateFunctionError = class extends Error {
+  constructor(name) {
+    super(`[abi-engine] Duplicate function name detected: "${name}". Function overloads are not yet supported.`);
+    this.code = "DUPLICATE_FUNCTION";
+    this.name = "DuplicateFunctionError";
+    this.functionName = name;
+  }
+};
+
+// ../abi-engine/src/parser.ts
+var _parseCache = /* @__PURE__ */ new WeakMap();
+function parseABI(abi) {
+  const hit = _parseCache.get(abi);
+  if (hit) return hit;
+  if (!Array.isArray(abi) || abi.length === 0) {
+    throw new InvalidABIError("ABI must be a non-empty array");
+  }
+  const readFunctions = [];
+  const writeFunctions = [];
+  const payableFunctions = [];
+  const events = [];
+  let constructor;
+  for (const item of abi) {
+    if (!item || typeof item !== "object" || !("type" in item)) {
+      throw new InvalidABIError(`Invalid ABI item: ${JSON.stringify(item)}`);
+    }
+    switch (item.type) {
+      case "function": {
+        const fn = item;
+        const sm = fn.stateMutability;
+        if (sm === "view" || sm === "pure") {
+          readFunctions.push(fn);
+        } else if (sm === "payable") {
+          payableFunctions.push(fn);
+          writeFunctions.push(fn);
+        } else {
+          writeFunctions.push(fn);
+        }
+        break;
+      }
+      case "event":
+        events.push(item);
+        break;
+      case "constructor":
+        constructor = item;
+        break;
+    }
+  }
+  const result = { readFunctions, writeFunctions, payableFunctions, events, constructor };
+  _parseCache.set(abi, result);
+  return result;
+}
+function isWriteFunction(fn) {
+  return fn.stateMutability !== "view" && fn.stateMutability !== "pure";
+}
+function isPayableFunction(fn) {
+  return fn.stateMutability === "payable";
+}
+function solidityTypeToTS(abiType) {
+  if (abiType.endsWith("[]")) return `${solidityTypeToTS(abiType.slice(0, -2))}[]`;
+  if (abiType.startsWith("uint") || abiType.startsWith("int")) return "bigint";
+  if (abiType === "address") return "`0x${string}`";
+  if (abiType === "bool") return "boolean";
+  if (abiType.startsWith("bytes")) return "`0x${string}`";
+  if (abiType === "string") return "string";
+  if (abiType === "tuple") return "Record<string, unknown>";
+  return "unknown";
+}
+function generateMethodSignature(fn) {
+  const sm = fn.stateMutability;
+  const kind = sm === "view" || sm === "pure" ? "read" : sm === "payable" ? "payable" : "write";
+  const params = (fn.inputs ?? []).map((p, i) => ({
+    name: p.name || `arg${i}`,
+    type: solidityTypeToTS(p.type)
+  }));
+  const paramStr = params.map((p) => `${p.name}: ${p.type}`).join(", ");
+  let returnType;
+  const outputs = fn.outputs ?? [];
+  if (outputs.length === 0) {
+    returnType = kind === "read" ? "void" : "TransactionResult";
+  } else if (outputs.length === 1) {
+    returnType = solidityTypeToTS(outputs[0].type);
+  } else {
+    returnType = `[${outputs.map((o) => solidityTypeToTS(o.type)).join(", ")}]`;
+  }
+  const asyncReturn = kind === "read" ? `Promise<${returnType}>` : "Promise<TransactionResult>";
+  const signature = `${fn.name}(${paramStr}): ${asyncReturn}`;
+  return { name: fn.name, kind, signature, params };
+}
+function generateAllMethodSignatures(parsed) {
+  const all = [...parsed.readFunctions, ...parsed.writeFunctions];
+  return all.map(generateMethodSignature);
+}
+
+// src/contract.ts
+function trackEvent(telemetry, type, chain2, functionName, success, start) {
   telemetry?.track({
     type,
-    chain: chain?.name ?? "unknown",
-    chainId: chain?.id ?? 0,
+    chain: chain2?.name ?? "unknown",
+    chainId: chain2?.id ?? 0,
     functionName,
     success,
     durationMs: Date.now() - start,
     ts: Date.now()
   });
 }
-function buildContractInstance(address, abi, publicClient, txEngine, telemetry, chain) {
-  const parsed = abiEngine.parseABI(abi);
+function buildContractInstance(address, abi, publicClient, txEngine, telemetry, chain2) {
+  const parsed = parseABI(abi);
   const eventsMap = new Map(parsed.events.map((e) => [e.name, e]));
   const instance = {
     _address: address,
     _abi: abi
   };
   for (const fn of parsed.readFunctions) {
-    instance[fn.name] = buildReadMethod(fn, address, abi, txEngine, telemetry, chain);
+    instance[fn.name] = buildReadMethod(fn, address, abi, txEngine, telemetry, chain2);
   }
   for (const fn of parsed.writeFunctions) {
-    instance[fn.name] = buildWriteMethod(fn, address, abi, txEngine, telemetry, chain);
+    instance[fn.name] = buildWriteMethod(fn, address, abi, txEngine, telemetry, chain2);
   }
   instance["on"] = buildEventSubscription(address, abi, eventsMap, publicClient);
   instance["estimateGas"] = async (method, ...args) => {
     const start = Date.now();
     try {
       const estimate = await txEngine.estimateGas({ address, abi, functionName: method, args });
-      trackEvent(telemetry, "contract.gas_estimate", chain, method, true, start);
+      trackEvent(telemetry, "contract.gas_estimate", chain2, method, true, start);
       return estimate.gas;
     } catch (error) {
-      trackEvent(telemetry, "contract.gas_estimate", chain, method, false, start);
+      trackEvent(telemetry, "contract.gas_estimate", chain2, method, false, start);
       throw error;
     }
   };
   return instance;
 }
-function buildReadMethod(fn, address, abi, txEngine, telemetry, chain) {
+function buildReadMethod(fn, address, abi, txEngine, telemetry, chain2) {
   return async (...args) => {
     const start = Date.now();
     try {
       const result = await txEngine.read({ address, abi, functionName: fn.name, args });
-      trackEvent(telemetry, "contract.read", chain, fn.name, true, start);
+      trackEvent(telemetry, "contract.read", chain2, fn.name, true, start);
       return result;
     } catch (error) {
-      trackEvent(telemetry, "contract.read", chain, fn.name, false, start);
+      trackEvent(telemetry, "contract.read", chain2, fn.name, false, start);
       throw error;
     }
   };
 }
-function buildWriteMethod(fn, address, abi, txEngine, telemetry, chain) {
+function buildWriteMethod(fn, address, abi, txEngine, telemetry, chain2) {
   const isPayable = fn.stateMutability === "payable";
   return async (...args) => {
     let callArgs = args;
@@ -178,10 +3554,10 @@ function buildWriteMethod(fn, address, abi, txEngine, telemetry, chain) {
         value,
         gas
       });
-      trackEvent(telemetry, "contract.write", chain, fn.name, true, start);
+      trackEvent(telemetry, "contract.write", chain2, fn.name, true, start);
       return result;
     } catch (error) {
-      trackEvent(telemetry, "contract.write", chain, fn.name, false, start);
+      trackEvent(telemetry, "contract.write", chain2, fn.name, false, start);
       throw error;
     }
   };
@@ -240,11 +3616,11 @@ var ContractNotLoadedError = class extends Error {
   }
 };
 var UnsupportedChainError = class extends Error {
-  constructor(chain) {
-    super(`[awarizon/web3] Unsupported chain: "${chain}". Pass a valid chain name or viem Chain object.`);
+  constructor(chain2) {
+    super(`[awarizon/web3] Unsupported chain: "${chain2}". Pass a valid chain name or viem Chain object.`);
     this.code = "UNSUPPORTED_CHAIN";
     this.name = "UnsupportedChainError";
-    this.chain = chain;
+    this.chain = chain2;
   }
 };
 var ApiKeyRequiredError = class extends Error {
@@ -715,6 +4091,8 @@ var ERC1155_ABI = [
   { type: "event", name: "TransferBatch", inputs: [{ indexed: true, name: "operator", type: "address" }, { indexed: true, name: "from", type: "address" }, { indexed: true, name: "to", type: "address" }, { name: "ids", type: "uint256[]" }, { name: "values", type: "uint256[]" }] },
   { type: "event", name: "ApprovalForAll", inputs: [{ indexed: true, name: "account", type: "address" }, { indexed: true, name: "operator", type: "address" }, { name: "approved", type: "bool" }] }
 ];
+
+// src/sdk.ts
 var WalletProxy = class {
   constructor(engine, ensureReady) {
     this.engine = engine;
@@ -764,8 +4142,8 @@ var WalletProxy = class {
   disconnect() {
     this.engine.disconnect();
   }
-  async switchChain(chain) {
-    return this.engine.switchChain(chain);
+  async switchChain(chain2) {
+    return this.engine.switchChain(chain2);
   }
   // ── Gated async — EIP-1193, signing, chain awareness ───────────────────────
   async connectEIP1193(provider, info) {
@@ -807,13 +4185,13 @@ var AwarizonWeb3 = class {
       chain: this.chain,
       transport: getChainTransport(this.chain, config.rpcUrl)
     });
-    this._engine = new walletEngine.WalletEngine({
+    this._engine = new WalletEngine({
       chain: this.chain,
       publicClient: this.publicClient,
       rpcUrl: config.rpcUrl,
-      getTransport: (chain) => getChainTransport(chain, config.rpcUrl)
+      getTransport: (chain2) => getChainTransport(chain2, config.rpcUrl)
     });
-    this._txEngine = new txEngine.TransactionEngine(
+    this._txEngine = new TransactionEngine(
       this.publicClient,
       () => this._engine.getWalletClient()
     );
@@ -924,9 +4302,9 @@ var AwarizonWeb3 = class {
     this._engine.disconnectExternal();
     return this;
   }
-  async switchChain(chain) {
+  async switchChain(chain2) {
     await this._telemetry.ensureValidated();
-    const resolved = resolveChain(chain);
+    const resolved = resolveChain(chain2);
     await this._engine.switchChain(resolved);
     this._contractCache.clear();
     return this;
@@ -1301,100 +4679,54 @@ Currently registered: ${registered}`
     await this._telemetry.destroy();
   }
 };
+/*! Bundled license information:
+
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@scure/base/lib/esm/index.js:
+  (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@scure/bip39/esm/index.js:
+  (*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) *)
+*/
 
-Object.defineProperty(exports, "ChainMismatchError", {
-  enumerable: true,
-  get: function () { return walletEngine.ChainMismatchError; }
-});
-Object.defineProperty(exports, "ChainSwitchError", {
-  enumerable: true,
-  get: function () { return walletEngine.ChainSwitchError; }
-});
-Object.defineProperty(exports, "InvalidMnemonicError", {
-  enumerable: true,
-  get: function () { return walletEngine.InvalidMnemonicError; }
-});
-Object.defineProperty(exports, "InvalidPrivateKeyError", {
-  enumerable: true,
-  get: function () { return walletEngine.InvalidPrivateKeyError; }
-});
-Object.defineProperty(exports, "WalletEngine", {
-  enumerable: true,
-  get: function () { return walletEngine.WalletEngine; }
-});
-Object.defineProperty(exports, "WalletNotConnectedError", {
-  enumerable: true,
-  get: function () { return walletEngine.WalletNotConnectedError; }
-});
-Object.defineProperty(exports, "ContractExecutionError", {
-  enumerable: true,
-  get: function () { return txEngine.ContractExecutionError; }
-});
-Object.defineProperty(exports, "GasEstimationError", {
-  enumerable: true,
-  get: function () { return txEngine.GasEstimationError; }
-});
-Object.defineProperty(exports, "SimulationError", {
-  enumerable: true,
-  get: function () { return txEngine.SimulationError; }
-});
-Object.defineProperty(exports, "TransactionEngine", {
-  enumerable: true,
-  get: function () { return txEngine.TransactionEngine; }
-});
-Object.defineProperty(exports, "TransactionTimeoutError", {
-  enumerable: true,
-  get: function () { return txEngine.TransactionTimeoutError; }
-});
-Object.defineProperty(exports, "DuplicateFunctionError", {
-  enumerable: true,
-  get: function () { return abiEngine.DuplicateFunctionError; }
-});
-Object.defineProperty(exports, "InvalidABIError", {
-  enumerable: true,
-  get: function () { return abiEngine.InvalidABIError; }
-});
-Object.defineProperty(exports, "UnsupportedABIItemError", {
-  enumerable: true,
-  get: function () { return abiEngine.UnsupportedABIItemError; }
-});
-Object.defineProperty(exports, "generateAllMethodSignatures", {
-  enumerable: true,
-  get: function () { return abiEngine.generateAllMethodSignatures; }
-});
-Object.defineProperty(exports, "generateMethodSignature", {
-  enumerable: true,
-  get: function () { return abiEngine.generateMethodSignature; }
-});
-Object.defineProperty(exports, "isPayableFunction", {
-  enumerable: true,
-  get: function () { return abiEngine.isPayableFunction; }
-});
-Object.defineProperty(exports, "isWriteFunction", {
-  enumerable: true,
-  get: function () { return abiEngine.isWriteFunction; }
-});
-Object.defineProperty(exports, "parseABI", {
-  enumerable: true,
-  get: function () { return abiEngine.parseABI; }
-});
 exports.ApiKeyRequiredError = ApiKeyRequiredError;
 exports.AwarizonWeb3 = AwarizonWeb3;
 exports.CHAINLINK_FEEDS = CHAINLINK_FEEDS;
 exports.CHAINS = CHAINS;
 exports.COINGECKO_IDS = COINGECKO_IDS;
+exports.ChainMismatchError = ChainMismatchError;
+exports.ChainSwitchError = ChainSwitchError;
+exports.ContractExecutionError = ContractExecutionError;
 exports.ContractNotLoadedError = ContractNotLoadedError;
+exports.DuplicateFunctionError = DuplicateFunctionError;
 exports.ERC1155_ABI = ERC1155_ABI;
 exports.ERC20_ABI = ERC20_ABI;
 exports.ERC721_ABI = ERC721_ABI;
+exports.GasEstimationError = GasEstimationError;
+exports.InvalidABIError = InvalidABIError;
 exports.InvalidApiKeyError = InvalidApiKeyError;
+exports.InvalidMnemonicError = InvalidMnemonicError;
+exports.InvalidPrivateKeyError = InvalidPrivateKeyError;
 exports.NetworkMismatchError = NetworkMismatchError;
 exports.PriceEngine = PriceEngine;
 exports.ProviderError = ProviderError;
+exports.SimulationError = SimulationError;
 exports.TelemetryClient = TelemetryClient;
+exports.TransactionEngine = TransactionEngine;
+exports.TransactionTimeoutError = TransactionTimeoutError;
+exports.UnsupportedABIItemError = UnsupportedABIItemError;
 exports.UnsupportedChainError = UnsupportedChainError;
+exports.WalletEngine = WalletEngine;
+exports.WalletNotConnectedError = WalletNotConnectedError;
+exports.generateAllMethodSignatures = generateAllMethodSignatures;
+exports.generateMethodSignature = generateMethodSignature;
 exports.getChainTransport = getChainTransport;
 exports.getSupportedChainIds = getSupportedChainIds;
+exports.isPayableFunction = isPayableFunction;
+exports.isWriteFunction = isWriteFunction;
+exports.parseABI = parseABI;
 exports.resolveChain = resolveChain;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map