@gardenfi/swap 0.0.1-beta.9 → 0.0.2

package/dist/index381.js

@@ -1,26 +1,346 @@
-function i(e) {
-  const t = [];
-  let l = 0;
-  if (e === 0)
-    return [0];
-  for (; e > 0; )
-    t[l] = e & 127, (e >>= 7) && (t[l] |= 128), l += 1;
-  return t;
-}
-function o(e) {
-  let t = 0, l = 0, r = 0;
-  for (; ; ) {
-    const n = e[r];
-    if (r += 1, t |= (n & 127) << l, !(n & 128))
-      break;
-    l += 7;
+import { InvalidTypeError as C, InvalidArrayError as _, ArrayLengthMismatchError as $, BytesSizeMismatchError as O } from "./index352.js";
+import { checksum as M, assert as R } from "./index281.js";
+import { toNumber as u, slice as T, toBoolean as D, toBigInt as U, toString as V, trimLeft as j } from "./index282.js";
+import { BaseError as q } from "./index278.js";
+import { size as h, fromNumber as B, concat as m, fromBytes as w, padLeft as S, fromBoolean as F, IntegerOutOfRangeError as G, padRight as b, fromString as H, slice as J } from "./index277.js";
+import { integerRegex as K } from "./index287.js";
+function p(t, e, o) {
+  const { checksumAddress: n, staticPosition: s } = o, i = I(e.type);
+  if (i) {
+    const [r, d] = i;
+    return X(t, { ...e, type: d }, { checksumAddress: n, length: r, staticPosition: s });
+  }
+  if (e.type === "tuple")
+    return tt(t, e, {
+      checksumAddress: n,
+      staticPosition: s
+    });
+  if (e.type === "address")
+    return Q(t, { checksum: n });
+  if (e.type === "bool")
+    return Y(t);
+  if (e.type.startsWith("bytes"))
+    return Z(t, e, { staticPosition: s });
+  if (e.type.startsWith("uint") || e.type.startsWith("int"))
+    return v(t, e);
+  if (e.type === "string")
+    return et(t, { staticPosition: s });
+  throw new C(e.type);
+}
+const k = 32, A = 32;
+function Q(t, e = {}) {
+  const { checksum: o = !1 } = e, n = t.readBytes(32);
+  return [((i) => o ? M(i) : i)(w(T(n, -20))), 32];
+}
+function X(t, e, o) {
+  const { checksumAddress: n, length: s, staticPosition: i } = o;
+  if (!s) {
+    const c = u(t.readBytes(A)), a = i + c, f = a + k;
+    t.setPosition(a);
+    const y = u(t.readBytes(k)), l = g(e);
+    let P = 0;
+    const N = [];
+    for (let z = 0; z < y; ++z) {
+      t.setPosition(f + (l ? z * 32 : P));
+      const [L, E] = p(t, e, {
+        checksumAddress: n,
+        staticPosition: f
+      });
+      P += E, N.push(L);
+    }
+    return t.setPosition(i + 32), [N, 32];
+  }
+  if (g(e)) {
+    const c = u(t.readBytes(A)), a = i + c, f = [];
+    for (let y = 0; y < s; ++y) {
+      t.setPosition(a + y * 32);
+      const [l] = p(t, e, {
+        checksumAddress: n,
+        staticPosition: a
+      });
+      f.push(l);
+    }
+    return t.setPosition(i + 32), [f, 32];
+  }
+  let r = 0;
+  const d = [];
+  for (let c = 0; c < s; ++c) {
+    const [a, f] = p(t, e, {
+      checksumAddress: n,
+      staticPosition: i + r
+    });
+    r += f, d.push(a);
+  }
+  return [d, r];
+}
+function Y(t) {
+  return [D(t.readBytes(32), { size: 32 }), 32];
+}
+function Z(t, e, { staticPosition: o }) {
+  const [n, s] = e.type.split("bytes");
+  if (!s) {
+    const r = u(t.readBytes(32));
+    t.setPosition(o + r);
+    const d = u(t.readBytes(32));
+    if (d === 0)
+      return t.setPosition(o + 32), ["0x", 32];
+    const c = t.readBytes(d);
+    return t.setPosition(o + 32), [w(c), 32];
+  }
+  return [w(t.readBytes(Number.parseInt(s, 10), 32)), 32];
+}
+function v(t, e) {
+  const o = e.type.startsWith("int"), n = Number.parseInt(e.type.split("int")[1] || "256", 10), s = t.readBytes(32);
+  return [
+    n > 48 ? U(s, { signed: o }) : u(s, { signed: o }),
+    32
+  ];
+}
+function tt(t, e, o) {
+  const { checksumAddress: n, staticPosition: s } = o, i = e.components.length === 0 || e.components.some(({ name: c }) => !c), r = i ? [] : {};
+  let d = 0;
+  if (g(e)) {
+    const c = u(t.readBytes(A)), a = s + c;
+    for (let f = 0; f < e.components.length; ++f) {
+      const y = e.components[f];
+      t.setPosition(a + d);
+      const [l, P] = p(t, y, {
+        checksumAddress: n,
+        staticPosition: a
+      });
+      d += P, r[i ? f : y == null ? void 0 : y.name] = l;
+    }
+    return t.setPosition(s + 32), [r, 32];
+  }
+  for (let c = 0; c < e.components.length; ++c) {
+    const a = e.components[c], [f, y] = p(t, a, {
+      checksumAddress: n,
+      staticPosition: s
+    });
+    r[i ? c : a == null ? void 0 : a.name] = f, d += y;
+  }
+  return [r, d];
+}
+function et(t, { staticPosition: e }) {
+  const o = u(t.readBytes(32)), n = e + o;
+  t.setPosition(n);
+  const s = u(t.readBytes(32));
+  if (s === 0)
+    return t.setPosition(e + 32), ["", 32];
+  const i = t.readBytes(s, 32), r = V(j(i));
+  return t.setPosition(e + 32), [r, 32];
+}
+function pt({ checksumAddress: t, parameters: e, values: o }) {
+  const n = [];
+  for (let s = 0; s < e.length; s++)
+    n.push(x({
+      checksumAddress: t,
+      parameter: e[s],
+      value: o[s]
+    }));
+  return n;
+}
+function x({ checksumAddress: t = !1, parameter: e, value: o }) {
+  const n = e, s = I(n.type);
+  if (s) {
+    const [i, r] = s;
+    return st(o, {
+      checksumAddress: t,
+      length: i,
+      parameter: {
+        ...n,
+        type: r
+      }
+    });
+  }
+  if (n.type === "tuple")
+    return dt(o, {
+      checksumAddress: t,
+      parameter: n
+    });
+  if (n.type === "address")
+    return nt(o, {
+      checksum: t
+    });
+  if (n.type === "bool")
+    return it(o);
+  if (n.type.startsWith("uint") || n.type.startsWith("int")) {
+    const i = n.type.startsWith("int"), [, , r = "256"] = K.exec(n.type) ?? [];
+    return rt(o, {
+      signed: i,
+      size: Number(r)
+    });
+  }
+  if (n.type.startsWith("bytes"))
+    return ot(o, { type: n.type });
+  if (n.type === "string")
+    return ct(o);
+  throw new C(n.type);
+}
+function W(t) {
+  let e = 0;
+  for (let i = 0; i < t.length; i++) {
+    const { dynamic: r, encoded: d } = t[i];
+    r ? e += 32 : e += h(d);
+  }
+  const o = [], n = [];
+  let s = 0;
+  for (let i = 0; i < t.length; i++) {
+    const { dynamic: r, encoded: d } = t[i];
+    r ? (o.push(B(e + s, { size: 32 })), n.push(d), s += h(d)) : o.push(d);
+  }
+  return m(...o, ...n);
+}
+function nt(t, e) {
+  const { checksum: o = !1 } = e;
+  return R(t, { strict: o }), {
+    dynamic: !1,
+    encoded: S(t.toLowerCase())
+  };
+}
+function st(t, e) {
+  const { checksumAddress: o, length: n, parameter: s } = e, i = n === null;
+  if (!Array.isArray(t))
+    throw new _(t);
+  if (!i && t.length !== n)
+    throw new $({
+      expectedLength: n,
+      givenLength: t.length,
+      type: `${s.type}[${n}]`
+    });
+  let r = !1;
+  const d = [];
+  for (let c = 0; c < t.length; c++) {
+    const a = x({
+      checksumAddress: o,
+      parameter: s,
+      value: t[c]
+    });
+    a.dynamic && (r = !0), d.push(a);
+  }
+  if (i || r) {
+    const c = W(d);
+    if (i) {
+      const a = B(d.length, { size: 32 });
+      return {
+        dynamic: !0,
+        encoded: d.length > 0 ? m(a, c) : a
+      };
+    }
+    if (r)
+      return { dynamic: !0, encoded: c };
+  }
+  return {
+    dynamic: !1,
+    encoded: m(...d.map(({ encoded: c }) => c))
+  };
+}
+function ot(t, { type: e }) {
+  const [, o] = e.split("bytes"), n = h(t);
+  if (!o) {
+    let s = t;
+    return n % 32 !== 0 && (s = b(s, Math.ceil((t.length - 2) / 2 / 32) * 32)), {
+      dynamic: !0,
+      encoded: m(S(B(n, { size: 32 })), s)
+    };
+  }
+  if (n !== Number.parseInt(o, 10))
+    throw new O({
+      expectedSize: Number.parseInt(o, 10),
+      value: t
+    });
+  return { dynamic: !1, encoded: b(t) };
+}
+function it(t) {
+  if (typeof t != "boolean")
+    throw new q(`Invalid boolean value: "${t}" (type: ${typeof t}). Expected: \`true\` or \`false\`.`);
+  return { dynamic: !1, encoded: S(F(t)) };
+}
+function rt(t, { signed: e, size: o }) {
+  if (typeof o == "number") {
+    const n = 2n ** (BigInt(o) - (e ? 1n : 0n)) - 1n, s = e ? -n - 1n : 0n;
+    if (t > n || t < s)
+      throw new G({
+        max: n.toString(),
+        min: s.toString(),
+        signed: e,
+        size: o / 8,
+        value: t.toString()
+      });
+  }
+  return {
+    dynamic: !1,
+    encoded: B(t, {
+      size: 32,
+      signed: e
+    })
+  };
+}
+function ct(t) {
+  const e = H(t), o = Math.ceil(h(e) / 32), n = [];
+  for (let s = 0; s < o; s++)
+    n.push(b(J(e, s * 32, (s + 1) * 32)));
+  return {
+    dynamic: !0,
+    encoded: m(b(B(h(e), { size: 32 })), ...n)
+  };
+}
+function dt(t, e) {
+  const { checksumAddress: o, parameter: n } = e;
+  let s = !1;
+  const i = [];
+  for (let r = 0; r < n.components.length; r++) {
+    const d = n.components[r], c = Array.isArray(t) ? r : d.name, a = x({
+      checksumAddress: o,
+      parameter: d,
+      value: t[c]
+    });
+    i.push(a), a.dynamic && (s = !0);
   }
   return {
-    value: t,
-    length: r
+    dynamic: s,
+    encoded: s ? W(i) : m(...i.map(({ encoded: r }) => r))
   };
 }
+function I(t) {
+  const e = t.match(/^(.*)\[(\d+)?\]$/);
+  return e ? (
+    // Return `null` if the array is dynamic.
+    [e[2] ? Number(e[2]) : null, e[1]]
+  ) : void 0;
+}
+function g(t) {
+  var n;
+  const { type: e } = t;
+  if (e === "string" || e === "bytes" || e.endsWith("[]"))
+    return !0;
+  if (e === "tuple")
+    return (n = t.components) == null ? void 0 : n.some(g);
+  const o = I(t.type);
+  return !!(o && g({
+    ...t,
+    type: o[1]
+  }));
+}
 export {
-  o as ulebDecode,
-  i as ulebEncode
+  Q as decodeAddress,
+  X as decodeArray,
+  Y as decodeBool,
+  Z as decodeBytes,
+  v as decodeNumber,
+  p as decodeParameter,
+  et as decodeString,
+  tt as decodeTuple,
+  W as encode,
+  nt as encodeAddress,
+  st as encodeArray,
+  it as encodeBoolean,
+  ot as encodeBytes,
+  rt as encodeNumber,
+  ct as encodeString,
+  dt as encodeTuple,
+  I as getArrayComponents,
+  g as hasDynamicChild,
+  x as prepareParameter,
+  pt as prepareParameters
 };

package/dist/index382.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const h=require("./index381.cjs"),o=require("./index332.cjs");class a{constructor({initialSize:t=1024,maxSize:e=1/0,allocateSize:i=1024}={}){this.bytePosition=0,this.size=t,this.maxSize=e,this.allocateSize=i,this.dataView=new DataView(new ArrayBuffer(t))}ensureSizeOrGrow(t){const e=this.bytePosition+t;if(e>this.size){const i=Math.min(this.maxSize,this.size+this.allocateSize);if(e>i)throw new Error(`Attempting to serialize to BCS, but buffer does not have enough size. Allocated size: ${this.size}, Max size: ${this.maxSize}, Required size: ${e}`);this.size=i;const s=new ArrayBuffer(this.size);new Uint8Array(s).set(new Uint8Array(this.dataView.buffer)),this.dataView=new DataView(s)}}shift(t){return this.bytePosition+=t,this}write8(t){return this.ensureSizeOrGrow(1),this.dataView.setUint8(this.bytePosition,Number(t)),this.shift(1)}write16(t){return this.ensureSizeOrGrow(2),this.dataView.setUint16(this.bytePosition,Number(t),!0),this.shift(2)}write32(t){return this.ensureSizeOrGrow(4),this.dataView.setUint32(this.bytePosition,Number(t),!0),this.shift(4)}write64(t){return n(BigInt(t),8).forEach(e=>this.write8(e)),this}write128(t){return n(BigInt(t),16).forEach(e=>this.write8(e)),this}write256(t){return n(BigInt(t),32).forEach(e=>this.write8(e)),this}writeULEB(t){return h.ulebEncode(t).forEach(e=>this.write8(e)),this}writeVec(t,e){return this.writeULEB(t.length),Array.from(t).forEach((i,s)=>e(this,i,s,t.length)),this}*[Symbol.iterator](){for(let t=0;t<this.bytePosition;t++)yield this.dataView.getUint8(t);return this.toBytes()}toBytes(){return new Uint8Array(this.dataView.buffer.slice(0,this.bytePosition))}toString(t){return o.encodeStr(this.toBytes(),t)}}function n(r,t){const e=new Uint8Array(t);let i=0;for(;r>0;)e[i]=Number(r%BigInt(256)),r=r/BigInt(256),i+=1;return e}exports.BcsWriter=a;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("./index278.cjs"),h={bytes:new Uint8Array,dataView:new DataView(new ArrayBuffer(0)),position:0,positionReadCount:new Map,recursiveReadCount:0,recursiveReadLimit:Number.POSITIVE_INFINITY,assertReadLimit(){if(this.recursiveReadCount>=this.recursiveReadLimit)throw new r({count:this.recursiveReadCount+1,limit:this.recursiveReadLimit})},assertPosition(t){if(t<0||t>this.bytes.length-1)throw new n({length:this.bytes.length,position:t})},decrementPosition(t){if(t<0)throw new e({offset:t});const i=this.position-t;this.assertPosition(i),this.position=i},getReadCount(t){return this.positionReadCount.get(t||this.position)||0},incrementPosition(t){if(t<0)throw new e({offset:t});const i=this.position+t;this.assertPosition(i),this.position=i},inspectByte(t){const i=t??this.position;return this.assertPosition(i),this.bytes[i]},inspectBytes(t,i){const s=i??this.position;return this.assertPosition(s+t-1),this.bytes.subarray(s,s+t)},inspectUint8(t){const i=t??this.position;return this.assertPosition(i),this.bytes[i]},inspectUint16(t){const i=t??this.position;return this.assertPosition(i+1),this.dataView.getUint16(i)},inspectUint24(t){const i=t??this.position;return this.assertPosition(i+2),(this.dataView.getUint16(i)<<8)+this.dataView.getUint8(i+2)},inspectUint32(t){const i=t??this.position;return this.assertPosition(i+3),this.dataView.getUint32(i)},pushByte(t){this.assertPosition(this.position),this.bytes[this.position]=t,this.position++},pushBytes(t){this.assertPosition(this.position+t.length-1),this.bytes.set(t,this.position),this.position+=t.length},pushUint8(t){this.assertPosition(this.position),this.bytes[this.position]=t,this.position++},pushUint16(t){this.assertPosition(this.position+1),this.dataView.setUint16(this.position,t),this.position+=2},pushUint24(t){this.assertPosition(this.position+2),this.dataView.setUint16(this.position,t>>8),this.dataView.setUint8(this.position+2,t&255),this.position+=3},pushUint32(t){this.assertPosition(this.position+3),this.dataView.setUint32(this.position,t),this.position+=4},readByte(){this.assertReadLimit(),this._touch();const t=this.inspectByte();return this.position++,t},readBytes(t,i){this.assertReadLimit(),this._touch();const s=this.inspectBytes(t);return this.position+=i??t,s},readUint8(){this.assertReadLimit(),this._touch();const t=this.inspectUint8();return this.position+=1,t},readUint16(){this.assertReadLimit(),this._touch();const t=this.inspectUint16();return this.position+=2,t},readUint24(){this.assertReadLimit(),this._touch();const t=this.inspectUint24();return this.position+=3,t},readUint32(){this.assertReadLimit(),this._touch();const t=this.inspectUint32();return this.position+=4,t},get remaining(){return this.bytes.length-this.position},setPosition(t){const i=this.position;return this.assertPosition(t),this.position=t,()=>this.position=i},_touch(){if(this.recursiveReadLimit===Number.POSITIVE_INFINITY)return;const t=this.getReadCount();this.positionReadCount.set(this.position,t+1),t>0&&this.recursiveReadCount++}};function a(t,{recursiveReadLimit:i=8192}={}){const s=Object.create(h);return s.bytes=t,s.dataView=new DataView(t.buffer,t.byteOffset,t.byteLength),s.positionReadCount=new Map,s.recursiveReadLimit=i,s}class e extends o.BaseError{constructor({offset:i}){super(`Offset \`${i}\` cannot be negative.`),Object.defineProperty(this,"name",{enumerable:!0,configurable:!0,writable:!0,value:"Cursor.NegativeOffsetError"})}}class n extends o.BaseError{constructor({length:i,position:s}){super(`Position \`${s}\` is out of bounds (\`0 < position < ${i}\`).`),Object.defineProperty(this,"name",{enumerable:!0,configurable:!0,writable:!0,value:"Cursor.PositionOutOfBoundsError"})}}class r extends o.BaseError{constructor({count:i,limit:s}){super(`Recursive read limit of \`${s}\` exceeded (recursive read count: \`${i}\`).`),Object.defineProperty(this,"name",{enumerable:!0,configurable:!0,writable:!0,value:"Cursor.RecursiveReadLimitExceededError"})}}exports.NegativeOffsetError=e;exports.PositionOutOfBoundsError=n;exports.RecursiveReadLimitExceededError=r;exports.create=a;

package/dist/index382.js

@@ -1,136 +1,163 @@
-import { ulebEncode as h } from "./index381.js";
-import { encodeStr as o } from "./index332.js";
-class u {
-  constructor({
-    initialSize: t = 1024,
-    maxSize: i = 1 / 0,
-    allocateSize: e = 1024
-  } = {}) {
-    this.bytePosition = 0, this.size = t, this.maxSize = i, this.allocateSize = e, this.dataView = new DataView(new ArrayBuffer(t));
+import { BaseError as e } from "./index278.js";
+const n = {
+  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 h({
+        count: this.recursiveReadCount + 1,
+        limit: this.recursiveReadLimit
+      });
+  },
+  assertPosition(t) {
+    if (t < 0 || t > this.bytes.length - 1)
+      throw new r({
+        length: this.bytes.length,
+        position: t
+      });
+  },
+  decrementPosition(t) {
+    if (t < 0)
+      throw new o({ offset: t });
+    const i = this.position - t;
+    this.assertPosition(i), this.position = i;
+  },
+  getReadCount(t) {
+    return this.positionReadCount.get(t || this.position) || 0;
+  },
+  incrementPosition(t) {
+    if (t < 0)
+      throw new o({ offset: t });
+    const i = this.position + t;
+    this.assertPosition(i), this.position = i;
+  },
+  inspectByte(t) {
+    const i = t ?? this.position;
+    return this.assertPosition(i), this.bytes[i];
+  },
+  inspectBytes(t, i) {
+    const s = i ?? this.position;
+    return this.assertPosition(s + t - 1), this.bytes.subarray(s, s + t);
+  },
+  inspectUint8(t) {
+    const i = t ?? this.position;
+    return this.assertPosition(i), this.bytes[i];
+  },
+  inspectUint16(t) {
+    const i = t ?? this.position;
+    return this.assertPosition(i + 1), this.dataView.getUint16(i);
+  },
+  inspectUint24(t) {
+    const i = t ?? this.position;
+    return this.assertPosition(i + 2), (this.dataView.getUint16(i) << 8) + this.dataView.getUint8(i + 2);
+  },
+  inspectUint32(t) {
+    const i = t ?? this.position;
+    return this.assertPosition(i + 3), this.dataView.getUint32(i);
+  },
+  pushByte(t) {
+    this.assertPosition(this.position), this.bytes[this.position] = t, this.position++;
+  },
+  pushBytes(t) {
+    this.assertPosition(this.position + t.length - 1), this.bytes.set(t, this.position), this.position += t.length;
+  },
+  pushUint8(t) {
+    this.assertPosition(this.position), this.bytes[this.position] = t, this.position++;
+  },
+  pushUint16(t) {
+    this.assertPosition(this.position + 1), this.dataView.setUint16(this.position, t), this.position += 2;
+  },
+  pushUint24(t) {
+    this.assertPosition(this.position + 2), this.dataView.setUint16(this.position, t >> 8), this.dataView.setUint8(this.position + 2, t & 255), this.position += 3;
+  },
+  pushUint32(t) {
+    this.assertPosition(this.position + 3), this.dataView.setUint32(this.position, t), this.position += 4;
+  },
+  readByte() {
+    this.assertReadLimit(), this._touch();
+    const t = this.inspectByte();
+    return this.position++, t;
+  },
+  readBytes(t, i) {
+    this.assertReadLimit(), this._touch();
+    const s = this.inspectBytes(t);
+    return this.position += i ?? t, s;
+  },
+  readUint8() {
+    this.assertReadLimit(), this._touch();
+    const t = this.inspectUint8();
+    return this.position += 1, t;
+  },
+  readUint16() {
+    this.assertReadLimit(), this._touch();
+    const t = this.inspectUint16();
+    return this.position += 2, t;
+  },
+  readUint24() {
+    this.assertReadLimit(), this._touch();
+    const t = this.inspectUint24();
+    return this.position += 3, t;
+  },
+  readUint32() {
+    this.assertReadLimit(), this._touch();
+    const t = this.inspectUint32();
+    return this.position += 4, t;
+  },
+  get remaining() {
+    return this.bytes.length - this.position;
+  },
+  setPosition(t) {
+    const i = this.position;
+    return this.assertPosition(t), this.position = t, () => this.position = i;
+  },
+  _touch() {
+    if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
+      return;
+    const t = this.getReadCount();
+    this.positionReadCount.set(this.position, t + 1), t > 0 && this.recursiveReadCount++;
   }
-  ensureSizeOrGrow(t) {
-    const i = this.bytePosition + t;
-    if (i > this.size) {
-      const e = Math.min(this.maxSize, this.size + this.allocateSize);
-      if (i > e)
-        throw new Error(
-          `Attempting to serialize to BCS, but buffer does not have enough size. Allocated size: ${this.size}, Max size: ${this.maxSize}, Required size: ${i}`
-        );
-      this.size = e;
-      const s = new ArrayBuffer(this.size);
-      new Uint8Array(s).set(new Uint8Array(this.dataView.buffer)), this.dataView = new DataView(s);
-    }
-  }
-  /**
-   * Shift current cursor position by `bytes`.
-   *
-   * @param {Number} bytes Number of bytes to
-   * @returns {this} Self for possible chaining.
-   */
-  shift(t) {
-    return this.bytePosition += t, this;
-  }
-  /**
-   * Write a U8 value into a buffer and shift cursor position by 1.
-   * @param {Number} value Value to write.
-   * @returns {this}
-   */
-  write8(t) {
-    return this.ensureSizeOrGrow(1), this.dataView.setUint8(this.bytePosition, Number(t)), this.shift(1);
-  }
-  /**
-   * Write a U16 value into a buffer and shift cursor position by 2.
-   * @param {Number} value Value to write.
-   * @returns {this}
-   */
-  write16(t) {
-    return this.ensureSizeOrGrow(2), this.dataView.setUint16(this.bytePosition, Number(t), !0), this.shift(2);
-  }
-  /**
-   * Write a U32 value into a buffer and shift cursor position by 4.
-   * @param {Number} value Value to write.
-   * @returns {this}
-   */
-  write32(t) {
-    return this.ensureSizeOrGrow(4), this.dataView.setUint32(this.bytePosition, Number(t), !0), this.shift(4);
-  }
-  /**
-   * Write a U64 value into a buffer and shift cursor position by 8.
-   * @param {bigint} value Value to write.
-   * @returns {this}
-   */
-  write64(t) {
-    return n(BigInt(t), 8).forEach((i) => this.write8(i)), this;
-  }
-  /**
-   * Write a U128 value into a buffer and shift cursor position by 16.
-   *
-   * @param {bigint} value Value to write.
-   * @returns {this}
-   */
-  write128(t) {
-    return n(BigInt(t), 16).forEach((i) => this.write8(i)), this;
-  }
-  /**
-   * Write a U256 value into a buffer and shift cursor position by 16.
-   *
-   * @param {bigint} value Value to write.
-   * @returns {this}
-   */
-  write256(t) {
-    return n(BigInt(t), 32).forEach((i) => this.write8(i)), this;
-  }
-  /**
-   * Write a ULEB value into a buffer and shift cursor position by number of bytes
-   * written.
-   * @param {Number} value Value to write.
-   * @returns {this}
-   */
-  writeULEB(t) {
-    return h(t).forEach((i) => this.write8(i)), this;
-  }
-  /**
-   * Write a vector into a buffer by first writing the vector length and then calling
-   * a callback on each passed value.
-   *
-   * @param {Array<Any>} vector Array of elements to write.
-   * @param {WriteVecCb} cb Callback to call on each element of the vector.
-   * @returns {this}
-   */
-  writeVec(t, i) {
-    return this.writeULEB(t.length), Array.from(t).forEach((e, s) => i(this, e, s, t.length)), this;
-  }
-  /**
-   * Adds support for iterations over the object.
-   * @returns {Uint8Array}
-   */
-  *[Symbol.iterator]() {
-    for (let t = 0; t < this.bytePosition; t++)
-      yield this.dataView.getUint8(t);
-    return this.toBytes();
-  }
-  /**
-   * Get underlying buffer taking only value bytes (in case initial buffer size was bigger).
-   * @returns {Uint8Array} Resulting bcs.
-   */
-  toBytes() {
-    return new Uint8Array(this.dataView.buffer.slice(0, this.bytePosition));
+};
+function u(t, { recursiveReadLimit: i = 8192 } = {}) {
+  const s = Object.create(n);
+  return s.bytes = t, s.dataView = new DataView(t.buffer, t.byteOffset, t.byteLength), s.positionReadCount = /* @__PURE__ */ new Map(), s.recursiveReadLimit = i, s;
+}
+class o extends e {
+  constructor({ offset: i }) {
+    super(`Offset \`${i}\` cannot be negative.`), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "Cursor.NegativeOffsetError"
+    });
   }
-  /**
-   * Represent data as 'hex' or 'base64'
-   * @param encoding Encoding to use: 'base64' or 'hex'
-   */
-  toString(t) {
-    return o(this.toBytes(), t);
+}
+class r extends e {
+  constructor({ length: i, position: s }) {
+    super(`Position \`${s}\` is out of bounds (\`0 < position < ${i}\`).`), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "Cursor.PositionOutOfBoundsError"
+    });
   }
 }
-function n(r, t) {
-  const i = new Uint8Array(t);
-  let e = 0;
-  for (; r > 0; )
-    i[e] = Number(r % BigInt(256)), r = r / BigInt(256), e += 1;
-  return i;
+class h extends e {
+  constructor({ count: i, limit: s }) {
+    super(`Recursive read limit of \`${s}\` exceeded (recursive read count: \`${i}\`).`), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "Cursor.RecursiveReadLimitExceededError"
+    });
+  }
 }
 export {
-  u as BcsWriter
+  o as NegativeOffsetError,
+  r as PositionOutOfBoundsError,
+  h as RecursiveReadLimitExceededError,
+  u as create
 };