@aboutcircles/sdk-utils 0.1.0

package/dist/index.js

@@ -0,0 +1,1901 @@
+// src/circlesConverter.ts
+class CirclesConverter {
+  static ONE_64 = 1n << 64n;
+  static GAMMA_64 = 18443079296116538654n;
+  static BETA_64 = 18450409579521241655n;
+  static SECONDS_PER_DAY = 86400n;
+  static INFLATION_DAY_ZERO_UNIX = 1602720000n;
+  static ATTO_FACTOR = 1000000000000000000n;
+  static FACTOR_1E12 = 1000000000000n;
+  static V1_ACCURACY = 100000000n;
+  static V1_INFLATION_PCT_NUM = 107n;
+  static V1_INFLATION_PCT_DEN = 100n;
+  static PERIOD_SEC = 31556952n;
+  static mul64(a, b) {
+    return a * b >> 64n;
+  }
+  static mulU(factor64x64, value) {
+    return factor64x64 * value >> 64n;
+  }
+  static pow64(base64x64, exp) {
+    let base = base64x64;
+    let exponent = exp;
+    let result = this.ONE_64;
+    while (exponent > 0n) {
+      if ((exponent & 1n) === 1n) {
+        result = this.mul64(result, base);
+      }
+      base = this.mul64(base, base);
+      exponent >>= 1n;
+    }
+    return result;
+  }
+  static ONE_36 = 1000000000000000000000000000000000000000n;
+  static GAMMA_36 = 999801332008598957430613406568191166n;
+  static BETA_36 = 1000198707468214629156271489013303962n;
+  static mul36(a, b) {
+    return a * b / this.ONE_36;
+  }
+  static pow36(base36, exp) {
+    let result = this.ONE_36;
+    let base = base36;
+    let e = exp;
+    while (e > 0n) {
+      const isOdd = (e & 1n) === 1n;
+      if (isOdd) {
+        result = this.mul36(result, base);
+      }
+      base = this.mul36(base, base);
+      e >>= 1n;
+    }
+    return result;
+  }
+  static attoCirclesToCircles(atto) {
+    if (atto === 0n)
+      return 0;
+    const whole = atto / this.ATTO_FACTOR;
+    const frac = atto % this.ATTO_FACTOR;
+    const MAX_SAFE_INT = BigInt(Number.MAX_SAFE_INTEGER);
+    if (whole > MAX_SAFE_INT || whole < -MAX_SAFE_INT) {
+      throw new RangeError("Atto value’s integer component exceeds JS double precision.");
+    }
+    return Number(whole) + Number(frac) / Number(this.ATTO_FACTOR);
+  }
+  static circlesToAttoCircles(circles) {
+    return BigInt(Math.trunc(circles * Number(this.ATTO_FACTOR)));
+  }
+  static inflationaryToDemurrage(inflationary, day) {
+    return this.mulU(this.pow64(this.GAMMA_64, day), inflationary);
+  }
+  static demurrageToInflationary(demurraged, day) {
+    return this.mulU(this.pow64(this.BETA_64, day), demurraged);
+  }
+  static dayFromTimestamp(unixSeconds) {
+    return (unixSeconds - this.INFLATION_DAY_ZERO_UNIX) / this.SECONDS_PER_DAY;
+  }
+  static attoCirclesToAttoStaticCircles(demurraged, nowUnixSeconds = BigInt(Math.floor(Date.now() / 1000))) {
+    return this.demurrageToInflationary(demurraged, this.dayFromTimestamp(nowUnixSeconds));
+  }
+  static attoStaticCirclesToAttoCircles(staticCircles, nowUnixSeconds = BigInt(Math.floor(Date.now() / 1000))) {
+    return this.inflationaryToDemurrage(staticCircles, this.dayFromTimestamp(nowUnixSeconds));
+  }
+  static inflationaryToDemurrageExact(inflationary, day) {
+    const factor = this.pow36(this.GAMMA_36, day);
+    return inflationary * factor / this.ONE_36;
+  }
+  static demurrageToInflationaryExact(demurraged, day) {
+    const factor = this.pow36(this.BETA_36, day);
+    return demurraged * factor / this.ONE_36;
+  }
+  static attoCirclesToAttoStaticCirclesExact(demurraged, nowUnixSeconds = BigInt(Math.floor(Date.now() / 1000))) {
+    const day = this.dayFromTimestamp(nowUnixSeconds);
+    return this.demurrageToInflationaryExact(demurraged, day);
+  }
+  static attoStaticCirclesToAttoCirclesExact(staticCircles, nowUnixSeconds = BigInt(Math.floor(Date.now() / 1000))) {
+    const day = this.dayFromTimestamp(nowUnixSeconds);
+    return this.inflationaryToDemurrageExact(staticCircles, day);
+  }
+  static truncateToInt64(wei) {
+    const truncated = wei / this.FACTOR_1E12;
+    const MAX_INT64 = 9223372036854775807n;
+    return truncated > MAX_INT64 ? MAX_INT64 : truncated;
+  }
+  static blowUpToBigInt(sixDecimals) {
+    return sixDecimals * this.FACTOR_1E12;
+  }
+  static truncateToSixDecimals(wei) {
+    return this.blowUpToBigInt(this.truncateToInt64(wei));
+  }
+  static v1InflateFactor(periodIdx) {
+    if (periodIdx === 0n)
+      return this.V1_ACCURACY;
+    return this.V1_ACCURACY * this.V1_INFLATION_PCT_NUM ** periodIdx / this.V1_INFLATION_PCT_DEN ** periodIdx;
+  }
+  static attoCrcToAttoCircles(v1Amount, blockTimestampUtc) {
+    const secondsSinceEpoch = blockTimestampUtc - this.INFLATION_DAY_ZERO_UNIX;
+    const periodIdx = secondsSinceEpoch / this.PERIOD_SEC;
+    const secondsIntoPeriod = secondsSinceEpoch % this.PERIOD_SEC;
+    const factorCur = this.v1InflateFactor(periodIdx);
+    const factorNext = this.v1InflateFactor(periodIdx + 1n);
+    return this.v1ToDemurrage(v1Amount, factorCur, factorNext, secondsIntoPeriod, this.PERIOD_SEC);
+  }
+  static attoCirclesToAttoCrc(demurraged, blockTimestampUtc) {
+    const secondsSinceEpoch = blockTimestampUtc - this.INFLATION_DAY_ZERO_UNIX;
+    const periodIdx = secondsSinceEpoch / this.PERIOD_SEC;
+    const secondsIntoPeriod = secondsSinceEpoch % this.PERIOD_SEC;
+    const factorCur = this.v1InflateFactor(periodIdx);
+    const factorNext = this.v1InflateFactor(periodIdx + 1n);
+    const rP = factorCur * (this.PERIOD_SEC - secondsIntoPeriod) + factorNext * secondsIntoPeriod;
+    return demurraged * 3n * this.V1_ACCURACY * this.PERIOD_SEC / rP;
+  }
+  static v1ToDemurrage(v1Amount, factorCur, factorNext, secondsInto, periodSec) {
+    const rP = factorCur * (periodSec - secondsInto) + factorNext * secondsInto;
+    return v1Amount * 3n * this.V1_ACCURACY * periodSec / rP;
+  }
+}
+// src/bytes.ts
+var byteToHex = [];
+for (let i = 0;i < 256; i++) {
+  byteToHex[i] = i.toString(16).padStart(2, "0");
+}
+function bytesToHex(bytes) {
+  let hex = "0x";
+  for (let i = 0;i < bytes.length; i++) {
+    hex += byteToHex[bytes[i]];
+  }
+  return hex;
+}
+// ../../node_modules/@noble/hashes/esm/_u64.js
+var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+var _32n = /* @__PURE__ */ BigInt(32);
+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 rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+var rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+var rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+var rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+
+// ../../node_modules/@noble/hashes/esm/utils.js
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+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);
+  }
+}
+var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+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;
+}
+var swap32IfBE = isLE ? (u) => u : byteSwap32;
+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;
+}
+class Hash {
+}
+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;
+}
+
+// ../../node_modules/@noble/hashes/esm/sha3.js
+var _0n = BigInt(0);
+var _1n = BigInt(1);
+var _2n = BigInt(2);
+var _7n = BigInt(7);
+var _256n = BigInt(256);
+var _0x71n = BigInt(113);
+var SHA3_PI = [];
+var SHA3_ROTL = [];
+var _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);
+}
+var IOTAS = split(_SHA3_IOTA, true);
+var SHA3_IOTA_H = IOTAS[0];
+var SHA3_IOTA_L = IOTAS[1];
+var rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
+var rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
+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);
+}
+
+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 = toBytes(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;
+  }
+}
+var gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen));
+var keccak_256 = /* @__PURE__ */ (() => gen(1, 136, 256 / 8))();
+
+// src/abi.ts
+var HEX_CHARS = 64;
+var BYTES_PER_WORD = 32;
+var strip0x = (hex) => hex.startsWith("0x") ? hex.slice(2) : hex;
+var toHex64 = (num) => num.toString(16).padStart(HEX_CHARS, "0");
+function checksumAddress(address) {
+  const addr = address.toLowerCase().replace("0x", "");
+  const hash = bytesToHex(keccak_256(new TextEncoder().encode(addr))).slice(2);
+  let result = "0x";
+  for (let i = 0;i < addr.length; i++) {
+    result += parseInt(hash[i], 16) >= 8 ? addr[i].toUpperCase() : addr[i];
+  }
+  return result;
+}
+function getTypeString(type, components) {
+  if (type === "tuple" && components) {
+    const types = components.map((c) => getTypeString(c.type, c.components));
+    return `(${types.join(",")})`;
+  }
+  const tupleArrayMatch = type.match(/^tuple(\[\d*\])$/);
+  if (tupleArrayMatch && components) {
+    const baseType = getTypeString("tuple", components);
+    return `${baseType}${tupleArrayMatch[1]}`;
+  }
+  return type;
+}
+function getFunctionSignature(abiFunction) {
+  const inputs = abiFunction.inputs || [];
+  const types = inputs.map((input) => getTypeString(input.type, input.components));
+  return `${abiFunction.name}(${types.join(",")})`;
+}
+function getFunctionSelector(abiFunction) {
+  const signature = getFunctionSignature(abiFunction);
+  const hash = keccak_256(new TextEncoder().encode(signature));
+  return bytesToHex(hash.slice(0, 4));
+}
+function isDynamicType(type, components) {
+  if (type === "string" || type === "bytes")
+    return true;
+  if (type.includes("[")) {
+    const baseType = type.slice(0, type.indexOf("["));
+    if (type.endsWith("[]"))
+      return true;
+    if (baseType === "tuple") {
+      return isTupleDynamic(components);
+    }
+    return isDynamicType(baseType);
+  }
+  if (type === "tuple") {
+    return isTupleDynamic(components);
+  }
+  return false;
+}
+function isTupleDynamic(components) {
+  return components?.some((c) => isDynamicType(c.type, c.components)) ?? false;
+}
+function encodeParam(type, value, components) {
+  if (type === "tuple" && components) {
+    return encodeTuple(components, value);
+  }
+  if (type.includes("[")) {
+    return encodeArray(type, value, components);
+  }
+  return encodePrimitive(type, value);
+}
+function encodeArray(type, arr, components) {
+  const baseType = type.slice(0, type.indexOf("["));
+  const isDynamic = type.endsWith("[]");
+  const elementsAreDynamic = isDynamicType(baseType, components);
+  let encoded;
+  if (elementsAreDynamic) {
+    const encodings = arr.map((v) => encodeParam(baseType, v, components));
+    let offset = arr.length * BYTES_PER_WORD;
+    const offsets = encodings.map((enc) => {
+      const currentOffset = offset;
+      offset += enc.length / 2;
+      return toHex64(currentOffset);
+    });
+    encoded = offsets.join("") + encodings.join("");
+  } else {
+    encoded = arr.map((v) => encodeParam(baseType, v, components)).join("");
+  }
+  return isDynamic ? toHex64(arr.length) + encoded : encoded;
+}
+function encodeTuple(components, value) {
+  const isArray = Array.isArray(value);
+  const encodings = [];
+  const dynamicData = [];
+  const isDynamic = [];
+  for (let i = 0;i < components.length; i++) {
+    const component = components[i];
+    const val = isArray ? value[i] : value[component.name || ""];
+    const dynamic = isDynamicType(component.type, component.components);
+    isDynamic.push(dynamic);
+    if (dynamic) {
+      encodings.push("");
+      dynamicData.push(encodeParam(component.type, val, component.components));
+    } else {
+      encodings.push(encodeParam(component.type, val, component.components));
+    }
+  }
+  if (dynamicData.length > 0) {
+    let offset = encodings.reduce((sum, enc, i) => sum + (isDynamic[i] ? BYTES_PER_WORD : enc.length / 2), 0);
+    let result = "";
+    let dynamicIndex = 0;
+    for (let i = 0;i < components.length; i++) {
+      if (isDynamic[i]) {
+        result += toHex64(offset);
+        offset += dynamicData[dynamicIndex].length / 2;
+        dynamicIndex++;
+      } else {
+        result += encodings[i];
+      }
+    }
+    return result + dynamicData.join("");
+  }
+  return encodings.join("");
+}
+function encodePrimitive(type, value) {
+  if (type === "address") {
+    return strip0x(value).toLowerCase().padStart(HEX_CHARS, "0");
+  }
+  if (type === "bool") {
+    return toHex64(value ? 1 : 0);
+  }
+  if (type.startsWith("uint")) {
+    const num = typeof value === "bigint" ? value : BigInt(value);
+    return toHex64(num);
+  }
+  if (type.startsWith("int")) {
+    let num = typeof value === "bigint" ? value : BigInt(value);
+    if (num < 0n) {
+      const bits = type === "int" ? 256 : parseInt(type.slice(3));
+      num = (1n << BigInt(bits)) + num;
+    }
+    return toHex64(num);
+  }
+  if (type.startsWith("bytes") && type !== "bytes") {
+    return strip0x(value).padEnd(HEX_CHARS, "0");
+  }
+  if (type === "bytes") {
+    const bytes = strip0x(value);
+    const length = toHex64(bytes.length / 2);
+    const padded = bytes.padEnd(Math.ceil(bytes.length / HEX_CHARS) * HEX_CHARS, "0");
+    return length + padded;
+  }
+  if (type === "string") {
+    const bytes = Array.from(new TextEncoder().encode(value)).map((b) => b.toString(16).padStart(2, "0")).join("");
+    const length = toHex64(bytes.length / 2);
+    const padded = bytes.padEnd(Math.ceil(bytes.length / HEX_CHARS) * HEX_CHARS, "0");
+    return length + padded;
+  }
+  throw new Error(`Unsupported type: ${type}`);
+}
+function decodeParam(type, data, offset = 0, components) {
+  if (type === "tuple" && components) {
+    return decodeTuple(components, data, offset);
+  }
+  if (type.includes("[")) {
+    return decodeArray(type, data, offset, components);
+  }
+  return decodePrimitive(type, data, offset);
+}
+function decodeArray(type, data, offset, components) {
+  const baseType = type.slice(0, type.indexOf("["));
+  const chunk = data.slice(offset, offset + HEX_CHARS);
+  if (type.endsWith("[]")) {
+    const dataOffset = parseInt(chunk, 16) * 2;
+    const length = parseInt(data.slice(dataOffset, dataOffset + HEX_CHARS), 16);
+    const values = [];
+    let currentOffset = dataOffset + HEX_CHARS;
+    for (let i = 0;i < length; i++) {
+      const result = decodeParam(baseType, data, currentOffset, components);
+      values.push(result.value);
+      currentOffset += result.consumed;
+    }
+    return { value: values, consumed: HEX_CHARS };
+  }
+  const match = type.match(/\[(\d+)\]$/);
+  if (match) {
+    const length = parseInt(match[1]);
+    const values = [];
+    let consumed = 0;
+    for (let i = 0;i < length; i++) {
+      const result = decodeParam(baseType, data, offset + consumed, components);
+      values.push(result.value);
+      consumed += result.consumed;
+    }
+    return { value: values, consumed };
+  }
+  throw new Error(`Invalid array type: ${type}`);
+}
+function decodeTuple(components, data, offset) {
+  const values = [];
+  let currentOffset = offset;
+  for (const component of components) {
+    const result = decodeParam(component.type, data, currentOffset, component.components);
+    values.push(result.value);
+    currentOffset += result.consumed;
+  }
+  return { value: values, consumed: currentOffset - offset };
+}
+function decodePrimitive(type, data, offset) {
+  const chunk = data.slice(offset, offset + HEX_CHARS);
+  if (type === "address") {
+    return {
+      value: checksumAddress("0x" + chunk.slice(24)),
+      consumed: HEX_CHARS
+    };
+  }
+  if (type === "bool") {
+    return {
+      value: parseInt(chunk, 16) !== 0,
+      consumed: HEX_CHARS
+    };
+  }
+  if (type.startsWith("uint")) {
+    return {
+      value: BigInt("0x" + chunk),
+      consumed: HEX_CHARS
+    };
+  }
+  if (type.startsWith("int")) {
+    const value = BigInt("0x" + chunk);
+    const bits = type === "int" ? 256 : parseInt(type.slice(3));
+    const signBit = 1n << BigInt(bits - 1);
+    return {
+      value: value >= signBit ? value - (1n << BigInt(bits)) : value,
+      consumed: HEX_CHARS
+    };
+  }
+  if (type.startsWith("bytes") && type !== "bytes") {
+    const size = parseInt(type.match(/^bytes(\d+)$/)[1]);
+    return {
+      value: "0x" + chunk.slice(0, size * 2),
+      consumed: HEX_CHARS
+    };
+  }
+  if (type === "bytes") {
+    const dataOffset = parseInt(chunk, 16) * 2;
+    const length = parseInt(data.slice(dataOffset, dataOffset + HEX_CHARS), 16) * 2;
+    return {
+      value: "0x" + data.slice(dataOffset + HEX_CHARS, dataOffset + HEX_CHARS + length),
+      consumed: HEX_CHARS
+    };
+  }
+  if (type === "string") {
+    const dataOffset = parseInt(chunk, 16) * 2;
+    const length = parseInt(data.slice(dataOffset, dataOffset + HEX_CHARS), 16) * 2;
+    const bytes = data.slice(dataOffset + HEX_CHARS, dataOffset + HEX_CHARS + length);
+    const byteArray = new Uint8Array(bytes.match(/.{2}/g)?.map((b) => parseInt(b, 16)) || []);
+    return {
+      value: new TextDecoder().decode(byteArray),
+      consumed: HEX_CHARS
+    };
+  }
+  throw new Error(`Unsupported type: ${type}`);
+}
+function encodeFunctionData(config) {
+  const { abi, functionName, args = [] } = config;
+  const abiFunction = abi.find((item) => item.type === "function" && item.name === functionName);
+  if (!abiFunction) {
+    throw new Error(`Function "${functionName}" not found in ABI`);
+  }
+  const selector = getFunctionSelector(abiFunction);
+  const inputs = abiFunction.inputs || [];
+  if (inputs.length === 0)
+    return selector;
+  if (args.length !== inputs.length) {
+    throw new Error(`Expected ${inputs.length} arguments, got ${args.length}`);
+  }
+  const encodings = [];
+  const dynamicData = [];
+  const isDynamic = [];
+  for (let i = 0;i < inputs.length; i++) {
+    const input = inputs[i];
+    const components = input.components;
+    const dynamic = isDynamicType(input.type, components);
+    isDynamic.push(dynamic);
+    if (dynamic) {
+      encodings.push("");
+      dynamicData.push(encodeParam(input.type, args[i], components));
+    } else {
+      encodings.push(encodeParam(input.type, args[i], components));
+    }
+  }
+  if (dynamicData.length === 0) {
+    return selector + encodings.join("");
+  }
+  let offset = encodings.reduce((sum, enc, i) => sum + (isDynamic[i] ? BYTES_PER_WORD : enc.length / 2), 0);
+  let result = "";
+  let dynamicIndex = 0;
+  for (let i = 0;i < inputs.length; i++) {
+    if (isDynamic[i]) {
+      result += toHex64(offset);
+      offset += dynamicData[dynamicIndex].length / 2;
+      dynamicIndex++;
+    } else {
+      result += encodings[i];
+    }
+  }
+  return selector + result + dynamicData.join("");
+}
+function decodeFunctionResult(config) {
+  const { abi, functionName, data } = config;
+  const abiFunction = abi.find((item) => item.type === "function" && item.name === functionName);
+  if (!abiFunction) {
+    throw new Error(`Function "${functionName}" not found in ABI`);
+  }
+  const outputs = abiFunction.outputs || [];
+  if (outputs.length === 0)
+    return;
+  const cleanData = strip0x(data);
+  if (outputs.length === 1) {
+    return decodeParam(outputs[0].type, cleanData, 0, outputs[0].components).value;
+  }
+  const results = [];
+  let offset = 0;
+  for (const output of outputs) {
+    const result = decodeParam(output.type, cleanData, offset, output.components);
+    results.push(result.value);
+    offset += result.consumed;
+  }
+  return results;
+}
+function getErrorSelector(errorItem) {
+  const inputs = errorItem.inputs || [];
+  const types = inputs.map((input) => getTypeString(input.type, input.components));
+  const signature = `${errorItem.name}(${types.join(",")})`;
+  const hash = keccak_256(new TextEncoder().encode(signature));
+  return bytesToHex(hash.slice(0, 4));
+}
+function decodeErrorResult(config) {
+  const { abi, data } = config;
+  if (!data || data.length < 10) {
+    return null;
+  }
+  const selector = data.slice(0, 10).toLowerCase();
+  const cleanData = strip0x(data.slice(10));
+  const errors = abi.filter((item) => item.type === "error");
+  for (const errorItem of errors) {
+    const errorSelector = getErrorSelector(errorItem);
+    if (errorSelector.toLowerCase() === selector) {
+      const inputs = errorItem.inputs || [];
+      if (inputs.length === 0) {
+        return { errorName: errorItem.name };
+      }
+      const decodedArgs = [];
+      let offset = 0;
+      for (const input of inputs) {
+        const result = decodeParam(input.type, cleanData, offset, input.components);
+        decodedArgs.push(result.value);
+        offset += result.consumed;
+      }
+      return {
+        errorName: errorItem.name,
+        args: decodedArgs
+      };
+    }
+  }
+  return null;
+}
+// ../../node_modules/multiformats/dist/src/bytes.js
+var empty = new Uint8Array(0);
+function equals(aa, bb) {
+  if (aa === bb) {
+    return true;
+  }
+  if (aa.byteLength !== bb.byteLength) {
+    return false;
+  }
+  for (let ii = 0;ii < aa.byteLength; ii++) {
+    if (aa[ii] !== bb[ii]) {
+      return false;
+    }
+  }
+  return true;
+}
+function coerce(o) {
+  if (o instanceof Uint8Array && o.constructor.name === "Uint8Array") {
+    return o;
+  }
+  if (o instanceof ArrayBuffer) {
+    return new Uint8Array(o);
+  }
+  if (ArrayBuffer.isView(o)) {
+    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
+  }
+  throw new Error("Unknown type, must be binary type");
+}
+
+// ../../node_modules/multiformats/dist/src/vendor/base-x.js
+function base(ALPHABET, name) {
+  if (ALPHABET.length >= 255) {
+    throw new TypeError("Alphabet too long");
+  }
+  var BASE_MAP = new Uint8Array(256);
+  for (var j = 0;j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255;
+  }
+  for (var i = 0;i < ALPHABET.length; i++) {
+    var x = ALPHABET.charAt(i);
+    var xc = x.charCodeAt(0);
+    if (BASE_MAP[xc] !== 255) {
+      throw new TypeError(x + " is ambiguous");
+    }
+    BASE_MAP[xc] = i;
+  }
+  var BASE = ALPHABET.length;
+  var LEADER = ALPHABET.charAt(0);
+  var FACTOR = Math.log(BASE) / Math.log(256);
+  var iFACTOR = Math.log(256) / Math.log(BASE);
+  function encode(source) {
+    if (source instanceof Uint8Array)
+      ;
+    else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source);
+    }
+    if (!(source instanceof Uint8Array)) {
+      throw new TypeError("Expected Uint8Array");
+    }
+    if (source.length === 0) {
+      return "";
+    }
+    var zeroes = 0;
+    var length = 0;
+    var pbegin = 0;
+    var pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+    var b58 = new Uint8Array(size);
+    while (pbegin !== pend) {
+      var carry = source[pbegin];
+      var i2 = 0;
+      for (var it1 = size - 1;(carry !== 0 || i2 < length) && it1 !== -1; it1--, i2++) {
+        carry += 256 * b58[it1] >>> 0;
+        b58[it1] = carry % BASE >>> 0;
+        carry = carry / BASE >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length = i2;
+      pbegin++;
+    }
+    var it2 = size - length;
+    while (it2 !== size && b58[it2] === 0) {
+      it2++;
+    }
+    var str = LEADER.repeat(zeroes);
+    for (;it2 < size; ++it2) {
+      str += ALPHABET.charAt(b58[it2]);
+    }
+    return str;
+  }
+  function decodeUnsafe(source) {
+    if (typeof source !== "string") {
+      throw new TypeError("Expected String");
+    }
+    if (source.length === 0) {
+      return new Uint8Array;
+    }
+    var psz = 0;
+    if (source[psz] === " ") {
+      return;
+    }
+    var zeroes = 0;
+    var length = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+    var size = (source.length - psz) * FACTOR + 1 >>> 0;
+    var b256 = new Uint8Array(size);
+    while (source[psz]) {
+      var carry = BASE_MAP[source.charCodeAt(psz)];
+      if (carry === 255) {
+        return;
+      }
+      var i2 = 0;
+      for (var it3 = size - 1;(carry !== 0 || i2 < length) && it3 !== -1; it3--, i2++) {
+        carry += BASE * b256[it3] >>> 0;
+        b256[it3] = carry % 256 >>> 0;
+        carry = carry / 256 >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length = i2;
+      psz++;
+    }
+    if (source[psz] === " ") {
+      return;
+    }
+    var it4 = size - length;
+    while (it4 !== size && b256[it4] === 0) {
+      it4++;
+    }
+    var vch = new Uint8Array(zeroes + (size - it4));
+    var j2 = zeroes;
+    while (it4 !== size) {
+      vch[j2++] = b256[it4++];
+    }
+    return vch;
+  }
+  function decode(string) {
+    var buffer = decodeUnsafe(string);
+    if (buffer) {
+      return buffer;
+    }
+    throw new Error(`Non-${name} character`);
+  }
+  return {
+    encode,
+    decodeUnsafe,
+    decode
+  };
+}
+var src = base;
+var _brrp__multiformats_scope_baseX = src;
+var base_x_default = _brrp__multiformats_scope_baseX;
+
+// ../../node_modules/multiformats/dist/src/bases/base.js
+class Encoder {
+  name;
+  prefix;
+  baseEncode;
+  constructor(name, prefix, baseEncode) {
+    this.name = name;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+  }
+  encode(bytes) {
+    if (bytes instanceof Uint8Array) {
+      return `${this.prefix}${this.baseEncode(bytes)}`;
+    } else {
+      throw Error("Unknown type, must be binary type");
+    }
+  }
+}
+
+class Decoder {
+  name;
+  prefix;
+  baseDecode;
+  prefixCodePoint;
+  constructor(name, prefix, baseDecode) {
+    this.name = name;
+    this.prefix = prefix;
+    const prefixCodePoint = prefix.codePointAt(0);
+    if (prefixCodePoint === undefined) {
+      throw new Error("Invalid prefix character");
+    }
+    this.prefixCodePoint = prefixCodePoint;
+    this.baseDecode = baseDecode;
+  }
+  decode(text) {
+    if (typeof text === "string") {
+      if (text.codePointAt(0) !== this.prefixCodePoint) {
+        throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
+      }
+      return this.baseDecode(text.slice(this.prefix.length));
+    } else {
+      throw Error("Can only multibase decode strings");
+    }
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+}
+
+class ComposedDecoder {
+  decoders;
+  constructor(decoders) {
+    this.decoders = decoders;
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+  decode(input) {
+    const prefix = input[0];
+    const decoder = this.decoders[prefix];
+    if (decoder != null) {
+      return decoder.decode(input);
+    } else {
+      throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
+    }
+  }
+}
+function or(left, right) {
+  return new ComposedDecoder({
+    ...left.decoders ?? { [left.prefix]: left },
+    ...right.decoders ?? { [right.prefix]: right }
+  });
+}
+
+class Codec {
+  name;
+  prefix;
+  baseEncode;
+  baseDecode;
+  encoder;
+  decoder;
+  constructor(name, prefix, baseEncode, baseDecode) {
+    this.name = name;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+    this.baseDecode = baseDecode;
+    this.encoder = new Encoder(name, prefix, baseEncode);
+    this.decoder = new Decoder(name, prefix, baseDecode);
+  }
+  encode(input) {
+    return this.encoder.encode(input);
+  }
+  decode(input) {
+    return this.decoder.decode(input);
+  }
+}
+function from({ name, prefix, encode, decode }) {
+  return new Codec(name, prefix, encode, decode);
+}
+function baseX({ name, prefix, alphabet }) {
+  const { encode, decode } = base_x_default(alphabet, name);
+  return from({
+    prefix,
+    name,
+    encode,
+    decode: (text) => coerce(decode(text))
+  });
+}
+function decode(string, alphabetIdx, bitsPerChar, name) {
+  let end = string.length;
+  while (string[end - 1] === "=") {
+    --end;
+  }
+  const out = new Uint8Array(end * bitsPerChar / 8 | 0);
+  let bits = 0;
+  let buffer = 0;
+  let written = 0;
+  for (let i = 0;i < end; ++i) {
+    const value = alphabetIdx[string[i]];
+    if (value === undefined) {
+      throw new SyntaxError(`Non-${name} character`);
+    }
+    buffer = buffer << bitsPerChar | value;
+    bits += bitsPerChar;
+    if (bits >= 8) {
+      bits -= 8;
+      out[written++] = 255 & buffer >> bits;
+    }
+  }
+  if (bits >= bitsPerChar || (255 & buffer << 8 - bits) !== 0) {
+    throw new SyntaxError("Unexpected end of data");
+  }
+  return out;
+}
+function encode(data, alphabet, bitsPerChar) {
+  const pad = alphabet[alphabet.length - 1] === "=";
+  const mask = (1 << bitsPerChar) - 1;
+  let out = "";
+  let bits = 0;
+  let buffer = 0;
+  for (let i = 0;i < data.length; ++i) {
+    buffer = buffer << 8 | data[i];
+    bits += 8;
+    while (bits > bitsPerChar) {
+      bits -= bitsPerChar;
+      out += alphabet[mask & buffer >> bits];
+    }
+  }
+  if (bits !== 0) {
+    out += alphabet[mask & buffer << bitsPerChar - bits];
+  }
+  if (pad) {
+    while ((out.length * bitsPerChar & 7) !== 0) {
+      out += "=";
+    }
+  }
+  return out;
+}
+function createAlphabetIdx(alphabet) {
+  const alphabetIdx = {};
+  for (let i = 0;i < alphabet.length; ++i) {
+    alphabetIdx[alphabet[i]] = i;
+  }
+  return alphabetIdx;
+}
+function rfc4648({ name, prefix, bitsPerChar, alphabet }) {
+  const alphabetIdx = createAlphabetIdx(alphabet);
+  return from({
+    prefix,
+    name,
+    encode(input) {
+      return encode(input, alphabet, bitsPerChar);
+    },
+    decode(input) {
+      return decode(input, alphabetIdx, bitsPerChar, name);
+    }
+  });
+}
+
+// ../../node_modules/multiformats/dist/src/bases/base32.js
+var base32 = rfc4648({
+  prefix: "b",
+  name: "base32",
+  alphabet: "abcdefghijklmnopqrstuvwxyz234567",
+  bitsPerChar: 5
+});
+var base32upper = rfc4648({
+  prefix: "B",
+  name: "base32upper",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
+  bitsPerChar: 5
+});
+var base32pad = rfc4648({
+  prefix: "c",
+  name: "base32pad",
+  alphabet: "abcdefghijklmnopqrstuvwxyz234567=",
+  bitsPerChar: 5
+});
+var base32padupper = rfc4648({
+  prefix: "C",
+  name: "base32padupper",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
+  bitsPerChar: 5
+});
+var base32hex = rfc4648({
+  prefix: "v",
+  name: "base32hex",
+  alphabet: "0123456789abcdefghijklmnopqrstuv",
+  bitsPerChar: 5
+});
+var base32hexupper = rfc4648({
+  prefix: "V",
+  name: "base32hexupper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
+  bitsPerChar: 5
+});
+var base32hexpad = rfc4648({
+  prefix: "t",
+  name: "base32hexpad",
+  alphabet: "0123456789abcdefghijklmnopqrstuv=",
+  bitsPerChar: 5
+});
+var base32hexpadupper = rfc4648({
+  prefix: "T",
+  name: "base32hexpadupper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV=",
+  bitsPerChar: 5
+});
+var base32z = rfc4648({
+  prefix: "h",
+  name: "base32z",
+  alphabet: "ybndrfg8ejkmcpqxot1uwisza345h769",
+  bitsPerChar: 5
+});
+
+// ../../node_modules/multiformats/dist/src/bases/base36.js
+var base36 = baseX({
+  prefix: "k",
+  name: "base36",
+  alphabet: "0123456789abcdefghijklmnopqrstuvwxyz"
+});
+var base36upper = baseX({
+  prefix: "K",
+  name: "base36upper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+});
+
+// ../../node_modules/multiformats/dist/src/bases/base58.js
+var base58btc = baseX({
+  name: "base58btc",
+  prefix: "z",
+  alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+});
+var base58flickr = baseX({
+  name: "base58flickr",
+  prefix: "Z",
+  alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
+});
+
+// ../../node_modules/multiformats/dist/src/vendor/varint.js
+var encode_1 = encode2;
+var MSB = 128;
+var REST = 127;
+var MSBALL = ~REST;
+var INT = Math.pow(2, 31);
+function encode2(num, out, offset) {
+  out = out || [];
+  offset = offset || 0;
+  var oldOffset = offset;
+  while (num >= INT) {
+    out[offset++] = num & 255 | MSB;
+    num /= 128;
+  }
+  while (num & MSBALL) {
+    out[offset++] = num & 255 | MSB;
+    num >>>= 7;
+  }
+  out[offset] = num | 0;
+  encode2.bytes = offset - oldOffset + 1;
+  return out;
+}
+var decode2 = read;
+var MSB$1 = 128;
+var REST$1 = 127;
+function read(buf, offset) {
+  var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
+  do {
+    if (counter >= l) {
+      read.bytes = 0;
+      throw new RangeError("Could not decode varint");
+    }
+    b = buf[counter++];
+    res += shift < 28 ? (b & REST$1) << shift : (b & REST$1) * Math.pow(2, shift);
+    shift += 7;
+  } while (b >= MSB$1);
+  read.bytes = counter - offset;
+  return res;
+}
+var N1 = Math.pow(2, 7);
+var N2 = Math.pow(2, 14);
+var N3 = Math.pow(2, 21);
+var N4 = Math.pow(2, 28);
+var N5 = Math.pow(2, 35);
+var N6 = Math.pow(2, 42);
+var N7 = Math.pow(2, 49);
+var N8 = Math.pow(2, 56);
+var N9 = Math.pow(2, 63);
+var length = function(value) {
+  return value < N1 ? 1 : value < N2 ? 2 : value < N3 ? 3 : value < N4 ? 4 : value < N5 ? 5 : value < N6 ? 6 : value < N7 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10;
+};
+var varint = {
+  encode: encode_1,
+  decode: decode2,
+  encodingLength: length
+};
+var _brrp_varint = varint;
+var varint_default = _brrp_varint;
+
+// ../../node_modules/multiformats/dist/src/varint.js
+function decode3(data, offset = 0) {
+  const code = varint_default.decode(data, offset);
+  return [code, varint_default.decode.bytes];
+}
+function encodeTo(int, target, offset = 0) {
+  varint_default.encode(int, target, offset);
+  return target;
+}
+function encodingLength(int) {
+  return varint_default.encodingLength(int);
+}
+
+// ../../node_modules/multiformats/dist/src/hashes/digest.js
+function create(code, digest) {
+  const size = digest.byteLength;
+  const sizeOffset = encodingLength(code);
+  const digestOffset = sizeOffset + encodingLength(size);
+  const bytes = new Uint8Array(digestOffset + size);
+  encodeTo(code, bytes, 0);
+  encodeTo(size, bytes, sizeOffset);
+  bytes.set(digest, digestOffset);
+  return new Digest(code, size, digest, bytes);
+}
+function decode4(multihash) {
+  const bytes = coerce(multihash);
+  const [code, sizeOffset] = decode3(bytes);
+  const [size, digestOffset] = decode3(bytes.subarray(sizeOffset));
+  const digest = bytes.subarray(sizeOffset + digestOffset);
+  if (digest.byteLength !== size) {
+    throw new Error("Incorrect length");
+  }
+  return new Digest(code, size, digest, bytes);
+}
+function equals2(a, b) {
+  if (a === b) {
+    return true;
+  } else {
+    const data = b;
+    return a.code === data.code && a.size === data.size && data.bytes instanceof Uint8Array && equals(a.bytes, data.bytes);
+  }
+}
+
+class Digest {
+  code;
+  size;
+  digest;
+  bytes;
+  constructor(code, size, digest, bytes) {
+    this.code = code;
+    this.size = size;
+    this.digest = digest;
+    this.bytes = bytes;
+  }
+}
+
+// ../../node_modules/multiformats/dist/src/cid.js
+function format(link, base2) {
+  const { bytes, version } = link;
+  switch (version) {
+    case 0:
+      return toStringV0(bytes, baseCache(link), base2 ?? base58btc.encoder);
+    default:
+      return toStringV1(bytes, baseCache(link), base2 ?? base32.encoder);
+  }
+}
+var cache = new WeakMap;
+function baseCache(cid) {
+  const baseCache2 = cache.get(cid);
+  if (baseCache2 == null) {
+    const baseCache3 = new Map;
+    cache.set(cid, baseCache3);
+    return baseCache3;
+  }
+  return baseCache2;
+}
+
+class CID {
+  code;
+  version;
+  multihash;
+  bytes;
+  "/";
+  constructor(version, code, multihash, bytes) {
+    this.code = code;
+    this.version = version;
+    this.multihash = multihash;
+    this.bytes = bytes;
+    this["/"] = bytes;
+  }
+  get asCID() {
+    return this;
+  }
+  get byteOffset() {
+    return this.bytes.byteOffset;
+  }
+  get byteLength() {
+    return this.bytes.byteLength;
+  }
+  toV0() {
+    switch (this.version) {
+      case 0: {
+        return this;
+      }
+      case 1: {
+        const { code, multihash } = this;
+        if (code !== DAG_PB_CODE) {
+          throw new Error("Cannot convert a non dag-pb CID to CIDv0");
+        }
+        if (multihash.code !== SHA_256_CODE) {
+          throw new Error("Cannot convert non sha2-256 multihash CID to CIDv0");
+        }
+        return CID.createV0(multihash);
+      }
+      default: {
+        throw Error(`Can not convert CID version ${this.version} to version 0. This is a bug please report`);
+      }
+    }
+  }
+  toV1() {
+    switch (this.version) {
+      case 0: {
+        const { code, digest } = this.multihash;
+        const multihash = create(code, digest);
+        return CID.createV1(this.code, multihash);
+      }
+      case 1: {
+        return this;
+      }
+      default: {
+        throw Error(`Can not convert CID version ${this.version} to version 1. This is a bug please report`);
+      }
+    }
+  }
+  equals(other) {
+    return CID.equals(this, other);
+  }
+  static equals(self, other) {
+    const unknown = other;
+    return unknown != null && self.code === unknown.code && self.version === unknown.version && equals2(self.multihash, unknown.multihash);
+  }
+  toString(base2) {
+    return format(this, base2);
+  }
+  toJSON() {
+    return { "/": format(this) };
+  }
+  link() {
+    return this;
+  }
+  [Symbol.toStringTag] = "CID";
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `CID(${this.toString()})`;
+  }
+  static asCID(input) {
+    if (input == null) {
+      return null;
+    }
+    const value = input;
+    if (value instanceof CID) {
+      return value;
+    } else if (value["/"] != null && value["/"] === value.bytes || value.asCID === value) {
+      const { version, code, multihash, bytes } = value;
+      return new CID(version, code, multihash, bytes ?? encodeCID(version, code, multihash.bytes));
+    } else if (value[cidSymbol] === true) {
+      const { version, multihash, code } = value;
+      const digest = decode4(multihash);
+      return CID.create(version, code, digest);
+    } else {
+      return null;
+    }
+  }
+  static create(version, code, digest) {
+    if (typeof code !== "number") {
+      throw new Error("String codecs are no longer supported");
+    }
+    if (!(digest.bytes instanceof Uint8Array)) {
+      throw new Error("Invalid digest");
+    }
+    switch (version) {
+      case 0: {
+        if (code !== DAG_PB_CODE) {
+          throw new Error(`Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`);
+        } else {
+          return new CID(version, code, digest, digest.bytes);
+        }
+      }
+      case 1: {
+        const bytes = encodeCID(version, code, digest.bytes);
+        return new CID(version, code, digest, bytes);
+      }
+      default: {
+        throw new Error("Invalid version");
+      }
+    }
+  }
+  static createV0(digest) {
+    return CID.create(0, DAG_PB_CODE, digest);
+  }
+  static createV1(code, digest) {
+    return CID.create(1, code, digest);
+  }
+  static decode(bytes) {
+    const [cid, remainder] = CID.decodeFirst(bytes);
+    if (remainder.length !== 0) {
+      throw new Error("Incorrect length");
+    }
+    return cid;
+  }
+  static decodeFirst(bytes) {
+    const specs = CID.inspectBytes(bytes);
+    const prefixSize = specs.size - specs.multihashSize;
+    const multihashBytes = coerce(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
+    if (multihashBytes.byteLength !== specs.multihashSize) {
+      throw new Error("Incorrect length");
+    }
+    const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);
+    const digest = new Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);
+    const cid = specs.version === 0 ? CID.createV0(digest) : CID.createV1(specs.codec, digest);
+    return [cid, bytes.subarray(specs.size)];
+  }
+  static inspectBytes(initialBytes) {
+    let offset = 0;
+    const next = () => {
+      const [i, length2] = decode3(initialBytes.subarray(offset));
+      offset += length2;
+      return i;
+    };
+    let version = next();
+    let codec = DAG_PB_CODE;
+    if (version === 18) {
+      version = 0;
+      offset = 0;
+    } else {
+      codec = next();
+    }
+    if (version !== 0 && version !== 1) {
+      throw new RangeError(`Invalid CID version ${version}`);
+    }
+    const prefixSize = offset;
+    const multihashCode = next();
+    const digestSize = next();
+    const size = offset + digestSize;
+    const multihashSize = size - prefixSize;
+    return { version, codec, multihashCode, digestSize, multihashSize, size };
+  }
+  static parse(source, base2) {
+    const [prefix, bytes] = parseCIDtoBytes(source, base2);
+    const cid = CID.decode(bytes);
+    if (cid.version === 0 && source[0] !== "Q") {
+      throw Error("Version 0 CID string must not include multibase prefix");
+    }
+    baseCache(cid).set(prefix, source);
+    return cid;
+  }
+}
+function parseCIDtoBytes(source, base2) {
+  switch (source[0]) {
+    case "Q": {
+      const decoder = base2 ?? base58btc;
+      return [
+        base58btc.prefix,
+        decoder.decode(`${base58btc.prefix}${source}`)
+      ];
+    }
+    case base58btc.prefix: {
+      const decoder = base2 ?? base58btc;
+      return [base58btc.prefix, decoder.decode(source)];
+    }
+    case base32.prefix: {
+      const decoder = base2 ?? base32;
+      return [base32.prefix, decoder.decode(source)];
+    }
+    case base36.prefix: {
+      const decoder = base2 ?? base36;
+      return [base36.prefix, decoder.decode(source)];
+    }
+    default: {
+      if (base2 == null) {
+        throw Error("To parse non base32, base36 or base58btc encoded CID multibase decoder must be provided");
+      }
+      return [source[0], base2.decode(source)];
+    }
+  }
+}
+function toStringV0(bytes, cache2, base2) {
+  const { prefix } = base2;
+  if (prefix !== base58btc.prefix) {
+    throw Error(`Cannot string encode V0 in ${base2.name} encoding`);
+  }
+  const cid = cache2.get(prefix);
+  if (cid == null) {
+    const cid2 = base2.encode(bytes).slice(1);
+    cache2.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+}
+function toStringV1(bytes, cache2, base2) {
+  const { prefix } = base2;
+  const cid = cache2.get(prefix);
+  if (cid == null) {
+    const cid2 = base2.encode(bytes);
+    cache2.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+}
+var DAG_PB_CODE = 112;
+var SHA_256_CODE = 18;
+function encodeCID(version, code, multihash) {
+  const codeOffset = encodingLength(version);
+  const hashOffset = codeOffset + encodingLength(code);
+  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
+  encodeTo(version, bytes, 0);
+  encodeTo(code, bytes, codeOffset);
+  bytes.set(multihash, hashOffset);
+  return bytes;
+}
+var cidSymbol = Symbol.for("@ipld/js-cid/CID");
+
+// src/cid.ts
+function cidV0ToHex(cidV0) {
+  const cid = CID.parse(cidV0, base58btc);
+  if (cid.version !== 0) {
+    throw new Error(`Expected CIDv0, got CIDv${cid.version}`);
+  }
+  if (cid.multihash.code !== 18) {
+    throw new Error("Unsupported hash algorithm. Only SHA-256 is supported for CIDv0.");
+  }
+  const digest = cid.multihash.digest;
+  const hexString = `0x${Array.from(digest).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+  return hexString;
+}
+function cidV0ToUint8Array(cidV0) {
+  const cid = CID.parse(cidV0, base58btc);
+  if (cid.version !== 0) {
+    throw new Error(`Expected CIDv0, got CIDv${cid.version}`);
+  }
+  if (cid.multihash.code !== 18) {
+    throw new Error("Unsupported hash algorithm. Only SHA-256 is supported for CIDv0.");
+  }
+  return cid.multihash.digest;
+}
+// src/address.ts
+function uint256ToAddress(uint256) {
+  const hex = uint256.toString(16);
+  const paddedHex = hex.padStart(64, "0");
+  const addressHex = paddedHex.slice(-40);
+  return `0x${addressHex}`;
+}
+// src/constants.ts
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+// src/errors.ts
+class CirclesError extends Error {
+  name;
+  code;
+  source;
+  cause;
+  context;
+  constructor(name, message, options) {
+    super(message);
+    this.name = name;
+    this.code = options?.code;
+    this.source = options?.source ?? "UNKNOWN";
+    this.cause = options?.cause;
+    this.context = options?.context;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      source: this.source,
+      context: this.context,
+      cause: this.cause instanceof Error ? {
+        name: this.cause.name,
+        message: this.cause.message
+      } : this.cause,
+      stack: this.stack
+    };
+  }
+  toString() {
+    let result = `[${this.source}] ${this.name}: ${this.message}`;
+    if (this.code) {
+      result += ` (Code: ${this.code})`;
+    }
+    if (this.context) {
+      result += `
+Context: ${JSON.stringify(this.context, null, 2)}`;
+    }
+    return result;
+  }
+}
+
+class ValidationError extends CirclesError {
+  constructor(message, options) {
+    super("ValidationError", message, { ...options, source: "VALIDATION" });
+  }
+  static invalidAddress(address) {
+    return new ValidationError("Invalid Ethereum address", {
+      code: "VALIDATION_INVALID_ADDRESS",
+      context: { address }
+    });
+  }
+  static invalidAmount(amount, reason) {
+    return new ValidationError(reason || "Invalid amount", {
+      code: "VALIDATION_INVALID_AMOUNT",
+      context: { amount, reason }
+    });
+  }
+  static missingParameter(paramName) {
+    return new ValidationError(`Missing required parameter: ${paramName}`, {
+      code: "VALIDATION_MISSING_PARAM",
+      context: { paramName }
+    });
+  }
+  static invalidParameter(paramName, value, reason) {
+    return new ValidationError(`Invalid parameter '${paramName}': ${reason || "value is invalid"}`, {
+      code: "VALIDATION_INVALID_PARAM",
+      context: { paramName, value, reason }
+    });
+  }
+}
+
+class EncodingError extends CirclesError {
+  constructor(message, options) {
+    super("EncodingError", message, { ...options, source: "ENCODING" });
+  }
+  static abiEncoding(functionName, cause) {
+    return new EncodingError("Failed to encode ABI data", {
+      code: "ENCODING_ABI_FAILED",
+      cause,
+      context: { functionName }
+    });
+  }
+  static cidConversion(cid, cause) {
+    return new EncodingError("Failed to convert CID", {
+      code: "ENCODING_CID_FAILED",
+      cause,
+      context: { cid }
+    });
+  }
+}
+function wrapError(error, source = "UNKNOWN") {
+  if (error instanceof CirclesError) {
+    return error;
+  }
+  if (error instanceof Error) {
+    return new CirclesError(error.name || "UnknownError", error.message, {
+      source,
+      cause: error
+    });
+  }
+  return new CirclesError("UnknownError", String(error), {
+    source,
+    cause: error
+  });
+}
+function isCirclesError(error) {
+  return error instanceof CirclesError;
+}
+function getErrorMessage(error) {
+  if (isCirclesError(error)) {
+    return error.message;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/contractErrors.ts
+var ERROR_CODE_MESSAGES = {
+  0: "Avatar already registered",
+  1: "Avatar must be registered before inviting",
+  2: "Invalid invitation",
+  3: "Avatar must be registered",
+  4: "Only self can register",
+  5: "Maximum value reached",
+  6: "Inflationary supply already set",
+  7: "Group has no collateral",
+  161: "Trust to zero address is not allowed",
+  16: "Invalid parameter"
+};
+function extractErrorData(error) {
+  if (error?.details && typeof error.details === "string") {
+    const match = error.details.match(/err:\s*(0x[0-9a-fA-F]+)/);
+    if (match) {
+      return match[1];
+    }
+  }
+  if (error?.data && typeof error.data === "string" && error.data.startsWith("0x")) {
+    return error.data;
+  }
+  let currentError = error;
+  while (currentError) {
+    if (currentError.data && typeof currentError.data === "string") {
+      return currentError.data;
+    }
+    currentError = currentError.cause;
+  }
+  return null;
+}
+function formatErrorMessage(errorName, args, errorAbi) {
+  if (!args || args.length === 0) {
+    return errorName;
+  }
+  if (!errorAbi || !errorAbi.inputs) {
+    const formattedArgs = args.map((arg) => {
+      if (typeof arg === "bigint") {
+        return arg.toString();
+      }
+      return String(arg);
+    }).join(", ");
+    return `${errorName}(${formattedArgs})`;
+  }
+  const codeIndex = errorAbi.inputs.findIndex((input) => input.name === "code" || input.name === "" && input.type === "uint8");
+  let baseMessage = errorName;
+  let detailsParts = [];
+  if (codeIndex !== -1) {
+    const code = Number(args[codeIndex]);
+    const humanMessage = ERROR_CODE_MESSAGES[code];
+    if (humanMessage) {
+      baseMessage = humanMessage;
+    }
+  }
+  errorAbi.inputs.forEach((input, index) => {
+    const arg = args[index];
+    const name = input.name || `arg${index}`;
+    if (!input.name && input.type === "uint8") {
+      return;
+    }
+    let formattedValue;
+    if (typeof arg === "bigint") {
+      formattedValue = arg.toString();
+    } else if (typeof arg === "string" && arg.startsWith("0x")) {
+      formattedValue = arg;
+    } else {
+      formattedValue = String(arg);
+    }
+    if (name === "code" || input.type === "uint8") {
+      formattedValue = `0x${Number(arg).toString(16)}`;
+    }
+    detailsParts.push(`${name}: ${formattedValue}`);
+  });
+  if (detailsParts.length > 0) {
+    return `${baseMessage} (${detailsParts.join(", ")})`;
+  }
+  return baseMessage;
+}
+function parseContractError(error, abi) {
+  const errorData = extractErrorData(error);
+  if (!errorData) {
+    return null;
+  }
+  const decoded = decodeErrorResult({ abi, data: errorData });
+  if (!decoded) {
+    return null;
+  }
+  const errorAbi = abi.find((item) => item.type === "error" && item.name === decoded.errorName);
+  const selector = errorData.slice(0, 10);
+  const formattedMessage = formatErrorMessage(decoded.errorName, decoded.args, errorAbi);
+  return {
+    errorName: decoded.errorName,
+    args: decoded.args,
+    selector,
+    rawData: errorData,
+    formattedMessage
+  };
+}
+
+class ContractError extends CirclesError {
+  decodedError;
+  constructor(message, options) {
+    super("ContractError", message, { ...options, source: "CORE" });
+    this.decodedError = options?.decodedError;
+  }
+  static fromTransactionError(error, abi, context) {
+    const decoded = parseContractError(error, abi);
+    if (decoded) {
+      return new ContractError(`Transaction failed: ${decoded.formattedMessage}`, {
+        code: decoded.selector,
+        cause: error,
+        context: {
+          ...context,
+          errorName: decoded.errorName,
+          errorArgs: decoded.args
+        },
+        decodedError: decoded
+      });
+    }
+    const message = error?.message || String(error);
+    return new ContractError(`Transaction failed: ${message}`, {
+      cause: error,
+      context
+    });
+  }
+  toString() {
+    let result = super.toString();
+    if (this.decodedError) {
+      result += `
+Decoded Error: ${this.decodedError.formattedMessage}`;
+      if (this.decodedError.args && this.decodedError.args.length > 0) {
+        result += `
+Arguments: ${JSON.stringify(this.decodedError.args, (_, v) => typeof v === "bigint" ? v.toString() : v)}`;
+      }
+    }
+    return result;
+  }
+}
+export {
+  wrapError,
+  uint256ToAddress,
+  parseContractError,
+  isCirclesError,
+  getErrorMessage,
+  encodeFunctionData,
+  decodeFunctionResult,
+  decodeErrorResult,
+  cidV0ToUint8Array,
+  cidV0ToHex,
+  checksumAddress,
+  bytesToHex,
+  ZERO_ADDRESS,
+  ValidationError,
+  EncodingError,
+  ContractError,
+  CirclesError,
+  CirclesConverter
+};