@digitalworld/digital-world-sdk 16.0.0

package/lib/esm/node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/large-int.js

@@ -0,0 +1,142 @@
+import { XdrPrimitiveType } from './xdr-type.js';
+import { encodeBigIntFromBits, sliceBigInt, calculateBigIntBoundaries } from './bigint-encoder.js';
+import { XdrNotImplementedDefinitionError, XdrWriterError } from './errors.js';
+
+class LargeInt extends XdrPrimitiveType {
+  /**
+   * @param {Array<Number|BigInt|String>} parts - Slices to encode
+   */
+  constructor(args) {
+    super();
+    this._value = encodeBigIntFromBits(args, this.size, this.unsigned);
+  }
+
+  /**
+   * Signed/unsigned representation
+   * @type {Boolean}
+   * @abstract
+   */
+  get unsigned() {
+    throw new XdrNotImplementedDefinitionError();
+  }
+
+  /**
+   * Size of the integer in bits
+   * @type {Number}
+   * @abstract
+   */
+  get size() {
+    throw new XdrNotImplementedDefinitionError();
+  }
+
+  /**
+   * Slice integer to parts with smaller bit size
+   * @param {32|64|128} sliceSize - Size of each part in bits
+   * @return {BigInt[]}
+   */
+  slice(sliceSize) {
+    return sliceBigInt(this._value, this.size, sliceSize);
+  }
+
+  toString() {
+    return this._value.toString();
+  }
+
+  toJSON() {
+    return { _value: this._value.toString() };
+  }
+
+  toBigInt() {
+    return BigInt(this._value);
+  }
+
+  /**
+   * @inheritDoc
+   */
+  static read(reader) {
+    const { size, unsigned } = this.prototype;
+    if (size === 64) {
+      return new this(
+        unsigned ? reader.readBigUInt64BE() : reader.readBigInt64BE()
+      );
+    }
+    return new this(
+      ...Array.from({ length: size / 64 }, () =>
+        reader.readBigUInt64BE()
+      ).reverse()
+    );
+  }
+
+  /**
+   * @inheritDoc
+   */
+  static write(value, writer) {
+    if (value instanceof this) {
+      value = value._value;
+    } else if (
+      typeof value !== 'bigint' ||
+      value > this.MAX_VALUE ||
+      value < this.MIN_VALUE
+    )
+      throw new XdrWriterError(`${value} is not a ${this.name}`);
+
+    const { unsigned, size } = this.prototype;
+    if (size === 64) {
+      if (unsigned) {
+        writer.writeBigUInt64BE(value);
+      } else {
+        writer.writeBigInt64BE(value);
+      }
+    } else {
+      // extract 64-bit chunks directly from bigint, big-endian order
+      // This does not use sliceBigint since it returns slices as signed values,
+      // which is not what we want for encoding
+      const uvalue = unsigned ? value : BigInt.asUintN(size, value);
+      for (let i = size / 64 - 1; i >= 0; i--) {
+        writer.writeBigUInt64BE(
+          (uvalue >> BigInt(i * 64)) & 0xffffffffffffffffn // 2^64-1
+        );
+      }
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+  static isValid(value) {
+    if (value instanceof this) return true;
+    if (typeof value === 'bigint') {
+      return value >= this.MIN_VALUE && value <= this.MAX_VALUE;
+    }
+    return false;
+  }
+
+  /**
+   * Create instance from string
+   * @param {String} string - Numeric representation
+   * @return {LargeInt}
+   */
+  static fromString(string) {
+    return new this(string);
+  }
+
+  static MAX_VALUE = 0n;
+
+  static MIN_VALUE = 0n;
+
+  /**
+   * @internal
+   * @return {void}
+   */
+  static defineIntBoundaries() {
+    const [min, max] = calculateBigIntBoundaries(
+      this.prototype.size,
+      this.prototype.unsigned
+    );
+    this.MIN_VALUE = min;
+    this.MAX_VALUE = max;
+  }
+}
+
+export { LargeInt };
+//# sourceMappingURL=large-int.js.map

package/lib/esm/node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/large-int.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"large-int.js","sources":["../../../../../../../../../node_modules/.pnpm/@stellar+js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/large-int.js"],"sourcesContent":["import { XdrPrimitiveType } from './xdr-type';\nimport {\n  calculateBigIntBoundaries,\n  encodeBigIntFromBits,\n  sliceBigInt\n} from './bigint-encoder';\nimport { XdrNotImplementedDefinitionError, XdrWriterError } from './errors';\n\nexport class LargeInt extends XdrPrimitiveType {\n  /**\n   * @param {Array<Number|BigInt|String>} parts - Slices to encode\n   */\n  constructor(args) {\n    super();\n    this._value = encodeBigIntFromBits(args, this.size, this.unsigned);\n  }\n\n  /**\n   * Signed/unsigned representation\n   * @type {Boolean}\n   * @abstract\n   */\n  get unsigned() {\n    throw new XdrNotImplementedDefinitionError();\n  }\n\n  /**\n   * Size of the integer in bits\n   * @type {Number}\n   * @abstract\n   */\n  get size() {\n    throw new XdrNotImplementedDefinitionError();\n  }\n\n  /**\n   * Slice integer to parts with smaller bit size\n   * @param {32|64|128} sliceSize - Size of each part in bits\n   * @return {BigInt[]}\n   */\n  slice(sliceSize) {\n    return sliceBigInt(this._value, this.size, sliceSize);\n  }\n\n  toString() {\n    return this._value.toString();\n  }\n\n  toJSON() {\n    return { _value: this._value.toString() };\n  }\n\n  toBigInt() {\n    return BigInt(this._value);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  static read(reader) {\n    const { size, unsigned } = this.prototype;\n    if (size === 64) {\n      return new this(\n        unsigned ? reader.readBigUInt64BE() : reader.readBigInt64BE()\n      );\n    }\n    return new this(\n      ...Array.from({ length: size / 64 }, () =>\n        reader.readBigUInt64BE()\n      ).reverse()\n    );\n  }\n\n  /**\n   * @inheritDoc\n   */\n  static write(value, writer) {\n    if (value instanceof this) {\n      value = value._value;\n    } else if (\n      typeof value !== 'bigint' ||\n      value > this.MAX_VALUE ||\n      value < this.MIN_VALUE\n    )\n      throw new XdrWriterError(`${value} is not a ${this.name}`);\n\n    const { unsigned, size } = this.prototype;\n    if (size === 64) {\n      if (unsigned) {\n        writer.writeBigUInt64BE(value);\n      } else {\n        writer.writeBigInt64BE(value);\n      }\n    } else {\n      // extract 64-bit chunks directly from bigint, big-endian order\n      // This does not use sliceBigint since it returns slices as signed values,\n      // which is not what we want for encoding\n      const uvalue = unsigned ? value : BigInt.asUintN(size, value);\n      for (let i = size / 64 - 1; i >= 0; i--) {\n        writer.writeBigUInt64BE(\n          (uvalue >> BigInt(i * 64)) & 0xffffffffffffffffn // 2^64-1\n        );\n      }\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  static isValid(value) {\n    if (value instanceof this) return true;\n    if (typeof value === 'bigint') {\n      return value >= this.MIN_VALUE && value <= this.MAX_VALUE;\n    }\n    return false;\n  }\n\n  /**\n   * Create instance from string\n   * @param {String} string - Numeric representation\n   * @return {LargeInt}\n   */\n  static fromString(string) {\n    return new this(string);\n  }\n\n  static MAX_VALUE = 0n;\n\n  static MIN_VALUE = 0n;\n\n  /**\n   * @internal\n   * @return {void}\n   */\n  static defineIntBoundaries() {\n    const [min, max] = calculateBigIntBoundaries(\n      this.prototype.size,\n      this.prototype.unsigned\n    );\n    this.MIN_VALUE = min;\n    this.MAX_VALUE = max;\n  }\n}\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/lib/esm/node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/opaque.js

@@ -0,0 +1,39 @@
+import { Buffer } from 'buffer';
+import { XdrCompositeType } from './xdr-type.js';
+import { XdrWriterError } from './errors.js';
+
+class Opaque extends XdrCompositeType {
+  constructor(length) {
+    super();
+    this._length = length;
+  }
+
+  /**
+   * @inheritDoc
+   */
+  read(reader) {
+    return reader.read(this._length);
+  }
+
+  /**
+   * @inheritDoc
+   */
+  write(value, writer) {
+    const { length } = value;
+    if (length !== this._length)
+      throw new XdrWriterError(
+        `got ${value.length} bytes, expected ${this._length}`
+      );
+    writer.write(value, length);
+  }
+
+  /**
+   * @inheritDoc
+   */
+  isValid(value) {
+    return Buffer.isBuffer(value) && value.length === this._length;
+  }
+}
+
+export { Opaque };
+//# sourceMappingURL=opaque.js.map

package/lib/esm/node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/opaque.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opaque.js","sources":["../../../../../../../../../node_modules/.pnpm/@stellar+js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/opaque.js"],"sourcesContent":["import { XdrCompositeType } from './xdr-type';\nimport { XdrWriterError } from './errors';\n\nexport class Opaque extends XdrCompositeType {\n  constructor(length) {\n    super();\n    this._length = length;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  read(reader) {\n    return reader.read(this._length);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  write(value, writer) {\n    const { length } = value;\n    if (length !== this._length)\n      throw new XdrWriterError(\n        `got ${value.length} bytes, expected ${this._length}`\n      );\n    writer.write(value, length);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  isValid(value) {\n    return Buffer.isBuffer(value) && value.length === this._length;\n  }\n}\n"],"names":[],"mappings":";;;;AAGO,MAAM,MAAM,SAAS,gBAAgB,CAAC;AAC7C,EAAE,WAAW,CAAC,MAAM,EAAE;AACtB,IAAI,KAAK,EAAE;AACX,IAAI,IAAI,CAAC,OAAO,GAAG,MAAM;AACzB,EAAE;;AAEF;AACA;AACA;AACA,EAAE,IAAI,CAAC,MAAM,EAAE;AACf,IAAI,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC;AACpC,EAAE;;AAEF;AACA;AACA;AACA,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE;AACvB,IAAI,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK;AAC5B,IAAI,IAAI,MAAM,KAAK,IAAI,CAAC,OAAO;AAC/B,MAAM,MAAM,IAAI,cAAc;AAC9B,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,iBAAiB,EAAE,IAAI,CAAC,OAAO,CAAC;AAC5D,OAAO;AACP,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC;AAC/B,EAAE;;AAEF;AACA;AACA;AACA,EAAE,OAAO,CAAC,KAAK,EAAE;AACjB,IAAI,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,OAAO;AAClE,EAAE;AACF;;;;","x_google_ignoreList":[0]}

package/lib/esm/node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/option.js

@@ -0,0 +1,47 @@
+import { Bool } from './bool.js';
+import { NestedXdrType } from './xdr-type.js';
+
+class Option extends NestedXdrType {
+  constructor(childType, maxDepth = NestedXdrType.DEFAULT_MAX_DEPTH) {
+    super(maxDepth);
+    this._childType = childType;
+  }
+
+  /**
+   * @inheritDoc
+   */
+  read(reader, remainingDepth = this._maxDepth) {
+    NestedXdrType.checkDepth(remainingDepth);
+    if (Bool.read(reader)) {
+      return this._childType.read(reader, remainingDepth - 1);
+    }
+
+    return undefined;
+  }
+
+  /**
+   * @inheritDoc
+   */
+  write(value, writer) {
+    const isPresent = value !== null && value !== undefined;
+
+    Bool.write(isPresent, writer);
+
+    if (isPresent) {
+      this._childType.write(value, writer);
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+  isValid(value) {
+    if (value === null || value === undefined) {
+      return true;
+    }
+    return this._childType.isValid(value);
+  }
+}
+
+export { Option };
+//# sourceMappingURL=option.js.map

package/lib/esm/node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/option.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"option.js","sources":["../../../../../../../../../node_modules/.pnpm/@stellar+js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/option.js"],"sourcesContent":["import { Bool } from './bool';\nimport { NestedXdrType } from './xdr-type';\n\nexport class Option extends NestedXdrType {\n  constructor(childType, maxDepth = NestedXdrType.DEFAULT_MAX_DEPTH) {\n    super(maxDepth);\n    this._childType = childType;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  read(reader, remainingDepth = this._maxDepth) {\n    NestedXdrType.checkDepth(remainingDepth);\n    if (Bool.read(reader)) {\n      return this._childType.read(reader, remainingDepth - 1);\n    }\n\n    return undefined;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  write(value, writer) {\n    const isPresent = value !== null && value !== undefined;\n\n    Bool.write(isPresent, writer);\n\n    if (isPresent) {\n      this._childType.write(value, writer);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  isValid(value) {\n    if (value === null || value === undefined) {\n      return true;\n    }\n    return this._childType.isValid(value);\n  }\n}\n"],"names":[],"mappings":";;;AAGO,MAAM,MAAM,SAAS,aAAa,CAAC;AAC1C,EAAE,WAAW,CAAC,SAAS,EAAE,QAAQ,GAAG,aAAa,CAAC,iBAAiB,EAAE;AACrE,IAAI,KAAK,CAAC,QAAQ,CAAC;AACnB,IAAI,IAAI,CAAC,UAAU,GAAG,SAAS;AAC/B,EAAE;;AAEF;AACA;AACA;AACA,EAAE,IAAI,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAAC,SAAS,EAAE;AAChD,IAAI,aAAa,CAAC,UAAU,CAAC,cAAc,CAAC;AAC5C,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;AAC3B,MAAM,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,cAAc,GAAG,CAAC,CAAC;AAC7D,IAAI;;AAEJ,IAAI,OAAO,SAAS;AACpB,EAAE;;AAEF;AACA;AACA;AACA,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE;AACvB,IAAI,MAAM,SAAS,GAAG,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS;;AAE3D,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,MAAM,CAAC;;AAEjC,IAAI,IAAI,SAAS,EAAE;AACnB,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,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,EAAE;AAC/C,MAAM,OAAO,IAAI;AACjB,IAAI;AACJ,IAAI,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC;AACzC,EAAE;AACF;;;;","x_google_ignoreList":[0]}

package/lib/esm/node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/quadruple.js

@@ -0,0 +1,19 @@
+import { XdrPrimitiveType } from './xdr-type.js';
+import { XdrDefinitionError } from './errors.js';
+
+class Quadruple extends XdrPrimitiveType {
+  static read() {
+    throw new XdrDefinitionError('quadruple not supported');
+  }
+
+  static write() {
+    throw new XdrDefinitionError('quadruple not supported');
+  }
+
+  static isValid() {
+    return false;
+  }
+}
+
+export { Quadruple };
+//# sourceMappingURL=quadruple.js.map

package/lib/esm/node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/quadruple.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quadruple.js","sources":["../../../../../../../../../node_modules/.pnpm/@stellar+js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/quadruple.js"],"sourcesContent":["import { XdrPrimitiveType } from './xdr-type';\nimport { XdrDefinitionError } from './errors';\n\nexport class Quadruple extends XdrPrimitiveType {\n  static read() {\n    throw new XdrDefinitionError('quadruple not supported');\n  }\n\n  static write() {\n    throw new XdrDefinitionError('quadruple not supported');\n  }\n\n  static isValid() {\n    return false;\n  }\n}\n"],"names":[],"mappings":";;;AAGO,MAAM,SAAS,SAAS,gBAAgB,CAAC;AAChD,EAAE,OAAO,IAAI,GAAG;AAChB,IAAI,MAAM,IAAI,kBAAkB,CAAC,yBAAyB,CAAC;AAC3D,EAAE;;AAEF,EAAE,OAAO,KAAK,GAAG;AACjB,IAAI,MAAM,IAAI,kBAAkB,CAAC,yBAAyB,CAAC;AAC3D,EAAE;;AAEF,EAAE,OAAO,OAAO,GAAG;AACnB,IAAI,OAAO,KAAK;AAChB,EAAE;AACF;;;;","x_google_ignoreList":[0]}

package/lib/esm/node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/reference.js

@@ -0,0 +1,14 @@
+import { XdrPrimitiveType } from './xdr-type.js';
+import { XdrDefinitionError } from './errors.js';
+
+class Reference extends XdrPrimitiveType {
+  /* jshint unused: false */
+  resolve() {
+    throw new XdrDefinitionError(
+      '"resolve" method should be implemented in the descendant class'
+    );
+  }
+}
+
+export { Reference };
+//# sourceMappingURL=reference.js.map

package/lib/esm/node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/reference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference.js","sources":["../../../../../../../../../node_modules/.pnpm/@stellar+js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/reference.js"],"sourcesContent":["import { XdrPrimitiveType } from './xdr-type';\nimport { XdrDefinitionError } from './errors';\n\nexport class Reference extends XdrPrimitiveType {\n  /* jshint unused: false */\n  resolve() {\n    throw new XdrDefinitionError(\n      '\"resolve\" method should be implemented in the descendant class'\n    );\n  }\n}\n"],"names":[],"mappings":";;;AAGO,MAAM,SAAS,SAAS,gBAAgB,CAAC;AAChD;AACA,EAAE,OAAO,GAAG;AACZ,IAAI,MAAM,IAAI,kBAAkB;AAChC,MAAM;AACN,KAAK;AACL,EAAE;AACF;;;;","x_google_ignoreList":[0]}

package/lib/esm/node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/serialization/xdr-reader.js

@@ -0,0 +1,169 @@
+import { Buffer } from 'buffer';
+import { XdrReaderError } from '../errors.js';
+
+class XdrReader {
+  /**
+   * @constructor
+   * @param {Buffer} source - Buffer containing serialized data
+   */
+  constructor(source) {
+    if (!Buffer.isBuffer(source)) {
+      if (
+        source instanceof Array ||
+        Array.isArray(source) ||
+        ArrayBuffer.isView(source)
+      ) {
+        source = Buffer.from(source);
+      } else {
+        throw new XdrReaderError(`source invalid: ${source}`);
+      }
+    }
+
+    this._buffer = source;
+    this._length = source.length;
+    this._index = 0;
+  }
+
+  /**
+   * @type {Buffer}
+   * @private
+   * @readonly
+   */
+  _buffer;
+  /**
+   * @type {Number}
+   * @private
+   * @readonly
+   */
+  _length;
+  /**
+   * @type {Number}
+   * @private
+   * @readonly
+   */
+  _index;
+
+  /**
+   * Check if the reader reached the end of the input buffer
+   * @return {Boolean}
+   */
+  get eof() {
+    return this._index === this._length;
+  }
+
+  /**
+   * Advance reader position, check padding and overflow
+   * @param {Number} size - Bytes to read
+   * @return {Number} Position to read from
+   * @private
+   */
+  advance(size) {
+    const from = this._index;
+    // advance cursor position
+    this._index += size;
+    // check buffer boundaries
+    if (this._length < this._index)
+      throw new XdrReaderError(
+        'attempt to read outside the boundary of the buffer'
+      );
+    // check that padding is correct for Opaque and String
+    const padding = 4 - (size % 4 || 4);
+    if (padding > 0) {
+      for (let i = 0; i < padding; i++)
+        if (this._buffer[this._index + i] !== 0)
+          // all bytes in the padding should be zeros
+          throw new XdrReaderError('invalid padding');
+      this._index += padding;
+    }
+    return from;
+  }
+
+  /**
+   * Reset reader position
+   * @return {void}
+   */
+  rewind() {
+    this._index = 0;
+  }
+
+  /**
+   * Remaining unread bytes in the source buffer
+   * @return {Number}
+   */
+  remainingBytes() {
+    return this._length - this._index;
+  }
+
+  /**
+   * Read byte array from the buffer
+   * @param {Number} size - Bytes to read
+   * @return {Buffer} - Sliced portion of the underlying buffer
+   */
+  read(size) {
+    const from = this.advance(size);
+    return this._buffer.subarray(from, from + size);
+  }
+
+  /**
+   * Read i32 from buffer
+   * @return {Number}
+   */
+  readInt32BE() {
+    return this._buffer.readInt32BE(this.advance(4));
+  }
+
+  /**
+   * Read u32 from buffer
+   * @return {Number}
+   */
+  readUInt32BE() {
+    return this._buffer.readUInt32BE(this.advance(4));
+  }
+
+  /**
+   * Read i64 from buffer
+   * @return {BigInt}
+   */
+  readBigInt64BE() {
+    return this._buffer.readBigInt64BE(this.advance(8));
+  }
+
+  /**
+   * Read u64 from buffer
+   * @return {BigInt}
+   */
+  readBigUInt64BE() {
+    return this._buffer.readBigUInt64BE(this.advance(8));
+  }
+
+  /**
+   * Read float from buffer
+   * @return {Number}
+   */
+  readFloatBE() {
+    return this._buffer.readFloatBE(this.advance(4));
+  }
+
+  /**
+   * Read double from buffer
+   * @return {Number}
+   */
+  readDoubleBE() {
+    return this._buffer.readDoubleBE(this.advance(8));
+  }
+
+  /**
+   * Ensure that input buffer has been consumed in full, otherwise it's a type mismatch
+   * @return {void}
+   * @throws {XdrReaderError}
+   */
+  ensureInputConsumed() {
+    if (this._index !== this._length)
+      throw new XdrReaderError(
+        `invalid XDR contract typecast - source buffer not entirely consumed`
+      );
+  }
+}
+
+export { XdrReader };
+//# sourceMappingURL=xdr-reader.js.map

package/lib/esm/node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/serialization/xdr-reader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xdr-reader.js","sources":["../../../../../../../../../../node_modules/.pnpm/@stellar+js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/serialization/xdr-reader.js"],"sourcesContent":["/**\n * @internal\n */\nimport { XdrReaderError } from '../errors';\n\nexport class XdrReader {\n  /**\n   * @constructor\n   * @param {Buffer} source - Buffer containing serialized data\n   */\n  constructor(source) {\n    if (!Buffer.isBuffer(source)) {\n      if (\n        source instanceof Array ||\n        Array.isArray(source) ||\n        ArrayBuffer.isView(source)\n      ) {\n        source = Buffer.from(source);\n      } else {\n        throw new XdrReaderError(`source invalid: ${source}`);\n      }\n    }\n\n    this._buffer = source;\n    this._length = source.length;\n    this._index = 0;\n  }\n\n  /**\n   * @type {Buffer}\n   * @private\n   * @readonly\n   */\n  _buffer;\n  /**\n   * @type {Number}\n   * @private\n   * @readonly\n   */\n  _length;\n  /**\n   * @type {Number}\n   * @private\n   * @readonly\n   */\n  _index;\n\n  /**\n   * Check if the reader reached the end of the input buffer\n   * @return {Boolean}\n   */\n  get eof() {\n    return this._index === this._length;\n  }\n\n  /**\n   * Advance reader position, check padding and overflow\n   * @param {Number} size - Bytes to read\n   * @return {Number} Position to read from\n   * @private\n   */\n  advance(size) {\n    const from = this._index;\n    // advance cursor position\n    this._index += size;\n    // check buffer boundaries\n    if (this._length < this._index)\n      throw new XdrReaderError(\n        'attempt to read outside the boundary of the buffer'\n      );\n    // check that padding is correct for Opaque and String\n    const padding = 4 - (size % 4 || 4);\n    if (padding > 0) {\n      for (let i = 0; i < padding; i++)\n        if (this._buffer[this._index + i] !== 0)\n          // all bytes in the padding should be zeros\n          throw new XdrReaderError('invalid padding');\n      this._index += padding;\n    }\n    return from;\n  }\n\n  /**\n   * Reset reader position\n   * @return {void}\n   */\n  rewind() {\n    this._index = 0;\n  }\n\n  /**\n   * Remaining unread bytes in the source buffer\n   * @return {Number}\n   */\n  remainingBytes() {\n    return this._length - this._index;\n  }\n\n  /**\n   * Read byte array from the buffer\n   * @param {Number} size - Bytes to read\n   * @return {Buffer} - Sliced portion of the underlying buffer\n   */\n  read(size) {\n    const from = this.advance(size);\n    return this._buffer.subarray(from, from + size);\n  }\n\n  /**\n   * Read i32 from buffer\n   * @return {Number}\n   */\n  readInt32BE() {\n    return this._buffer.readInt32BE(this.advance(4));\n  }\n\n  /**\n   * Read u32 from buffer\n   * @return {Number}\n   */\n  readUInt32BE() {\n    return this._buffer.readUInt32BE(this.advance(4));\n  }\n\n  /**\n   * Read i64 from buffer\n   * @return {BigInt}\n   */\n  readBigInt64BE() {\n    return this._buffer.readBigInt64BE(this.advance(8));\n  }\n\n  /**\n   * Read u64 from buffer\n   * @return {BigInt}\n   */\n  readBigUInt64BE() {\n    return this._buffer.readBigUInt64BE(this.advance(8));\n  }\n\n  /**\n   * Read float from buffer\n   * @return {Number}\n   */\n  readFloatBE() {\n    return this._buffer.readFloatBE(this.advance(4));\n  }\n\n  /**\n   * Read double from buffer\n   * @return {Number}\n   */\n  readDoubleBE() {\n    return this._buffer.readDoubleBE(this.advance(8));\n  }\n\n  /**\n   * Ensure that input buffer has been consumed in full, otherwise it's a type mismatch\n   * @return {void}\n   * @throws {XdrReaderError}\n   */\n  ensureInputConsumed() {\n    if (this._index !== this._length)\n      throw new XdrReaderError(\n        `invalid XDR contract typecast - source buffer not entirely consumed`\n      );\n  }\n}\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/lib/esm/node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/serialization/xdr-writer.js

@@ -0,0 +1,184 @@
+import { Buffer } from 'buffer';
+
+const BUFFER_CHUNK = 8192; // 8 KB chunk size increment
+
+/**
+ * @internal
+ */
+class XdrWriter {
+  /**
+   * @param {Buffer|Number} [buffer] - Optional destination buffer
+   */
+  constructor(buffer) {
+    if (typeof buffer === 'number') {
+      buffer = Buffer.allocUnsafe(buffer);
+    } else if (!(buffer instanceof Buffer)) {
+      buffer = Buffer.allocUnsafe(BUFFER_CHUNK);
+    }
+    this._buffer = buffer;
+    this._length = buffer.length;
+  }
+
+  /**
+   * @type {Buffer}
+   * @private
+   * @readonly
+   */
+  _buffer;
+  /**
+   * @type {Number}
+   * @private
+   * @readonly
+   */
+  _length;
+  /**
+   * @type {Number}
+   * @private
+   * @readonly
+   */
+  _index = 0;
+
+  /**
+   * Advance writer position, write padding if needed, auto-resize the buffer
+   * @param {Number} size - Bytes to write
+   * @return {Number} Position to read from
+   * @private
+   */
+  alloc(size) {
+    const from = this._index;
+    // advance cursor position
+    this._index += size;
+    // ensure sufficient buffer size
+    if (this._length < this._index) {
+      this.resize(this._index);
+    }
+    return from;
+  }
+
+  /**
+   * Increase size of the underlying buffer
+   * @param {Number} minRequiredSize - Minimum required buffer size
+   * @return {void}
+   * @private
+   */
+  resize(minRequiredSize) {
+    // calculate new length, align new buffer length by chunk size
+    const newLength = Math.ceil(minRequiredSize / BUFFER_CHUNK) * BUFFER_CHUNK;
+    // create new buffer and copy previous data
+    const newBuffer = Buffer.allocUnsafe(newLength);
+    this._buffer.copy(newBuffer, 0, 0, this._length);
+    // update references
+    this._buffer = newBuffer;
+    this._length = newLength;
+  }
+
+  /**
+   * Return XDR-serialized value
+   * @return {Buffer}
+   */
+  finalize() {
+    // clip underlying buffer to the actually written value
+    return this._buffer.subarray(0, this._index);
+  }
+
+  /**
+   * Return XDR-serialized value as byte array
+   * @return {Number[]}
+   */
+  toArray() {
+    return [...this.finalize()];
+  }
+
+  /**
+   * Write byte array from the buffer
+   * @param {Buffer|String} value - Bytes/string to write
+   * @param {Number} size - Size in bytes
+   * @return {XdrReader} - XdrReader wrapper on top of a subarray
+   */
+  write(value, size) {
+    if (typeof value === 'string') {
+      // serialize string directly to the output buffer
+      const offset = this.alloc(size);
+      this._buffer.write(value, offset, 'utf8');
+    } else {
+      // copy data to the output buffer
+      if (!(value instanceof Buffer)) {
+        value = Buffer.from(value);
+      }
+      const offset = this.alloc(size);
+      value.copy(this._buffer, offset, 0, size);
+    }
+
+    // add padding for 4-byte XDR alignment
+    const padding = 4 - (size % 4 || 4);
+    if (padding > 0) {
+      const offset = this.alloc(padding);
+      this._buffer.fill(0, offset, this._index);
+    }
+  }
+
+  /**
+   * Write i32 from buffer
+   * @param {Number} value - Value to serialize
+   * @return {void}
+   */
+  writeInt32BE(value) {
+    const offset = this.alloc(4);
+    this._buffer.writeInt32BE(value, offset);
+  }
+
+  /**
+   * Write u32 from buffer
+   * @param {Number} value - Value to serialize
+   * @return {void}
+   */
+  writeUInt32BE(value) {
+    const offset = this.alloc(4);
+    this._buffer.writeUInt32BE(value, offset);
+  }
+
+  /**
+   * Write i64 from buffer
+   * @param {BigInt} value - Value to serialize
+   * @return {void}
+   */
+  writeBigInt64BE(value) {
+    const offset = this.alloc(8);
+    this._buffer.writeBigInt64BE(value, offset);
+  }
+
+  /**
+   * Write u64 from buffer
+   * @param {BigInt} value - Value to serialize
+   * @return {void}
+   */
+  writeBigUInt64BE(value) {
+    const offset = this.alloc(8);
+    this._buffer.writeBigUInt64BE(value, offset);
+  }
+
+  /**
+   * Write float from buffer
+   * @param {Number} value - Value to serialize
+   * @return {void}
+   */
+  writeFloatBE(value) {
+    const offset = this.alloc(4);
+    this._buffer.writeFloatBE(value, offset);
+  }
+
+  /**
+   * Write double from buffer
+   * @param {Number} value - Value to serialize
+   * @return {void}
+   */
+  writeDoubleBE(value) {
+    const offset = this.alloc(8);
+    this._buffer.writeDoubleBE(value, offset);
+  }
+
+  static bufferChunkSize = BUFFER_CHUNK;
+}
+
+export { XdrWriter };
+//# sourceMappingURL=xdr-writer.js.map