@cfxjs/sirius-next-common 0.2.10 → 0.2.12

package/dist/chunk-6SXAFSBF.js

@@ -0,0 +1,1032 @@
+import {
+  AbiDecodingDataSizeTooSmallError,
+  AbiDecodingZeroDataError,
+  AbiFunctionNotFoundError,
+  AbiFunctionOutputsNotFoundError,
+  AbiFunctionSignatureNotFoundError,
+  BaseError,
+  InvalidAbiDecodingTypeError,
+  InvalidDefinitionTypeError,
+  bytesToBigInt,
+  bytesToBool,
+  bytesToHex,
+  bytesToNumber,
+  bytesToString,
+  checksumAddress,
+  decodeErrorResult,
+  decodeFunctionData,
+  decodeFunctionResult,
+  formatAbiItem,
+  hexToBytes,
+  isHex,
+  padHex,
+  size,
+  slice,
+  sliceBytes,
+  stringToBytes,
+  toEventSelector,
+  toFunctionSelector,
+  toHex,
+  trim
+} from "./chunk-JIRLY7OG.js";
+import {
+  NETWORK_ID
+} from "./chunk-WIB76E7O.js";
+import {
+  __publicField
+} from "./chunk-WQG2LZMB.js";
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/utils/lru.js
+var LruMap = class extends Map {
+  constructor(size2) {
+    super();
+    __publicField(this, "maxSize");
+    this.maxSize = size2;
+  }
+  get(key) {
+    const value = super.get(key);
+    if (super.has(key) && value !== void 0) {
+      this.delete(key);
+      super.set(key, value);
+    }
+    return value;
+  }
+  set(key, value) {
+    super.set(key, value);
+    if (this.maxSize && this.size > this.maxSize) {
+      const firstKey = this.keys().next().value;
+      if (firstKey)
+        this.delete(firstKey);
+    }
+    return this;
+  }
+};
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/errors/address.js
+var InvalidNetworkIdError = class extends BaseError {
+  constructor({ networkId, message }) {
+    super(`Invalid network id: ${networkId}. ${message || ""}`);
+    __publicField(this, "name", "InvalidNetworkIdError");
+  }
+};
+var ConvertBitExcessPaddingError = class extends BaseError {
+  constructor() {
+    super("Excess padding");
+    __publicField(this, "name", "ConvertBitExcessPaddingError");
+  }
+};
+var ConvertBitNonZeroPaddingError = class extends BaseError {
+  constructor() {
+    super("Non-zero padding");
+    __publicField(this, "name", "ConvertBitNonZeroPaddingError");
+  }
+};
+var MixedCaseAddressError = class extends BaseError {
+  constructor({ address }) {
+    super(`Mixed case address ${address}`);
+    __publicField(this, "name", "MixedCaseAddressError");
+  }
+};
+var InvalidAddressVersionError = class extends BaseError {
+  constructor({ address }) {
+    super(`Invalid address version ${address}`);
+    __publicField(this, "name", "InvalidAddressVersionError");
+  }
+};
+var AddressTypeNotMatchError = class extends BaseError {
+  constructor({ address }) {
+    super(`Address type not match ${address}`);
+    __publicField(this, "name", "AddressTypeNotMatchError");
+  }
+};
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/utils/address/convertBit.js
+function convertBit(buffer, inBits, outBits, isPad = false) {
+  const mask = (1 << outBits) - 1;
+  const array = [];
+  let bits = 0;
+  let value = 0;
+  for (const byte of buffer) {
+    bits += inBits;
+    value = value << inBits | byte;
+    while (bits >= outBits) {
+      bits -= outBits;
+      array.push(value >>> bits & mask);
+    }
+  }
+  value = value << outBits - bits & mask;
+  if (bits && isPad) {
+    array.push(value);
+  } else if (value && !isPad) {
+    throw new ConvertBitExcessPaddingError();
+  } else if (bits >= inBits && !isPad) {
+    throw new ConvertBitNonZeroPaddingError();
+  }
+  return array;
+}
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/utils/address/getAddressType.js
+function getAddressTypeByHexAddress(hexAddressUit8Array) {
+  switch (hexAddressUit8Array[0] & 240) {
+    case 16:
+      return "user";
+    case 128:
+      return "contract";
+    case 0:
+      for (const x of hexAddressUit8Array) {
+        if (x !== 0)
+          return "builtin";
+      }
+      return "null";
+    default:
+      return "unknown";
+  }
+}
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/constants/networkId.js
+var mainNetworkId = 1029;
+var testNetworkId = 1;
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/constants/networkName.js
+var mainNetworkName = "cfx";
+var testNetworkName = "cfxtest";
+var otherNetworkName = "net";
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/utils/address/isValidNetworkId.js
+var NET_ID_LIMIT = 4294967295;
+function isValidNetworkId(networkId) {
+  if (typeof networkId === "string") {
+    return /^([1-9]\d*)$/.test(networkId) && Number(networkId) <= NET_ID_LIMIT;
+  }
+  return networkId > 0 && networkId < NET_ID_LIMIT;
+}
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/utils/address/getNetworkIdByNetworkIdPrefix.js
+function getNetworkIdByNetworkIdPrefix(networkName) {
+  const lowerCaseNetworkName = networkName.toLowerCase();
+  if (lowerCaseNetworkName === mainNetworkName) {
+    return mainNetworkId;
+  }
+  if (lowerCaseNetworkName === testNetworkName) {
+    return testNetworkId;
+  }
+  const netPrefix = lowerCaseNetworkName.slice(0, 3);
+  const strNetId = lowerCaseNetworkName.slice(3);
+  if (!isValidNetworkId(strNetId)) {
+    throw new InvalidNetworkIdError({ networkId: strNetId });
+  }
+  if (netPrefix !== otherNetworkName) {
+    throw new InvalidNetworkIdError({
+      networkId: strNetId,
+      message: "netId prefix should be passed by 'cfx', 'cfxtest' or 'net[n]'"
+    });
+  }
+  const netId = Number(strNetId);
+  if (netId === mainNetworkId || netId === testNetworkId) {
+    throw new InvalidNetworkIdError({
+      networkId: strNetId,
+      message: "net1 or net1029 are invalid"
+    });
+  }
+  return netId;
+}
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/utils/address/getNetworkIdPrefixByNetworkId.js
+function getNetworkPrefixByNetworkId(networkId) {
+  if (!isValidNetworkId(networkId)) {
+    throw new InvalidNetworkIdError({ networkId });
+  }
+  if (networkId === mainNetworkId) {
+    return "cfx";
+  }
+  if (networkId === testNetworkId) {
+    return "cfxtest";
+  }
+  return `net${networkId}`;
+}
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/utils/address/polyMod.js
+var BIGINT_0 = 0n;
+var BIGINT_1 = 1n;
+var BIGINT_5 = 5n;
+var BIGINT_35 = 35n;
+var BIGINT_0B00001 = 1n;
+var BIGINT_0B00010 = 2n;
+var BIGINT_0B00100 = 4n;
+var BIGINT_0B01000 = 8n;
+var BIGINT_0B10000 = 16n;
+var BIGINT_0X07FFFFFFFF = 34359738367n;
+var BIGINT_0X98F2BC8E61 = 656907472481n;
+var BIGINT_0X79B76D99E2 = 522768456162n;
+var BIGINT_0XF33E5FB3C4 = 1044723512260n;
+var BIGINT_0XAE2EABE2A8 = 748107326120n;
+var BIGINT_0X1E4F43E470 = 130178868336n;
+function polyMod(buffer) {
+  let checksumBigInt = BIGINT_1;
+  for (const byte of buffer) {
+    const high = checksumBigInt >> BIGINT_35;
+    checksumBigInt = (checksumBigInt & BIGINT_0X07FFFFFFFF) << BIGINT_5;
+    checksumBigInt = byte ? checksumBigInt ^ BigInt(byte) : checksumBigInt;
+    if ((high & BIGINT_0B00001) !== BIGINT_0) {
+      checksumBigInt = checksumBigInt ^ BIGINT_0X98F2BC8E61;
+    }
+    if ((high & BIGINT_0B00010) !== BIGINT_0) {
+      checksumBigInt = checksumBigInt ^ BIGINT_0X79B76D99E2;
+    }
+    if ((high & BIGINT_0B00100) !== BIGINT_0) {
+      checksumBigInt = checksumBigInt ^ BIGINT_0XF33E5FB3C4;
+    }
+    if ((high & BIGINT_0B01000) !== BIGINT_0) {
+      checksumBigInt = checksumBigInt ^ BIGINT_0XAE2EABE2A8;
+    }
+    if ((high & BIGINT_0B10000) !== BIGINT_0) {
+      checksumBigInt = checksumBigInt ^ BIGINT_0X1E4F43E470;
+    }
+  }
+  return checksumBigInt ^ BIGINT_1;
+}
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/utils/address/hexAddressToBase32.js
+var VERSION_BYTE = 0;
+var ALPHABET = "ABCDEFGHJKMNPRSTUVWXYZ0123456789";
+function hexAddressToBase32({ hexAddress, networkId, verbose }) {
+  const hexBuffer = hexToBytes(hexAddress);
+  const addressType = getAddressTypeByHexAddress(hexBuffer);
+  const netName = getNetworkPrefixByNetworkId(networkId).toUpperCase();
+  const netName5Bits = stringToBytes(netName).map((_byte) => _byte & 31);
+  const payload5Bits = convertBit(new Uint8Array([VERSION_BYTE, ...hexBuffer]), 8, 5, true);
+  const checksumBigInt = polyMod(new Uint8Array([
+    ...netName5Bits,
+    0,
+    ...payload5Bits,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+  ]));
+  let checksumHex = toHex(checksumBigInt);
+  if (checksumHex.length < 12) {
+    checksumHex = padHex(checksumHex, { dir: "left", size: 5 });
+  }
+  const checksumBytes = hexToBytes(checksumHex);
+  const checksum5Bits = convertBit(checksumBytes, 8, 5, true);
+  const payload = payload5Bits.map((_byte2) => ALPHABET[_byte2]).join("");
+  const checksum = checksum5Bits.map((_byte3) => ALPHABET[_byte3]).join("");
+  return verbose ? `${netName}:TYPE.${addressType.toUpperCase()}:${payload}${checksum}` : `${netName}:${payload}${checksum}`.toLowerCase();
+}
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/utils/address/decodeBase32Address.js
+var ALPHABET_MAP = {
+  "0": 22,
+  "1": 23,
+  "2": 24,
+  "3": 25,
+  "4": 26,
+  "5": 27,
+  "6": 28,
+  "7": 29,
+  "8": 30,
+  "9": 31,
+  A: 0,
+  B: 1,
+  C: 2,
+  D: 3,
+  E: 4,
+  F: 5,
+  G: 6,
+  H: 7,
+  J: 8,
+  K: 9,
+  M: 10,
+  N: 11,
+  P: 12,
+  R: 13,
+  S: 14,
+  T: 15,
+  U: 16,
+  V: 17,
+  W: 18,
+  X: 19,
+  Y: 20,
+  Z: 21
+};
+function decodeBase32Address({ address, strict = true }) {
+  if (address !== address.toLowerCase() && address !== address.toUpperCase()) {
+    throw new MixedCaseAddressError({ address });
+  }
+  const [, netName, shouldHaveType, payload, checksum] = address.toUpperCase().match(/^([^:]+):(.+:)?(.{34})(.{8})$/) || ["", "", "", "", ""];
+  const netName5Bits = stringToBytes(netName).map((_byte) => _byte & 31);
+  const payload5Bits = Array.from(payload, (char) => ALPHABET_MAP[char]);
+  const checksum5Bits = Array.from(checksum, (char) => ALPHABET_MAP[char]);
+  const [version, ...addressBytes] = convertBit(new Uint8Array([...payload5Bits]), 5, 8);
+  if (version !== VERSION_BYTE) {
+    throw new InvalidAddressVersionError({ address });
+  }
+  const byteAddress = new Uint8Array([...addressBytes]);
+  const networkId = getNetworkIdByNetworkIdPrefix(netName);
+  const type = getAddressTypeByHexAddress(byteAddress);
+  if (shouldHaveType && `type.${type}:` !== shouldHaveType.toLowerCase()) {
+    throw new AddressTypeNotMatchError({ address });
+  }
+  if (strict) {
+    const valid = polyMod(new Uint8Array([...netName5Bits, 0, ...payload5Bits, ...checksum5Bits]));
+    if (valid) {
+      throw new InvalidAddressVersionError({ address });
+    }
+  }
+  return {
+    address: bytesToHex(byteAddress),
+    type,
+    networkId
+  };
+}
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/utils/address/base32AddressToHex.js
+function base32AddressToHex({ address, strict = true }) {
+  if (address !== address.toLowerCase() && address !== address.toUpperCase()) {
+    throw new MixedCaseAddressError({ address });
+  }
+  const addressInfo = decodeBase32Address({ address, strict });
+  return addressInfo.address;
+}
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/utils/address/isAddress.js
+var isAddressCache = /* @__PURE__ */ new LruMap(8192);
+function isAddress(address) {
+  if (isAddressCache.has(address))
+    return isAddressCache.get(address);
+  const result = (() => {
+    if (address.toLowerCase() !== address && address.toUpperCase() !== address)
+      return false;
+    try {
+      const addr = base32AddressToHex({ address });
+      return !!addr;
+    } catch (_error) {
+      return false;
+    }
+  })();
+  isAddressCache.set(address, result);
+  return result;
+}
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/utils/abi/encodeAbiParameters.js
+function getArrayComponents(type) {
+  const matches = type.match(/^(.*)\[(\d+)?\]$/);
+  return matches ? (
+    // Return `null` if the array is dynamic.
+    [matches[2] ? Number(matches[2]) : null, matches[1]]
+  ) : void 0;
+}
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/errors/cursor.js
+var NegativeOffsetError = class extends BaseError {
+  constructor({ offset }) {
+    super(`Offset \`${offset}\` cannot be negative.`);
+    __publicField(this, "name", "NegativeOffsetError");
+  }
+};
+var PositionOutOfBoundsError = class extends BaseError {
+  constructor({ length, position }) {
+    super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`);
+    __publicField(this, "name", "PositionOutOfBoundsError");
+  }
+};
+var RecursiveReadLimitExceededError = class extends BaseError {
+  constructor({ count, limit }) {
+    super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`);
+    __publicField(this, "name", "RecursiveReadLimitExceededError");
+  }
+};
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/utils/cursor.js
+var staticCursor = {
+  bytes: new Uint8Array(),
+  dataView: new DataView(new ArrayBuffer(0)),
+  position: 0,
+  positionReadCount: /* @__PURE__ */ new Map(),
+  recursiveReadCount: 0,
+  recursiveReadLimit: Number.POSITIVE_INFINITY,
+  assertReadLimit() {
+    if (this.recursiveReadCount >= this.recursiveReadLimit)
+      throw new RecursiveReadLimitExceededError({
+        count: this.recursiveReadCount + 1,
+        limit: this.recursiveReadLimit
+      });
+  },
+  assertPosition(position) {
+    if (position < 0 || position > this.bytes.length - 1)
+      throw new PositionOutOfBoundsError({
+        length: this.bytes.length,
+        position
+      });
+  },
+  decrementPosition(offset) {
+    if (offset < 0)
+      throw new NegativeOffsetError({ offset });
+    const position = this.position - offset;
+    this.assertPosition(position);
+    this.position = position;
+  },
+  getReadCount(position) {
+    return this.positionReadCount.get(position || this.position) || 0;
+  },
+  incrementPosition(offset) {
+    if (offset < 0)
+      throw new NegativeOffsetError({ offset });
+    const position = this.position + offset;
+    this.assertPosition(position);
+    this.position = position;
+  },
+  inspectByte(position_) {
+    const position = position_ ?? this.position;
+    this.assertPosition(position);
+    return this.bytes[position];
+  },
+  inspectBytes(length, position_) {
+    const position = position_ ?? this.position;
+    this.assertPosition(position + length - 1);
+    return this.bytes.subarray(position, position + length);
+  },
+  inspectUint8(position_) {
+    const position = position_ ?? this.position;
+    this.assertPosition(position);
+    return this.bytes[position];
+  },
+  inspectUint16(position_) {
+    const position = position_ ?? this.position;
+    this.assertPosition(position + 1);
+    return this.dataView.getUint16(position);
+  },
+  inspectUint24(position_) {
+    const position = position_ ?? this.position;
+    this.assertPosition(position + 2);
+    return (this.dataView.getUint16(position) << 8) + this.dataView.getUint8(position + 2);
+  },
+  inspectUint32(position_) {
+    const position = position_ ?? this.position;
+    this.assertPosition(position + 3);
+    return this.dataView.getUint32(position);
+  },
+  pushByte(byte) {
+    this.assertPosition(this.position);
+    this.bytes[this.position] = byte;
+    this.position++;
+  },
+  pushBytes(bytes) {
+    this.assertPosition(this.position + bytes.length - 1);
+    this.bytes.set(bytes, this.position);
+    this.position += bytes.length;
+  },
+  pushUint8(value) {
+    this.assertPosition(this.position);
+    this.bytes[this.position] = value;
+    this.position++;
+  },
+  pushUint16(value) {
+    this.assertPosition(this.position + 1);
+    this.dataView.setUint16(this.position, value);
+    this.position += 2;
+  },
+  pushUint24(value) {
+    this.assertPosition(this.position + 2);
+    this.dataView.setUint16(this.position, value >> 8);
+    this.dataView.setUint8(this.position + 2, value & ~4294967040);
+    this.position += 3;
+  },
+  pushUint32(value) {
+    this.assertPosition(this.position + 3);
+    this.dataView.setUint32(this.position, value);
+    this.position += 4;
+  },
+  readByte() {
+    this.assertReadLimit();
+    this._touch();
+    const value = this.inspectByte();
+    this.position++;
+    return value;
+  },
+  readBytes(length, size2) {
+    this.assertReadLimit();
+    this._touch();
+    const value = this.inspectBytes(length);
+    this.position += size2 ?? length;
+    return value;
+  },
+  readUint8() {
+    this.assertReadLimit();
+    this._touch();
+    const value = this.inspectUint8();
+    this.position += 1;
+    return value;
+  },
+  readUint16() {
+    this.assertReadLimit();
+    this._touch();
+    const value = this.inspectUint16();
+    this.position += 2;
+    return value;
+  },
+  readUint24() {
+    this.assertReadLimit();
+    this._touch();
+    const value = this.inspectUint24();
+    this.position += 3;
+    return value;
+  },
+  readUint32() {
+    this.assertReadLimit();
+    this._touch();
+    const value = this.inspectUint32();
+    this.position += 4;
+    return value;
+  },
+  get remaining() {
+    return this.bytes.length - this.position;
+  },
+  setPosition(position) {
+    const oldPosition = this.position;
+    this.assertPosition(position);
+    this.position = position;
+    return () => this.position = oldPosition;
+  },
+  _touch() {
+    if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
+      return;
+    const count = this.getReadCount();
+    this.positionReadCount.set(this.position, count + 1);
+    if (count > 0)
+      this.recursiveReadCount++;
+  }
+};
+function createCursor(bytes, { recursiveReadLimit = 8192 } = {}) {
+  const cursor = Object.create(staticCursor);
+  cursor.bytes = bytes;
+  cursor.dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  cursor.positionReadCount = /* @__PURE__ */ new Map();
+  cursor.recursiveReadLimit = recursiveReadLimit;
+  return cursor;
+}
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/utils/abi/decodeAbiParameters.js
+function decodeAbiParameters(params, data, networkId) {
+  const bytes = typeof data === "string" ? hexToBytes(data) : data;
+  const cursor = createCursor(bytes);
+  if (size(bytes) === 0 && params.length > 0)
+    throw new AbiDecodingZeroDataError();
+  if (size(data) && size(data) < 32)
+    throw new AbiDecodingDataSizeTooSmallError({
+      data: typeof data === "string" ? data : bytesToHex(data),
+      params,
+      size: size(data)
+    });
+  let consumed = 0;
+  const values = [];
+  for (let i = 0; i < params.length; ++i) {
+    const param = params[i];
+    cursor.setPosition(consumed);
+    const [data2, consumed_] = decodeParameter(cursor, param, {
+      networkId,
+      staticPosition: 0
+    });
+    consumed += consumed_;
+    values.push(data2);
+  }
+  return values;
+}
+function decodeParameter(cursor, param, { staticPosition, networkId }) {
+  const arrayComponents = getArrayComponents(param.type);
+  if (arrayComponents) {
+    const [length, type] = arrayComponents;
+    return decodeArray(cursor, { ...param, type }, { length, staticPosition, networkId });
+  }
+  if (param.type === "tuple")
+    return decodeTuple(cursor, param, {
+      staticPosition,
+      networkId
+    });
+  if (param.type === "address")
+    return decodeAddress(cursor, networkId);
+  if (param.type === "bool")
+    return decodeBool(cursor);
+  if (param.type.startsWith("bytes"))
+    return decodeBytes(cursor, param, { staticPosition });
+  if (param.type.startsWith("uint") || param.type.startsWith("int"))
+    return decodeNumber(cursor, param);
+  if (param.type === "string")
+    return decodeString(cursor, { staticPosition });
+  throw new InvalidAbiDecodingTypeError(param.type, {
+    docsPath: "/docs/contract/decodeAbiParameters"
+  });
+}
+var sizeOfLength = 32;
+var sizeOfOffset = 32;
+function decodeAddress(cursor, networkId) {
+  const value = cursor.readBytes(32);
+  const hexAddress = checksumAddress(bytesToHex(sliceBytes(value, -20)));
+  const base32Address = hexAddressToBase32({ hexAddress, networkId });
+  return [base32Address, 32];
+}
+function decodeArray(cursor, param, { length, staticPosition, networkId }) {
+  if (!length) {
+    const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
+    const start = staticPosition + offset;
+    const startOfData = start + sizeOfLength;
+    cursor.setPosition(start);
+    const length2 = bytesToNumber(cursor.readBytes(sizeOfLength));
+    const dynamicChild = hasDynamicChild(param);
+    let consumed2 = 0;
+    const value2 = [];
+    for (let i = 0; i < length2; ++i) {
+      cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed2));
+      const [data, consumed_] = decodeParameter(cursor, param, {
+        staticPosition: startOfData,
+        networkId
+      });
+      consumed2 += consumed_;
+      value2.push(data);
+    }
+    cursor.setPosition(staticPosition + 32);
+    return [value2, 32];
+  }
+  if (hasDynamicChild(param)) {
+    const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
+    const start = staticPosition + offset;
+    const value2 = [];
+    for (let i = 0; i < length; ++i) {
+      cursor.setPosition(start + i * 32);
+      const [data] = decodeParameter(cursor, param, {
+        staticPosition: start,
+        networkId
+      });
+      value2.push(data);
+    }
+    cursor.setPosition(staticPosition + 32);
+    return [value2, 32];
+  }
+  let consumed = 0;
+  const value = [];
+  for (let i = 0; i < length; ++i) {
+    const [data, consumed_] = decodeParameter(cursor, param, {
+      staticPosition: staticPosition + consumed,
+      networkId
+    });
+    consumed += consumed_;
+    value.push(data);
+  }
+  return [value, consumed];
+}
+function decodeBool(cursor) {
+  return [bytesToBool(cursor.readBytes(32), { size: 32 }), 32];
+}
+function decodeBytes(cursor, param, { staticPosition }) {
+  const [_, size2] = param.type.split("bytes");
+  if (!size2) {
+    const offset = bytesToNumber(cursor.readBytes(32));
+    cursor.setPosition(staticPosition + offset);
+    const length = bytesToNumber(cursor.readBytes(32));
+    if (length === 0) {
+      cursor.setPosition(staticPosition + 32);
+      return ["0x", 32];
+    }
+    const data = cursor.readBytes(length);
+    cursor.setPosition(staticPosition + 32);
+    return [bytesToHex(data), 32];
+  }
+  const value = bytesToHex(cursor.readBytes(Number.parseInt(size2), 32));
+  return [value, 32];
+}
+function decodeNumber(cursor, param) {
+  const signed = param.type.startsWith("int");
+  const size2 = Number.parseInt(param.type.split("int")[1] || "256");
+  const value = cursor.readBytes(32);
+  return [
+    size2 > 48 ? bytesToBigInt(value, { signed }) : bytesToNumber(value, { signed }),
+    32
+  ];
+}
+function decodeTuple(cursor, param, { staticPosition, networkId }) {
+  const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
+  const value = hasUnnamedChild ? [] : {};
+  let consumed = 0;
+  if (hasDynamicChild(param)) {
+    const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
+    const start = staticPosition + offset;
+    for (let i = 0; i < param.components.length; ++i) {
+      const component = param.components[i];
+      cursor.setPosition(start + consumed);
+      const [data, consumed_] = decodeParameter(cursor, component, {
+        staticPosition: start,
+        networkId
+      });
+      consumed += consumed_;
+      value[hasUnnamedChild ? i : component?.name] = data;
+    }
+    cursor.setPosition(staticPosition + 32);
+    return [value, 32];
+  }
+  for (let i = 0; i < param.components.length; ++i) {
+    const component = param.components[i];
+    const [data, consumed_] = decodeParameter(cursor, component, {
+      staticPosition,
+      networkId
+    });
+    value[hasUnnamedChild ? i : component?.name] = data;
+    consumed += consumed_;
+  }
+  return [value, consumed];
+}
+function decodeString(cursor, { staticPosition }) {
+  const offset = bytesToNumber(cursor.readBytes(32));
+  const start = staticPosition + offset;
+  cursor.setPosition(start);
+  const length = bytesToNumber(cursor.readBytes(32));
+  if (length === 0) {
+    cursor.setPosition(staticPosition + 32);
+    return ["", 32];
+  }
+  const data = cursor.readBytes(length, 32);
+  const value = bytesToString(trim(data));
+  cursor.setPosition(staticPosition + 32);
+  return [value, 32];
+}
+function hasDynamicChild(param) {
+  const { type } = param;
+  if (type === "string")
+    return true;
+  if (type === "bytes")
+    return true;
+  if (type.endsWith("[]"))
+    return true;
+  if (type === "tuple")
+    return param.components?.some(hasDynamicChild);
+  const arrayComponents = getArrayComponents(param.type);
+  if (arrayComponents && hasDynamicChild({ ...param, type: arrayComponents[1] }))
+    return true;
+  return false;
+}
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/utils/abi/formatAbiItem.js
+function formatAbiItem2(abiItem, { includeName = false } = {}) {
+  if (abiItem.type !== "function" && abiItem.type !== "event" && abiItem.type !== "error")
+    throw new InvalidDefinitionTypeError(abiItem.type);
+  return `${abiItem.name}(${formatAbiParams2(abiItem.inputs, { includeName })})`;
+}
+function formatAbiParams2(params, { includeName = false } = {}) {
+  if (!params)
+    return "";
+  return params.map((param) => formatAbiParam(param, { includeName })).join(includeName ? ", " : ",");
+}
+function formatAbiParam(param, { includeName }) {
+  if (param.type.startsWith("tuple")) {
+    return `(${formatAbiParams2(param.components, { includeName })})${param.type.slice("tuple".length)}`;
+  }
+  return param.type + (includeName && param.name ? ` ${param.name}` : "");
+}
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/utils/abi/decodeFunctionData.js
+function decodeFunctionData2(parameters) {
+  const { abi, data, networkId } = parameters;
+  const signature = slice(data, 0, 4);
+  const description = abi.find((x) => x.type === "function" && signature === toFunctionSelector(formatAbiItem(x)));
+  if (!description)
+    throw new AbiFunctionSignatureNotFoundError(signature, {
+      docsPath: "/docs/contract/decodeFunctionData"
+    });
+  return {
+    functionName: description.name,
+    args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbiParameters(description.inputs, slice(data, 4), networkId) : void 0
+  };
+}
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/types/abi.js
+var AbiItemAmbiguityError = class extends BaseError {
+  constructor(x, y) {
+    super("Found ambiguous types in overloaded ABI items.", {
+      metaMessages: [
+        `\`${x.type}\` in \`${formatAbiItem(x.abiItem)}\`, and`,
+        `\`${y.type}\` in \`${formatAbiItem(y.abiItem)}\``,
+        "",
+        "These types encode differently and cannot be distinguished at runtime.",
+        "Remove one of the ambiguous items in the ABI."
+      ]
+    });
+    __publicField(this, "name", "AbiItemAmbiguityError");
+  }
+};
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/utils/abi/getAbiItem.js
+function getAbiItem2(parameters) {
+  const { abi, args = [], name } = parameters;
+  const isSelector = isHex(name, { strict: false });
+  const abiItems = abi.filter((abiItem) => {
+    if (isSelector) {
+      if (abiItem.type === "function")
+        return toFunctionSelector(abiItem) === name;
+      if (abiItem.type === "event")
+        return toEventSelector(abiItem) === name;
+      return false;
+    }
+    return "name" in abiItem && abiItem.name === name;
+  });
+  if (abiItems.length === 0)
+    return void 0;
+  if (abiItems.length === 1)
+    return abiItems[0];
+  let matchedAbiItem = void 0;
+  for (const abiItem of abiItems) {
+    if (!("inputs" in abiItem))
+      continue;
+    if (!args || args.length === 0) {
+      if (!abiItem.inputs || abiItem.inputs.length === 0)
+        return abiItem;
+      continue;
+    }
+    if (!abiItem.inputs)
+      continue;
+    if (abiItem.inputs.length === 0)
+      continue;
+    if (abiItem.inputs.length !== args.length)
+      continue;
+    const matched = args.every((arg, index) => {
+      const abiParameter = "inputs" in abiItem && abiItem.inputs[index];
+      if (!abiParameter)
+        return false;
+      return isArgOfType(arg, abiParameter);
+    });
+    if (matched) {
+      if (matchedAbiItem && "inputs" in matchedAbiItem && matchedAbiItem.inputs) {
+        const ambiguousTypes = getAmbiguousTypes(abiItem.inputs, matchedAbiItem.inputs, args);
+        if (ambiguousTypes)
+          throw new AbiItemAmbiguityError({
+            abiItem,
+            type: ambiguousTypes[0]
+          }, {
+            abiItem: matchedAbiItem,
+            type: ambiguousTypes[1]
+          });
+      }
+      matchedAbiItem = abiItem;
+    }
+  }
+  if (matchedAbiItem)
+    return matchedAbiItem;
+  return abiItems[0];
+}
+function isArgOfType(arg, abiParameter) {
+  const argType = typeof arg;
+  const abiParameterType = abiParameter.type;
+  switch (abiParameterType) {
+    case "address":
+      return isAddress(arg);
+    case "bool":
+      return argType === "boolean";
+    case "function":
+      return argType === "string";
+    case "string":
+      return argType === "string";
+    default: {
+      if (abiParameterType === "tuple" && "components" in abiParameter)
+        return Object.values(abiParameter.components).every((component, index) => {
+          return isArgOfType(Object.values(arg)[index], component);
+        });
+      if (/^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(abiParameterType))
+        return argType === "number" || argType === "bigint";
+      if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))
+        return argType === "string" || arg instanceof Uint8Array;
+      if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
+        return Array.isArray(arg) && arg.every((x) => isArgOfType(x, {
+          ...abiParameter,
+          // Pop off `[]` or `[M]` from end of type
+          type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, "")
+        }));
+      }
+      return false;
+    }
+  }
+}
+function getAmbiguousTypes(sourceParameters, targetParameters, args) {
+  for (const parameterIndex in sourceParameters) {
+    const sourceParameter = sourceParameters[parameterIndex];
+    const targetParameter = targetParameters[parameterIndex];
+    if (sourceParameter.type === "tuple" && targetParameter.type === "tuple" && "components" in sourceParameter && "components" in targetParameter)
+      return getAmbiguousTypes(sourceParameter.components, targetParameter.components, args[parameterIndex]);
+    const types = [sourceParameter.type, targetParameter.type];
+    const ambiguous = (() => {
+      if (types.includes("address") && types.includes("bytes20"))
+        return true;
+      if (types.includes("address") && types.includes("string"))
+        return isAddress(args[parameterIndex]);
+      if (types.includes("address") && types.includes("bytes"))
+        return isAddress(args[parameterIndex]);
+      return false;
+    })();
+    if (ambiguous)
+      return types;
+  }
+  return;
+}
+
+// ../../node_modules/.pnpm/cive@0.8.1_bufferutil@4.0.8_typescript@5.4.3_utf-8-validate@5.0.10/node_modules/cive/_esm/utils/abi/decodeFunctionResult.js
+var docsPath = "/docs/contract/decodeFunctionResult";
+function decodeFunctionResult2(parameters) {
+  const { abi, args, functionName, data, networkId } = parameters;
+  let abiItem = abi[0];
+  if (functionName) {
+    const item = getAbiItem2({ abi, args, name: functionName });
+    if (!item)
+      throw new AbiFunctionNotFoundError(functionName, { docsPath });
+    abiItem = item;
+  }
+  if (abiItem.type !== "function")
+    throw new AbiFunctionNotFoundError(void 0, { docsPath });
+  if (!abiItem.outputs)
+    throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath });
+  const values = decodeAbiParameters(abiItem.outputs, data, networkId);
+  if (values && values.length > 1)
+    return values;
+  if (values && values.length === 1)
+    return values[0];
+  return void 0;
+}
+
+// src/utils/sdk.ts
+var decodeFunctionData3 = ({
+  data,
+  abi,
+  space
+}) => {
+  if (space === "core") {
+    return decodeFunctionData2({
+      data,
+      abi,
+      networkId: NETWORK_ID
+    });
+  } else {
+    return decodeFunctionData({
+      data,
+      abi
+    });
+  }
+};
+var decodeFunctionResult3 = ({
+  data,
+  abi,
+  functionName,
+  space
+}) => {
+  if (space === "core") {
+    return decodeFunctionResult2({
+      data,
+      functionName,
+      abi,
+      networkId: NETWORK_ID
+    });
+  } else {
+    return decodeFunctionResult({
+      data,
+      functionName,
+      abi
+    });
+  }
+};
+var decodeErrorResult2 = ({
+  data,
+  abi,
+  space
+}) => {
+  if (space === "core") {
+    if (data.length < 10 || !data.startsWith("0x"))
+      throw new Error("Invalid data");
+    const signature = data.slice(0, 10);
+    const abiItem = abi.find(
+      (x) => x.type === "error" && signature === toFunctionSelector(formatAbiItem2(x))
+    );
+    if (!abiItem)
+      throw new Error(`not found abi item for error signature: ${signature}`);
+    return {
+      abiItem,
+      args: "inputs" in abiItem && abiItem.inputs && abiItem.inputs.length > 0 ? decodeAbiParameters(
+        abiItem.inputs,
+        `0x${data.slice(10)}`,
+        NETWORK_ID
+      ) : void 0,
+      errorName: abiItem.name
+    };
+  } else {
+    return decodeErrorResult({
+      data,
+      abi
+    });
+  }
+};
+
+export {
+  decodeFunctionData3 as decodeFunctionData,
+  decodeFunctionResult3 as decodeFunctionResult,
+  decodeErrorResult2 as decodeErrorResult
+};
+//# sourceMappingURL=chunk-6SXAFSBF.js.map