@digitalworld/digital-world-sdk 16.0.0

package/lib/cjs/http-client/types.js

@@ -0,0 +1,24 @@
+'use strict';
+
+class CancelToken {
+  promise;
+  reason;
+  throwIfRequested() {
+    if (this.reason) {
+      throw new Error(this.reason);
+    }
+  }
+  constructor(executor) {
+    let resolvePromise;
+    this.promise = new Promise((resolve) => {
+      resolvePromise = resolve;
+    });
+    executor((reason) => {
+      this.reason = reason;
+      resolvePromise();
+    });
+  }
+}
+
+exports.CancelToken = CancelToken;
+//# sourceMappingURL=types.js.map

package/lib/cjs/http-client/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":["../../../src/http-client/types.ts"],"sourcesContent":["export type HttpResponseHeaders = Record<\n  string,\n  string | boolean | undefined\n> & {\n  \"set-cookie\"?: string[];\n};\n\nexport interface HttpClientDefaults extends Omit<\n  HttpClientRequestConfig,\n  \"headers\"\n> {\n  headers?: [string, string][] | Record<string, string> | Headers | undefined;\n}\n\nexport interface HttpClientResponse<T = any> {\n  data: T;\n  headers: HttpResponseHeaders;\n  config: any;\n  status: number;\n  statusText: string;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging -- intentionally merged with the CancelToken class below to declare its members\nexport interface CancelToken {\n  promise: Promise<void>;\n  throwIfRequested(): void;\n  reason?: string;\n}\n\ntype HeadersInit = [string, string][] | Record<string, string> | Headers;\n\nexport interface HttpClientRequestConfig<D = any> {\n  url?: string;\n  method?: string;\n  baseURL?: string;\n  data?: D;\n  timeout?: number;\n  fetchOptions?: Record<string, any>;\n  headers?: HeadersInit;\n  params?: Record<string, any>;\n  maxContentLength?: number;\n  maxRedirects?: number;\n  cancelToken?: CancelToken;\n  adapter?: (config: HttpClientRequestConfig) => Promise<HttpClientResponse>;\n}\n\nexport interface HttpClient {\n  get: <T = any>(\n    url: string,\n    config?: HttpClientRequestConfig,\n  ) => Promise<HttpClientResponse<T>>;\n  delete: <T = any>(\n    url: string,\n    config?: HttpClientRequestConfig,\n  ) => Promise<HttpClientResponse<T>>;\n  head: <T = any>(\n    url: string,\n    config?: HttpClientRequestConfig,\n  ) => Promise<HttpClientResponse<T>>;\n  options: <T = any>(\n    url: string,\n    config?: HttpClientRequestConfig,\n  ) => Promise<HttpClientResponse<T>>;\n  post: <T = any>(\n    url: string,\n    data?: any,\n    config?: HttpClientRequestConfig,\n  ) => Promise<HttpClientResponse<T>>;\n  put: <T = any>(\n    url: string,\n    data?: any,\n    config?: HttpClientRequestConfig,\n  ) => Promise<HttpClientResponse<T>>;\n  patch: <T = any>(\n    url: string,\n    data?: any,\n    config?: HttpClientRequestConfig,\n  ) => Promise<HttpClientResponse<T>>;\n  postForm: <T = any>(\n    url: string,\n    data?: any,\n    config?: HttpClientRequestConfig,\n  ) => Promise<HttpClientResponse<T>>;\n  putForm: <T = any>(\n    url: string,\n    data?: any,\n    config?: HttpClientRequestConfig,\n  ) => Promise<HttpClientResponse<T>>;\n  patchForm: <T = any>(\n    url: string,\n    data?: any,\n    config?: HttpClientRequestConfig,\n  ) => Promise<HttpClientResponse<T>>;\n  interceptors: {\n    request: InterceptorManager<HttpClientRequestConfig>;\n    response: InterceptorManager<HttpClientResponse>;\n  };\n  defaults: HttpClientDefaults;\n  CancelToken: typeof CancelToken;\n  isCancel: (value: any) => boolean;\n  makeRequest: <T = any>(\n    config: HttpClientRequestConfig,\n  ) => Promise<HttpClientResponse<T>>;\n  create: (config?: HttpClientRequestConfig) => HttpClient;\n}\n\nexport interface Interceptor<V> {\n  fulfilled: (value: V) => V | Promise<V>;\n  rejected?: (error: any) => any;\n}\n\nexport interface InterceptorManager<V> {\n  use(\n    fulfilled: (value: V) => V | Promise<V>,\n    rejected?: (error: any) => any,\n  ): number;\n  eject(id: number): void;\n  forEach(fn: (interceptor: Interceptor<V>) => void): void;\n  handlers: Array<Interceptor<V> | null>;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging -- intentionally merged with the CancelToken interface above\nexport class CancelToken {\n  promise: Promise<void>;\n  reason?: string;\n  throwIfRequested(): void {\n    if (this.reason) {\n      throw new Error(this.reason);\n    }\n  }\n  constructor(executor: (cancel: (reason?: string) => void) => void) {\n    let resolvePromise: (value?: any) => void;\n    this.promise = new Promise<void>((resolve) => {\n      resolvePromise = resolve;\n    });\n    executor((reason?: string) => {\n      this.reason = reason;\n      resolvePromise();\n    });\n  }\n}\n"],"names":[],"mappings":";;AA0HO,MAAM,WAAA,CAAY;AAAA,EACvB,OAAA;AAAA,EACA,MAAA;AAAA,EACA,gBAAA,GAAyB;AACvB,IAAA,IAAI,KAAK,MAAA,EAAQ;AACf,MAAA,MAAM,IAAI,KAAA,CAAM,IAAA,CAAK,MAAM,CAAA;AAAA,IAC7B;AAAA,EACF;AAAA,EACA,YAAY,QAAA,EAAuD;AACjE,IAAA,IAAI,cAAA;AACJ,IAAA,IAAA,CAAK,OAAA,GAAU,IAAI,OAAA,CAAc,CAAC,OAAA,KAAY;AAC5C,MAAA,cAAA,GAAiB,OAAA;AAAA,IACnB,CAAC,CAAA;AACD,IAAA,QAAA,CAAS,CAAC,MAAA,KAAoB;AAC5B,MAAA,IAAA,CAAK,MAAA,GAAS,MAAA;AACd,MAAA,cAAA,EAAe;AAAA,IACjB,CAAC,CAAA;AAAA,EACH;AACF;;;;"}

package/lib/cjs/index.js

@@ -0,0 +1,141 @@
+'use strict';
+
+var network = require('./errors/network.js');
+var not_found = require('./errors/not_found.js');
+var bad_request = require('./errors/bad_request.js');
+var bad_response = require('./errors/bad_response.js');
+var account_requires_memo = require('./errors/account_requires_memo.js');
+var config = require('./config.js');
+var utils = require('./utils.js');
+var index = require('./dwtoml/index.js');
+var index$2 = require('./federation/index.js');
+var index$4 = require('./webauth/index.js');
+var index$1 = require('./faucet/index.js');
+var index$3 = require('./gateway/index.js');
+var index$6 = require('./rpc/index.js');
+var index$5 = require('./contract/index.js');
+var generator = require('./bindings/generator.js');
+require('./node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/int.js');
+var hyper = require('./node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/hyper.js');
+require('./node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/unsigned-int.js');
+var unsignedHyper = require('./node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/unsigned-hyper.js');
+require('./node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/xdr-type.js');
+require('buffer');
+var curr_generated = require('./base/generated/curr_generated.js');
+var jsxdr = require('./base/jsxdr.js');
+var hashing = require('./base/hashing.js');
+var signing = require('./base/signing.js');
+var get_liquidity_pool_id = require('./base/get_liquidity_pool_id.js');
+var keypair = require('./base/keypair.js');
+var transaction_base = require('./base/transaction_base.js');
+var transaction = require('./base/transaction.js');
+var fee_bump_transaction = require('./base/fee_bump_transaction.js');
+var transaction_builder = require('./base/transaction_builder.js');
+var asset = require('./base/asset.js');
+var liquidity_pool_asset = require('./base/liquidity_pool_asset.js');
+var liquidity_pool_id = require('./base/liquidity_pool_id.js');
+var operation = require('./base/operation.js');
+var memo = require('./base/memo.js');
+var account = require('./base/account.js');
+var muxed_account = require('./base/muxed_account.js');
+var claimant = require('./base/claimant.js');
+var network$1 = require('./base/network.js');
+var strkey = require('./base/strkey.js');
+var signerkey = require('./base/signerkey.js');
+var soroban = require('./base/soroban.js');
+var decode_encode_muxed_account = require('./base/util/decode_encode_muxed_account.js');
+var contract = require('./base/contract.js');
+var address = require('./base/address.js');
+var scval = require('./base/scval.js');
+var events = require('./base/events.js');
+var sorobandata_builder = require('./base/sorobandata_builder.js');
+var auth = require('./base/auth.js');
+var invocation = require('./base/invocation.js');
+var index$7 = require('./base/numbers/index.js');
+var int128 = require('./base/numbers/int128.js');
+var int256 = require('./base/numbers/int256.js');
+var sc_int = require('./base/numbers/sc_int.js');
+var uint128 = require('./base/numbers/uint128.js');
+var uint256 = require('./base/numbers/uint256.js');
+var xdr_large_int = require('./base/numbers/xdr_large_int.js');
+
+
+
+exports.NetworkError = network.NetworkError;
+exports.NotFoundError = not_found.NotFoundError;
+exports.BadRequestError = bad_request.BadRequestError;
+exports.BadResponseError = bad_response.BadResponseError;
+exports.AccountRequiresMemoError = account_requires_memo.AccountRequiresMemoError;
+exports.Config = config.Config;
+exports.Utils = utils.Utils;
+exports.DwToml = index;
+exports.Federation = index$2;
+exports.WebAuth = index$4;
+exports.Faucet = index$1;
+exports.Gateway = index$3;
+exports.rpc = index$6;
+exports.contract = index$5;
+exports.BindingGenerator = generator.BindingGenerator;
+exports.Hyper = hyper.Hyper;
+exports.UnsignedHyper = unsignedHyper.UnsignedHyper;
+exports.xdr = curr_generated.default;
+exports.cereal = jsxdr.default;
+exports.hash = hashing.hash;
+exports.sign = signing.sign;
+exports.verify = signing.verify;
+exports.LiquidityPoolFeeV18 = get_liquidity_pool_id.LiquidityPoolFeeV18;
+exports.getLiquidityPoolId = get_liquidity_pool_id.getLiquidityPoolId;
+exports.Keypair = keypair.Keypair;
+exports.TransactionBase = transaction_base.TransactionBase;
+exports.Transaction = transaction.Transaction;
+exports.FeeBumpTransaction = fee_bump_transaction.FeeBumpTransaction;
+exports.BASE_FEE = transaction_builder.BASE_FEE;
+exports.TimeoutInfinite = transaction_builder.TimeoutInfinite;
+exports.TransactionBuilder = transaction_builder.TransactionBuilder;
+exports.Asset = asset.Asset;
+exports.AssetType = asset.AssetType;
+exports.LiquidityPoolAsset = liquidity_pool_asset.LiquidityPoolAsset;
+exports.LiquidityPoolId = liquidity_pool_id.LiquidityPoolId;
+exports.AuthClawbackEnabledFlag = operation.AuthClawbackEnabledFlag;
+exports.AuthImmutableFlag = operation.AuthImmutableFlag;
+exports.AuthRequiredFlag = operation.AuthRequiredFlag;
+exports.AuthRevocableFlag = operation.AuthRevocableFlag;
+exports.Operation = operation.Operation;
+exports.Memo = memo.Memo;
+exports.MemoHash = memo.MemoHash;
+exports.MemoID = memo.MemoID;
+exports.MemoNone = memo.MemoNone;
+exports.MemoReturn = memo.MemoReturn;
+exports.MemoText = memo.MemoText;
+exports.Account = account.Account;
+exports.MuxedAccount = muxed_account.MuxedAccount;
+exports.Claimant = claimant.Claimant;
+exports.Networks = network$1.Networks;
+exports.StrKey = strkey.StrKey;
+exports.SignerKey = signerkey.SignerKey;
+exports.Soroban = soroban.Soroban;
+exports.decodeAddressToMuxedAccount = decode_encode_muxed_account.decodeAddressToMuxedAccount;
+exports.encodeMuxedAccount = decode_encode_muxed_account.encodeMuxedAccount;
+exports.encodeMuxedAccountToAddress = decode_encode_muxed_account.encodeMuxedAccountToAddress;
+exports.extractBaseAddress = decode_encode_muxed_account.extractBaseAddress;
+exports.Contract = contract.Contract;
+exports.Address = address.Address;
+exports.nativeToScVal = scval.nativeToScVal;
+exports.scValToNative = scval.scValToNative;
+exports.scvSortedMap = scval.scvSortedMap;
+exports.humanizeEvents = events.humanizeEvents;
+exports.SorobanDataBuilder = sorobandata_builder.SorobanDataBuilder;
+exports.authorizeEntry = auth.authorizeEntry;
+exports.authorizeInvocation = auth.authorizeInvocation;
+exports.buildAuthorizationEntryPreimage = auth.buildAuthorizationEntryPreimage;
+exports.buildWithDelegatesEntry = auth.buildWithDelegatesEntry;
+exports.buildInvocationTree = invocation.buildInvocationTree;
+exports.walkInvocationTree = invocation.walkInvocationTree;
+exports.scValToBigInt = index$7.scValToBigInt;
+exports.Int128 = int128.Int128;
+exports.Int256 = int256.Int256;
+exports.ScInt = sc_int.ScInt;
+exports.Uint128 = uint128.Uint128;
+exports.Uint256 = uint256.Uint256;
+exports.XdrLargeInt = xdr_large_int.XdrLargeInt;
+//# sourceMappingURL=index.js.map

package/lib/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/cjs/node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/array.js

@@ -0,0 +1,68 @@
+'use strict';
+
+var xdrType = require('./xdr-type.js');
+var errors = require('./errors.js');
+
+class Array extends xdrType.NestedXdrType {
+  constructor(childType, length, maxDepth = xdrType.NestedXdrType.DEFAULT_MAX_DEPTH) {
+    super(maxDepth);
+    this._childType = childType;
+    this._length = length;
+  }
+
+  /**
+   * @inheritDoc
+   */
+  read(reader, remainingDepth = this._maxDepth) {
+    // Upper-bound fast-fail: remaining bytes is a loose capacity check since
+    // each XDR element typically consumes more than 1 byte (e.g., 4+ bytes).
+    if (this._length > reader.remainingBytes()) {
+      throw new errors.XdrReaderError(
+        `Array length ${
+          this._length
+        } exceeds remaining ${reader.remainingBytes()} bytes`
+      );
+    }
+    xdrType.NestedXdrType.checkDepth(remainingDepth);
+    const result = [];
+    // read values
+    for (let i = 0; i < this._length; i++) {
+      result.push(this._childType.read(reader, remainingDepth - 1));
+    }
+    return result;
+  }
+
+  /**
+   * @inheritDoc
+   */
+  write(value, writer) {
+    if (!global.Array.isArray(value))
+      throw new errors.XdrWriterError(`value is not array`);
+
+    if (value.length !== this._length)
+      throw new errors.XdrWriterError(
+        `got array of size ${value.length}, expected ${this._length}`
+      );
+
+    for (const child of value) {
+      this._childType.write(child, writer);
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+  isValid(value) {
+    if (!(value instanceof global.Array) || value.length !== this._length) {
+      return false;
+    }
+
+    for (const child of value) {
+      if (!this._childType.isValid(child)) return false;
+    }
+    return true;
+  }
+}
+
+exports.Array = Array;
+//# sourceMappingURL=array.js.map

package/lib/cjs/node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.js","sources":["../../../../../../../../../node_modules/.pnpm/@stellar+js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/array.js"],"sourcesContent":["import { NestedXdrType } from './xdr-type';\nimport { XdrWriterError, XdrReaderError } from './errors';\n\nexport class Array extends NestedXdrType {\n  constructor(childType, length, maxDepth = NestedXdrType.DEFAULT_MAX_DEPTH) {\n    super(maxDepth);\n    this._childType = childType;\n    this._length = length;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  read(reader, remainingDepth = this._maxDepth) {\n    // Upper-bound fast-fail: remaining bytes is a loose capacity check since\n    // each XDR element typically consumes more than 1 byte (e.g., 4+ bytes).\n    if (this._length > reader.remainingBytes()) {\n      throw new XdrReaderError(\n        `Array length ${\n          this._length\n        } exceeds remaining ${reader.remainingBytes()} bytes`\n      );\n    }\n    NestedXdrType.checkDepth(remainingDepth);\n    const result = [];\n    // read values\n    for (let i = 0; i < this._length; i++) {\n      result.push(this._childType.read(reader, remainingDepth - 1));\n    }\n    return result;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  write(value, writer) {\n    if (!global.Array.isArray(value))\n      throw new XdrWriterError(`value is not array`);\n\n    if (value.length !== this._length)\n      throw new XdrWriterError(\n        `got array of size ${value.length}, expected ${this._length}`\n      );\n\n    for (const child of value) {\n      this._childType.write(child, writer);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  isValid(value) {\n    if (!(value instanceof global.Array) || value.length !== this._length) {\n      return false;\n    }\n\n    for (const child of value) {\n      if (!this._childType.isValid(child)) return false;\n    }\n    return true;\n  }\n}\n"],"names":["NestedXdrType","XdrReaderError","XdrWriterError"],"mappings":";;;;;AAGO,MAAM,KAAK,SAASA,qBAAa,CAAC;AACzC,EAAE,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,GAAGA,qBAAa,CAAC,iBAAiB,EAAE;AAC7E,IAAI,KAAK,CAAC,QAAQ,CAAC;AACnB,IAAI,IAAI,CAAC,UAAU,GAAG,SAAS;AAC/B,IAAI,IAAI,CAAC,OAAO,GAAG,MAAM;AACzB,EAAE;;AAEF;AACA;AACA;AACA,EAAE,IAAI,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAAC,SAAS,EAAE;AAChD;AACA;AACA,IAAI,IAAI,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,cAAc,EAAE,EAAE;AAChD,MAAM,MAAM,IAAIC,qBAAc;AAC9B,QAAQ,CAAC,aAAa;AACtB,UAAU,IAAI,CAAC;AACf,SAAS,mBAAmB,EAAE,MAAM,CAAC,cAAc,EAAE,CAAC,MAAM;AAC5D,OAAO;AACP,IAAI;AACJ,IAAID,qBAAa,CAAC,UAAU,CAAC,cAAc,CAAC;AAC5C,IAAI,MAAM,MAAM,GAAG,EAAE;AACrB;AACA,IAAI,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,EAAE;AAC3C,MAAM,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,cAAc,GAAG,CAAC,CAAC,CAAC;AACnE,IAAI;AACJ,IAAI,OAAO,MAAM;AACjB,EAAE;;AAEF;AACA;AACA;AACA,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE;AACvB,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;AACpC,MAAM,MAAM,IAAIE,qBAAc,CAAC,CAAC,kBAAkB,CAAC,CAAC;;AAEpD,IAAI,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,OAAO;AACrC,MAAM,MAAM,IAAIA,qBAAc;AAC9B,QAAQ,CAAC,kBAAkB,EAAE,KAAK,CAAC,MAAM,CAAC,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC;AACpE,OAAO;;AAEP,IAAI,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE;AAC/B,MAAM,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC;AAC1C,IAAI;AACJ,EAAE;;AAEF;AACA;AACA;AACA,EAAE,OAAO,CAAC,KAAK,EAAE;AACjB,IAAI,IAAI,EAAE,KAAK,YAAY,MAAM,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,OAAO,EAAE;AAC3E,MAAM,OAAO,KAAK;AAClB,IAAI;;AAEJ,IAAI,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE;AAC/B,MAAM,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,OAAO,KAAK;AACvD,IAAI;AACJ,IAAI,OAAO,IAAI;AACf,EAAE;AACF;;;;","x_google_ignoreList":[0]}

package/lib/cjs/node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/bigint-encoder.js

@@ -0,0 +1,179 @@
+'use strict';
+
+/**
+ * Encode a native `bigint` value from a list of arbitrary integer-like values.
+ *
+ * @param {Array<number|bigint|string>} parts - Slices to encode in big-endian
+ *    format (i.e. earlier elements are higher bits)
+ * @param {64|128|256} size - Number of bits in the target integer type
+ * @param {boolean} unsigned - Whether it's an unsigned integer
+ *
+ * @returns {bigint}
+ */
+function encodeBigIntFromBits(parts, size, unsigned) {
+  if (!(parts instanceof Array)) {
+    // allow a single parameter instead of an array
+    parts = [parts];
+  } else if (parts.length && parts[0] instanceof Array) {
+    // unpack nested array param
+    parts = parts[0];
+  }
+
+  const total = parts.length;
+  const sliceSize = size / total;
+  switch (sliceSize) {
+    case 32:
+    case 64:
+    case 128:
+    case 256:
+      break;
+
+    default:
+      throw new RangeError(
+        `expected slices to fit in 32/64/128/256 bits, got ${parts}`
+      );
+  }
+
+  // normalize all inputs to bigint
+  try {
+    for (let i = 0; i < parts.length; i++) {
+      if (typeof parts[i] !== 'bigint') {
+        parts[i] = BigInt(parts[i].valueOf());
+      }
+    }
+  } catch (e) {
+    throw new TypeError(`expected bigint-like values, got: ${parts} (${e})`);
+  }
+
+  // fast path: single value — validate and return directly without assembly
+  if (parts.length === 1) {
+    const value = parts[0];
+    if (unsigned && value < 0n) {
+      throw new RangeError(`expected a positive value, got: ${parts}`);
+    }
+    const [min, max] = calculateBigIntBoundaries(size, unsigned);
+    if (value < min || value > max) {
+      throw new RangeError(
+        `bigint value ${value} for ${formatIntName(
+          size,
+          unsigned
+        )} out of range [${min}, ${max}]`
+      );
+    }
+    return value;
+  }
+
+  // multi-part assembly: encode in big-endian fashion, shifting each slice
+  let result = 0n;
+
+  for (let i = 0; i < parts.length; i++) {
+    assertSliceFits(parts[i], sliceSize);
+    result |= BigInt.asUintN(sliceSize, parts[i]) << BigInt(i * sliceSize);
+  }
+
+  if (!unsigned) {
+    result = BigInt.asIntN(size, result);
+  }
+
+  // check boundaries
+  const [min, max] = calculateBigIntBoundaries(size, unsigned);
+  if (result >= min && result <= max) {
+    return result;
+  }
+
+  // failed to encode
+  throw new RangeError(
+    `bigint values [${parts}] for ${formatIntName(
+      size,
+      unsigned
+    )} out of range [${min}, ${max}]: ${result}`
+  );
+}
+
+/**
+ * Transforms a single bigint value that's supposed to represent a `size`-bit
+ * integer into a list of `sliceSize`d chunks.
+ *
+ * @param {bigint} value - Single bigint value to decompose
+ * @param {64|128|256} iSize - Number of bits represented by `value`
+ * @param {32|64|128} sliceSize - Number of chunks to decompose into
+ * @return {bigint[]} List of signed bigint chunks in big-endian order (i.e. earlier elements are higher bits)
+ */
+function sliceBigInt(value, iSize, sliceSize) {
+  if (typeof value !== 'bigint') {
+    throw new TypeError(`Expected bigint 'value', got ${typeof value}`);
+  }
+
+  const total = iSize / sliceSize;
+  if (total === 1) {
+    return [value];
+  }
+
+  if (
+    sliceSize < 32 ||
+    sliceSize > 128 ||
+    (total !== 2 && total !== 4 && total !== 8)
+  ) {
+    throw new TypeError(
+      `invalid bigint (${value}) and slice size (${iSize} -> ${sliceSize}) combination`
+    );
+  }
+
+  const shift = BigInt(sliceSize);
+
+  // iterate shift and mask application
+  const result = new Array(total);
+  for (let i = 0; i < total; i++) {
+    // we force a signed interpretation to preserve sign in each slice value,
+    // but downstream can convert to unsigned if it's appropriate
+    result[i] = BigInt.asIntN(sliceSize, value); // clamps to size
+
+    // move on to the next chunk
+    value >>= shift;
+  }
+
+  return result;
+}
+
+function formatIntName(precision, unsigned) {
+  return `${unsigned ? 'u' : 'i'}${precision}`;
+}
+
+/**
+ * Get min|max boundaries for an integer with a specified bits size
+ * @param {64|128|256} size - Number of bits in the source integer type
+ * @param {Boolean} unsigned - Whether it's an unsigned integer
+ * @return {BigInt[]}
+ */
+function calculateBigIntBoundaries(size, unsigned) {
+  if (unsigned) {
+    return [0n, (1n << BigInt(size)) - 1n];
+  }
+
+  const boundary = 1n << BigInt(size - 1);
+  return [0n - boundary, boundary - 1n];
+}
+
+/**
+ * Asserts that a given part fits within the specified slice size.
+ * @param {bigint | number | string} part - The part to check.
+ * @param {number} sliceSize - The size of the slice in bits (e.g., 32, 64, 128)
+ * @returns {void}
+ * @throws {RangeError} If the part does not fit within the slice size.
+ */
+function assertSliceFits(part, sliceSize) {
+  const fitsSigned = BigInt.asIntN(sliceSize, part) === part;
+  const fitsUnsigned = BigInt.asUintN(sliceSize, part) === part;
+
+  if (!fitsSigned && !fitsUnsigned) {
+    throw new RangeError(
+      `slice value ${part} does not fit in ${sliceSize} bits`
+    );
+  }
+}
+
+exports.calculateBigIntBoundaries = calculateBigIntBoundaries;
+exports.encodeBigIntFromBits = encodeBigIntFromBits;
+exports.formatIntName = formatIntName;
+exports.sliceBigInt = sliceBigInt;
+//# sourceMappingURL=bigint-encoder.js.map

package/lib/cjs/node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/bigint-encoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigint-encoder.js","sources":["../../../../../../../../../node_modules/.pnpm/@stellar+js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/bigint-encoder.js"],"sourcesContent":["/**\n * Encode a native `bigint` value from a list of arbitrary integer-like values.\n *\n * @param {Array<number|bigint|string>} parts - Slices to encode in big-endian\n *    format (i.e. earlier elements are higher bits)\n * @param {64|128|256} size - Number of bits in the target integer type\n * @param {boolean} unsigned - Whether it's an unsigned integer\n *\n * @returns {bigint}\n */\nexport function encodeBigIntFromBits(parts, size, unsigned) {\n  if (!(parts instanceof Array)) {\n    // allow a single parameter instead of an array\n    parts = [parts];\n  } else if (parts.length && parts[0] instanceof Array) {\n    // unpack nested array param\n    parts = parts[0];\n  }\n\n  const total = parts.length;\n  const sliceSize = size / total;\n  switch (sliceSize) {\n    case 32:\n    case 64:\n    case 128:\n    case 256:\n      break;\n\n    default:\n      throw new RangeError(\n        `expected slices to fit in 32/64/128/256 bits, got ${parts}`\n      );\n  }\n\n  // normalize all inputs to bigint\n  try {\n    for (let i = 0; i < parts.length; i++) {\n      if (typeof parts[i] !== 'bigint') {\n        parts[i] = BigInt(parts[i].valueOf());\n      }\n    }\n  } catch (e) {\n    throw new TypeError(`expected bigint-like values, got: ${parts} (${e})`);\n  }\n\n  // fast path: single value — validate and return directly without assembly\n  if (parts.length === 1) {\n    const value = parts[0];\n    if (unsigned && value < 0n) {\n      throw new RangeError(`expected a positive value, got: ${parts}`);\n    }\n    const [min, max] = calculateBigIntBoundaries(size, unsigned);\n    if (value < min || value > max) {\n      throw new RangeError(\n        `bigint value ${value} for ${formatIntName(\n          size,\n          unsigned\n        )} out of range [${min}, ${max}]`\n      );\n    }\n    return value;\n  }\n\n  // multi-part assembly: encode in big-endian fashion, shifting each slice\n  let result = 0n;\n\n  for (let i = 0; i < parts.length; i++) {\n    assertSliceFits(parts[i], sliceSize);\n    result |= BigInt.asUintN(sliceSize, parts[i]) << BigInt(i * sliceSize);\n  }\n\n  if (!unsigned) {\n    result = BigInt.asIntN(size, result);\n  }\n\n  // check boundaries\n  const [min, max] = calculateBigIntBoundaries(size, unsigned);\n  if (result >= min && result <= max) {\n    return result;\n  }\n\n  // failed to encode\n  throw new RangeError(\n    `bigint values [${parts}] for ${formatIntName(\n      size,\n      unsigned\n    )} out of range [${min}, ${max}]: ${result}`\n  );\n}\n\n/**\n * Transforms a single bigint value that's supposed to represent a `size`-bit\n * integer into a list of `sliceSize`d chunks.\n *\n * @param {bigint} value - Single bigint value to decompose\n * @param {64|128|256} iSize - Number of bits represented by `value`\n * @param {32|64|128} sliceSize - Number of chunks to decompose into\n * @return {bigint[]} List of signed bigint chunks in big-endian order (i.e. earlier elements are higher bits)\n */\nexport function sliceBigInt(value, iSize, sliceSize) {\n  if (typeof value !== 'bigint') {\n    throw new TypeError(`Expected bigint 'value', got ${typeof value}`);\n  }\n\n  const total = iSize / sliceSize;\n  if (total === 1) {\n    return [value];\n  }\n\n  if (\n    sliceSize < 32 ||\n    sliceSize > 128 ||\n    (total !== 2 && total !== 4 && total !== 8)\n  ) {\n    throw new TypeError(\n      `invalid bigint (${value}) and slice size (${iSize} -> ${sliceSize}) combination`\n    );\n  }\n\n  const shift = BigInt(sliceSize);\n\n  // iterate shift and mask application\n  const result = new Array(total);\n  for (let i = 0; i < total; i++) {\n    // we force a signed interpretation to preserve sign in each slice value,\n    // but downstream can convert to unsigned if it's appropriate\n    result[i] = BigInt.asIntN(sliceSize, value); // clamps to size\n\n    // move on to the next chunk\n    value >>= shift;\n  }\n\n  return result;\n}\n\nexport function formatIntName(precision, unsigned) {\n  return `${unsigned ? 'u' : 'i'}${precision}`;\n}\n\n/**\n * Get min|max boundaries for an integer with a specified bits size\n * @param {64|128|256} size - Number of bits in the source integer type\n * @param {Boolean} unsigned - Whether it's an unsigned integer\n * @return {BigInt[]}\n */\nexport function calculateBigIntBoundaries(size, unsigned) {\n  if (unsigned) {\n    return [0n, (1n << BigInt(size)) - 1n];\n  }\n\n  const boundary = 1n << BigInt(size - 1);\n  return [0n - boundary, boundary - 1n];\n}\n\n/**\n * Asserts that a given part fits within the specified slice size.\n * @param {bigint | number | string} part - The part to check.\n * @param {number} sliceSize - The size of the slice in bits (e.g., 32, 64, 128)\n * @returns {void}\n * @throws {RangeError} If the part does not fit within the slice size.\n */\nfunction assertSliceFits(part, sliceSize) {\n  const fitsSigned = BigInt.asIntN(sliceSize, part) === part;\n  const fitsUnsigned = BigInt.asUintN(sliceSize, part) === part;\n\n  if (!fitsSigned && !fitsUnsigned) {\n    throw new RangeError(\n      `slice value ${part} does not fit in ${sliceSize} bits`\n    );\n  }\n}\n"],"names":[],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,oBAAoB,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE;AAC5D,EAAE,IAAI,EAAE,KAAK,YAAY,KAAK,CAAC,EAAE;AACjC;AACA,IAAI,KAAK,GAAG,CAAC,KAAK,CAAC;AACnB,EAAE,CAAC,MAAM,IAAI,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC,CAAC,YAAY,KAAK,EAAE;AACxD;AACA,IAAI,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC;AACpB,EAAE;;AAEF,EAAE,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM;AAC5B,EAAE,MAAM,SAAS,GAAG,IAAI,GAAG,KAAK;AAChC,EAAE,QAAQ,SAAS;AACnB,IAAI,KAAK,EAAE;AACX,IAAI,KAAK,EAAE;AACX,IAAI,KAAK,GAAG;AACZ,IAAI,KAAK,GAAG;AACZ,MAAM;;AAEN,IAAI;AACJ,MAAM,MAAM,IAAI,UAAU;AAC1B,QAAQ,CAAC,kDAAkD,EAAE,KAAK,CAAC;AACnE,OAAO;AACP;;AAEA;AACA,EAAE,IAAI;AACN,IAAI,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AAC3C,MAAM,IAAI,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ,EAAE;AACxC,QAAQ,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;AAC7C,MAAM;AACN,IAAI;AACJ,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE;AACd,IAAI,MAAM,IAAI,SAAS,CAAC,CAAC,kCAAkC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AAC5E,EAAE;;AAEF;AACA,EAAE,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;AAC1B,IAAI,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC;AAC1B,IAAI,IAAI,QAAQ,IAAI,KAAK,GAAG,EAAE,EAAE;AAChC,MAAM,MAAM,IAAI,UAAU,CAAC,CAAC,gCAAgC,EAAE,KAAK,CAAC,CAAC,CAAC;AACtE,IAAI;AACJ,IAAI,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,yBAAyB,CAAC,IAAI,EAAE,QAAQ,CAAC;AAChE,IAAI,IAAI,KAAK,GAAG,GAAG,IAAI,KAAK,GAAG,GAAG,EAAE;AACpC,MAAM,MAAM,IAAI,UAAU;AAC1B,QAAQ,CAAC,aAAa,EAAE,KAAK,CAAC,KAAK,EAAE,aAAa;AAClD,UAAU,IAAI;AACd,UAAU;AACV,SAAS,CAAC,eAAe,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;AACxC,OAAO;AACP,IAAI;AACJ,IAAI,OAAO,KAAK;AAChB,EAAE;;AAEF;AACA,EAAE,IAAI,MAAM,GAAG,EAAE;;AAEjB,EAAE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AACzC,IAAI,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC;AACxC,IAAI,MAAM,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC;AAC1E,EAAE;;AAEF,EAAE,IAAI,CAAC,QAAQ,EAAE;AACjB,IAAI,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC;AACxC,EAAE;;AAEF;AACA,EAAE,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,yBAAyB,CAAC,IAAI,EAAE,QAAQ,CAAC;AAC9D,EAAE,IAAI,MAAM,IAAI,GAAG,IAAI,MAAM,IAAI,GAAG,EAAE;AACtC,IAAI,OAAO,MAAM;AACjB,EAAE;;AAEF;AACA,EAAE,MAAM,IAAI,UAAU;AACtB,IAAI,CAAC,eAAe,EAAE,KAAK,CAAC,MAAM,EAAE,aAAa;AACjD,MAAM,IAAI;AACV,MAAM;AACN,KAAK,CAAC,eAAe,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC;AAC/C,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE;AACrD,EAAE,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;AACjC,IAAI,MAAM,IAAI,SAAS,CAAC,CAAC,6BAA6B,EAAE,OAAO,KAAK,CAAC,CAAC,CAAC;AACvE,EAAE;;AAEF,EAAE,MAAM,KAAK,GAAG,KAAK,GAAG,SAAS;AACjC,EAAE,IAAI,KAAK,KAAK,CAAC,EAAE;AACnB,IAAI,OAAO,CAAC,KAAK,CAAC;AAClB,EAAE;;AAEF,EAAE;AACF,IAAI,SAAS,GAAG,EAAE;AAClB,IAAI,SAAS,GAAG,GAAG;AACnB,KAAK,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC;AAC9C,IAAI;AACJ,IAAI,MAAM,IAAI,SAAS;AACvB,MAAM,CAAC,gBAAgB,EAAE,KAAK,CAAC,kBAAkB,EAAE,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,aAAa;AACtF,KAAK;AACL,EAAE;;AAEF,EAAE,MAAM,KAAK,GAAG,MAAM,CAAC,SAAS,CAAC;;AAEjC;AACA,EAAE,MAAM,MAAM,GAAG,IAAI,KAAK,CAAC,KAAK,CAAC;AACjC,EAAE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE;AAClC;AACA;AACA,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;;AAEhD;AACA,IAAI,KAAK,KAAK,KAAK;AACnB,EAAE;;AAEF,EAAE,OAAO,MAAM;AACf;;AAEO,SAAS,aAAa,CAAC,SAAS,EAAE,QAAQ,EAAE;AACnD,EAAE,OAAO,CAAC,EAAE,QAAQ,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,SAAS,CAAC,CAAC;AAC9C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,yBAAyB,CAAC,IAAI,EAAE,QAAQ,EAAE;AAC1D,EAAE,IAAI,QAAQ,EAAE;AAChB,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;AAC1C,EAAE;;AAEF,EAAE,MAAM,QAAQ,GAAG,EAAE,IAAI,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC;AACzC,EAAE,OAAO,CAAC,EAAE,GAAG,QAAQ,EAAE,QAAQ,GAAG,EAAE,CAAC;AACvC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE;AAC1C,EAAE,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,KAAK,IAAI;AAC5D,EAAE,MAAM,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC,KAAK,IAAI;;AAE/D,EAAE,IAAI,CAAC,UAAU,IAAI,CAAC,YAAY,EAAE;AACpC,IAAI,MAAM,IAAI,UAAU;AACxB,MAAM,CAAC,YAAY,EAAE,IAAI,CAAC,iBAAiB,EAAE,SAAS,CAAC,KAAK;AAC5D,KAAK;AACL,EAAE;AACF;;;;;;;","x_google_ignoreList":[0]}

package/lib/cjs/node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/bool.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var int = require('./int.js');
+var xdrType = require('./xdr-type.js');
+var errors = require('./errors.js');
+
+class Bool extends xdrType.XdrPrimitiveType {
+  /**
+   * @inheritDoc
+   */
+  static read(reader) {
+    const value = int.Int.read(reader);
+
+    switch (value) {
+      case 0:
+        return false;
+      case 1:
+        return true;
+      default:
+        throw new errors.XdrReaderError(`got ${value} when trying to read a bool`);
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+  static write(value, writer) {
+    const intVal = value ? 1 : 0;
+    int.Int.write(intVal, writer);
+  }
+
+  /**
+   * @inheritDoc
+   */
+  static isValid(value) {
+    return typeof value === 'boolean';
+  }
+}
+
+exports.Bool = Bool;
+//# sourceMappingURL=bool.js.map

package/lib/cjs/node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/bool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bool.js","sources":["../../../../../../../../../node_modules/.pnpm/@stellar+js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/bool.js"],"sourcesContent":["import { Int } from './int';\nimport { XdrPrimitiveType } from './xdr-type';\nimport { XdrReaderError } from './errors';\n\nexport class Bool extends XdrPrimitiveType {\n  /**\n   * @inheritDoc\n   */\n  static read(reader) {\n    const value = Int.read(reader);\n\n    switch (value) {\n      case 0:\n        return false;\n      case 1:\n        return true;\n      default:\n        throw new XdrReaderError(`got ${value} when trying to read a bool`);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  static write(value, writer) {\n    const intVal = value ? 1 : 0;\n    Int.write(intVal, writer);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  static isValid(value) {\n    return typeof value === 'boolean';\n  }\n}\n"],"names":["XdrPrimitiveType","Int","XdrReaderError"],"mappings":";;;;;;AAIO,MAAM,IAAI,SAASA,wBAAgB,CAAC;AAC3C;AACA;AACA;AACA,EAAE,OAAO,IAAI,CAAC,MAAM,EAAE;AACtB,IAAI,MAAM,KAAK,GAAGC,OAAG,CAAC,IAAI,CAAC,MAAM,CAAC;;AAElC,IAAI,QAAQ,KAAK;AACjB,MAAM,KAAK,CAAC;AACZ,QAAQ,OAAO,KAAK;AACpB,MAAM,KAAK,CAAC;AACZ,QAAQ,OAAO,IAAI;AACnB,MAAM;AACN,QAAQ,MAAM,IAAIC,qBAAc,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,2BAA2B,CAAC,CAAC;AAC3E;AACA,EAAE;;AAEF;AACA;AACA;AACA,EAAE,OAAO,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE;AAC9B,IAAI,MAAM,MAAM,GAAG,KAAK,GAAG,CAAC,GAAG,CAAC;AAChC,IAAID,OAAG,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC;AAC7B,EAAE;;AAEF;AACA;AACA;AACA,EAAE,OAAO,OAAO,CAAC,KAAK,EAAE;AACxB,IAAI,OAAO,OAAO,KAAK,KAAK,SAAS;AACrC,EAAE;AACF;;;;","x_google_ignoreList":[0]}