@gardenfi/swap 0.1.3-beta.2 → 0.1.3-beta.21

package/dist/index372.js

@@ -1,357 +1,97 @@
-import { lazyBcsType as l, BcsEnum as h, BcsStruct as g, BcsTuple as E, stringLikeBcsType as B, BcsType as w, fixedSizeBcsType as f, dynamicSizeBcsType as x, bigUIntBcsType as u, uIntBcsType as m } from "./index326.js";
-import { ulebEncode as y } from "./index370.js";
-function $(e, r, a) {
-  return new w({
-    read: (t) => {
-      const d = new Array(e);
-      for (let n = 0; n < e; n++)
-        d[n] = r.read(t);
-      return d;
-    },
-    write: (t, d) => {
-      for (const n of t)
-        r.write(n, d);
-    },
-    ...a,
-    name: (a == null ? void 0 : a.name) ?? `${r.name}[${e}]`,
-    validate: (t) => {
-      var d;
-      if ((d = a == null ? void 0 : a.validate) == null || d.call(a, t), !t || typeof t != "object" || !("length" in t))
-        throw new TypeError(`Expected array, found ${typeof t}`);
-      if (t.length !== e)
-        throw new TypeError(`Expected array of length ${e}, found ${t.length}`);
-    }
-  });
-}
-function b(e) {
-  return c.enum(`Option<${e.name}>`, {
-    None: null,
-    Some: e
-  }).transform({
-    input: (r) => r == null ? { None: !0 } : { Some: r },
-    output: (r) => r.$kind === "Some" ? r.Some : null
-  });
-}
-function T(e, r) {
-  return new w({
-    read: (a) => {
-      const t = a.readULEB(), d = new Array(t);
-      for (let n = 0; n < t; n++)
-        d[n] = e.read(a);
-      return d;
-    },
-    write: (a, t) => {
-      t.writeULEB(a.length);
-      for (const d of a)
-        e.write(d, t);
-    },
-    ...r,
-    name: (r == null ? void 0 : r.name) ?? `vector<${e.name}>`,
-    validate: (a) => {
-      var t;
-      if ((t = r == null ? void 0 : r.validate) == null || t.call(r, a), !a || typeof a != "object" || !("length" in a))
-        throw new TypeError(`Expected array, found ${typeof a}`);
-    }
-  });
-}
-function M(e, r) {
-  return c.vector(c.tuple([e, r])).transform({
-    name: `Map<${e.name}, ${r.name}>`,
-    input: (a) => [...a.entries()],
-    output: (a) => {
-      const t = /* @__PURE__ */ new Map();
-      for (const [d, n] of a)
-        t.set(d, n);
-      return t;
-    }
-  });
-}
-const c = {
-  /**
-   * Creates a BcsType that can be used to read and write an 8-bit unsigned integer.
-   * @example
-   * bcs.u8().serialize(255).toBytes() // Uint8Array [ 255 ]
-   */
-  u8(e) {
-    return m({
-      readMethod: "read8",
-      writeMethod: "write8",
-      size: 1,
-      maxValue: 2 ** 8 - 1,
-      ...e,
-      name: (e == null ? void 0 : e.name) ?? "u8"
-    });
-  },
-  /**
-   * Creates a BcsType that can be used to read and write a 16-bit unsigned integer.
-   * @example
-   * bcs.u16().serialize(65535).toBytes() // Uint8Array [ 255, 255 ]
-   */
-  u16(e) {
-    return m({
-      readMethod: "read16",
-      writeMethod: "write16",
-      size: 2,
-      maxValue: 2 ** 16 - 1,
-      ...e,
-      name: (e == null ? void 0 : e.name) ?? "u16"
-    });
-  },
-  /**
-   * Creates a BcsType that can be used to read and write a 32-bit unsigned integer.
-   * @example
-   * bcs.u32().serialize(4294967295).toBytes() // Uint8Array [ 255, 255, 255, 255 ]
-   */
-  u32(e) {
-    return m({
-      readMethod: "read32",
-      writeMethod: "write32",
-      size: 4,
-      maxValue: 2 ** 32 - 1,
-      ...e,
-      name: (e == null ? void 0 : e.name) ?? "u32"
-    });
-  },
+import { ulebDecode as r } from "./index373.js";
+class o {
   /**
-   * Creates a BcsType that can be used to read and write a 64-bit unsigned integer.
-   * @example
-   * bcs.u64().serialize(1).toBytes() // Uint8Array [ 1, 0, 0, 0, 0, 0, 0, 0 ]
-   */
-  u64(e) {
-    return u({
-      readMethod: "read64",
-      writeMethod: "write64",
-      size: 8,
-      maxValue: 2n ** 64n - 1n,
-      ...e,
-      name: (e == null ? void 0 : e.name) ?? "u64"
-    });
-  },
-  /**
-   * Creates a BcsType that can be used to read and write a 128-bit unsigned integer.
-   * @example
-   * bcs.u128().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]
-   */
-  u128(e) {
-    return u({
-      readMethod: "read128",
-      writeMethod: "write128",
-      size: 16,
-      maxValue: 2n ** 128n - 1n,
-      ...e,
-      name: (e == null ? void 0 : e.name) ?? "u128"
-    });
-  },
-  /**
-   * Creates a BcsType that can be used to read and write a 256-bit unsigned integer.
-   * @example
-   * bcs.u256().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]
-   */
-  u256(e) {
-    return u({
-      readMethod: "read256",
-      writeMethod: "write256",
-      size: 32,
-      maxValue: 2n ** 256n - 1n,
-      ...e,
-      name: (e == null ? void 0 : e.name) ?? "u256"
-    });
-  },
-  /**
-   * Creates a BcsType that can be used to read and write boolean values.
-   * @example
-   * bcs.bool().serialize(true).toBytes() // Uint8Array [ 1 ]
-   */
-  bool(e) {
-    return f({
-      size: 1,
-      read: (r) => r.read8() === 1,
-      write: (r, a) => a.write8(r ? 1 : 0),
-      ...e,
-      name: (e == null ? void 0 : e.name) ?? "bool",
-      validate: (r) => {
-        var a;
-        if ((a = e == null ? void 0 : e.validate) == null || a.call(e, r), typeof r != "boolean")
-          throw new TypeError(`Expected boolean, found ${typeof r}`);
-      }
-    });
-  },
-  /**
-   * Creates a BcsType that can be used to read and write unsigned LEB encoded integers
-   * @example
-   *
+   * @param {Uint8Array} data Data to use as a buffer.
    */
-  uleb128(e) {
-    return x({
-      read: (r) => r.readULEB(),
-      serialize: (r) => Uint8Array.from(y(r)),
-      ...e,
-      name: (e == null ? void 0 : e.name) ?? "uleb128"
-    });
-  },
-  /**
-   * Creates a BcsType representing a fixed length byte array
-   * @param size The number of bytes this types represents
-   * @example
-   * bcs.bytes(3).serialize(new Uint8Array([1, 2, 3])).toBytes() // Uint8Array [1, 2, 3]
-   */
-  bytes(e, r) {
-    return f({
-      size: e,
-      read: (a) => a.readBytes(e),
-      write: (a, t) => {
-        t.writeBytes(new Uint8Array(a));
-      },
-      ...r,
-      name: (r == null ? void 0 : r.name) ?? `bytes[${e}]`,
-      validate: (a) => {
-        var t;
-        if ((t = r == null ? void 0 : r.validate) == null || t.call(r, a), !a || typeof a != "object" || !("length" in a))
-          throw new TypeError(`Expected array, found ${typeof a}`);
-        if (a.length !== e)
-          throw new TypeError(`Expected array of length ${e}, found ${a.length}`);
-      }
-    });
-  },
+  constructor(t) {
+    this.bytePosition = 0, this.dataView = new DataView(t.buffer, t.byteOffset, t.byteLength);
+  }
   /**
-   * Creates a BcsType representing a variable length byte array
+   * Shift current cursor position by `bytes`.
    *
-   * @example
-   * bcs.byteVector().serialize([1, 2, 3]).toBytes() // Uint8Array [3, 1, 2, 3]
+   * @param {Number} bytes Number of bytes to
+   * @returns {this} Self for possible chaining.
    */
-  byteVector(e) {
-    return new w({
-      read: (r) => {
-        const a = r.readULEB();
-        return r.readBytes(a);
-      },
-      write: (r, a) => {
-        const t = new Uint8Array(r);
-        a.writeULEB(t.length), a.writeBytes(t);
-      },
-      ...e,
-      name: (e == null ? void 0 : e.name) ?? "vector<u8>",
-      serializedSize: (r) => {
-        const a = "length" in r ? r.length : null;
-        return a == null ? null : y(a).length + a;
-      },
-      validate: (r) => {
-        var a;
-        if ((a = e == null ? void 0 : e.validate) == null || a.call(e, r), !r || typeof r != "object" || !("length" in r))
-          throw new TypeError(`Expected array, found ${typeof r}`);
-      }
-    });
-  },
+  shift(t) {
+    return this.bytePosition += t, this;
+  }
   /**
-   * Creates a BcsType that can ser/de string values.  Strings will be UTF-8 encoded
-   * @example
-   * bcs.string().serialize('a').toBytes() // Uint8Array [ 1, 97 ]
+   * Read U8 value from the buffer and shift cursor by 1.
+   * @returns
    */
-  string(e) {
-    return B({
-      toBytes: (r) => new TextEncoder().encode(r),
-      fromBytes: (r) => new TextDecoder().decode(r),
-      ...e,
-      name: (e == null ? void 0 : e.name) ?? "string"
-    });
-  },
+  read8() {
+    const t = this.dataView.getUint8(this.bytePosition);
+    return this.shift(1), t;
+  }
   /**
-   * Creates a BcsType that represents a fixed length array of a given type
-   * @param size The number of elements in the array
-   * @param type The BcsType of each element in the array
-   * @example
-   * bcs.fixedArray(3, bcs.u8()).serialize([1, 2, 3]).toBytes() // Uint8Array [ 1, 2, 3 ]
+   * Read U16 value from the buffer and shift cursor by 2.
+   * @returns
    */
-  fixedArray: $,
+  read16() {
+    const t = this.dataView.getUint16(this.bytePosition, !0);
+    return this.shift(2), t;
+  }
   /**
-   * Creates a BcsType representing an optional value
-   * @param type The BcsType of the optional value
-   * @example
-   * bcs.option(bcs.u8()).serialize(null).toBytes() // Uint8Array [ 0 ]
-   * bcs.option(bcs.u8()).serialize(1).toBytes() // Uint8Array [ 1, 1 ]
+   * Read U32 value from the buffer and shift cursor by 4.
+   * @returns
    */
-  option: b,
+  read32() {
+    const t = this.dataView.getUint32(this.bytePosition, !0);
+    return this.shift(4), t;
+  }
   /**
-   * Creates a BcsType representing a variable length vector of a given type
-   * @param type The BcsType of each element in the vector
-   *
-   * @example
-   * bcs.vector(bcs.u8()).toBytes([1, 2, 3]) // Uint8Array [ 3, 1, 2, 3 ]
+   * Read U64 value from the buffer and shift cursor by 8.
+   * @returns
    */
-  vector: T,
+  read64() {
+    const t = this.read32(), e = this.read32().toString(16) + t.toString(16).padStart(8, "0");
+    return BigInt("0x" + e).toString(10);
+  }
   /**
-   * Creates a BcsType representing a tuple of a given set of types
-   * @param types The BcsTypes for each element in the tuple
-   *
-   * @example
-   * const tuple = bcs.tuple([bcs.u8(), bcs.string(), bcs.bool()])
-   * tuple.serialize([1, 'a', true]).toBytes() // Uint8Array [ 1, 1, 97, 1 ]
+   * Read U128 value from the buffer and shift cursor by 16.
    */
-  tuple(e, r) {
-    return new E({
-      fields: e,
-      ...r
-    });
-  },
+  read128() {
+    const t = BigInt(this.read64()), e = BigInt(this.read64()).toString(16) + t.toString(16).padStart(16, "0");
+    return BigInt("0x" + e).toString(10);
+  }
   /**
-   * Creates a BcsType representing a struct of a given set of fields
-   * @param name The name of the struct
-   * @param fields The fields of the struct. The order of the fields affects how data is serialized and deserialized
-   *
-   * @example
-   * const struct = bcs.struct('MyStruct', {
-   *  a: bcs.u8(),
-   *  b: bcs.string(),
-   * })
-   * struct.serialize({ a: 1, b: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]
+   * Read U128 value from the buffer and shift cursor by 32.
+   * @returns
    */
-  struct(e, r, a) {
-    return new g({
-      name: e,
-      fields: r,
-      ...a
-    });
-  },
+  read256() {
+    const t = BigInt(this.read128()), e = BigInt(this.read128()).toString(16) + t.toString(16).padStart(32, "0");
+    return BigInt("0x" + e).toString(10);
+  }
   /**
-   * Creates a BcsType representing an enum of a given set of options
-   * @param name The name of the enum
-   * @param values The values of the enum. The order of the values affects how data is serialized and deserialized.
-   * null can be used to represent a variant with no data.
-   *
-   * @example
-   * const enum = bcs.enum('MyEnum', {
-   *   A: bcs.u8(),
-   *   B: bcs.string(),
-   *   C: null,
-   * })
-   * enum.serialize({ A: 1 }).toBytes() // Uint8Array [ 0, 1 ]
-   * enum.serialize({ B: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]
-   * enum.serialize({ C: true }).toBytes() // Uint8Array [ 2 ]
+   * Read `num` number of bytes from the buffer and shift cursor by `num`.
+   * @param num Number of bytes to read.
    */
-  enum(e, r, a) {
-    return new h({
-      name: e,
-      fields: r,
-      ...a
-    });
-  },
+  readBytes(t) {
+    const i = this.bytePosition + this.dataView.byteOffset, e = new Uint8Array(this.dataView.buffer, i, t);
+    return this.shift(t), e;
+  }
   /**
-   * Creates a BcsType representing a map of a given key and value type
-   * @param keyType The BcsType of the key
-   * @param valueType The BcsType of the value
-   * @example
-   * const map = bcs.map(bcs.u8(), bcs.string())
-   * map.serialize(new Map([[2, 'a']])).toBytes() // Uint8Array [ 1, 2, 1, 97 ]
+   * Read ULEB value - an integer of varying size. Used for enum indexes and
+   * vector lengths.
+   * @returns {Number} The ULEB value.
    */
-  map: M,
+  readULEB() {
+    const t = this.bytePosition + this.dataView.byteOffset, i = new Uint8Array(this.dataView.buffer, t), { value: e, length: s } = r(i);
+    return this.shift(s), e;
+  }
   /**
-   * Creates a BcsType that wraps another BcsType which is lazily evaluated. This is useful for creating recursive types.
-   * @param cb A callback that returns the BcsType
+   * Read a BCS vector: read a length and then apply function `cb` X times
+   * where X is the length of the vector, defined as ULEB in BCS bytes.
+   * @param cb Callback to process elements of vector.
+   * @returns {Array<Any>} Array of the resulting values, returned by callback.
    */
-  lazy(e) {
-    return l(e);
+  readVec(t) {
+    const i = this.readULEB(), e = [];
+    for (let s = 0; s < i; s++)
+      e.push(t(this, s, i));
+    return e;
   }
-};
+}
 export {
-  c as bcs
+  o as BcsReader
 };

package/dist/index373.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("./index339.cjs"),i=require("./index263.cjs"),o=/^vector<(.+)>$/,l=/^([^:]+)::([^:]+)::([^<]+)(<(.+)>)?/;class t{static parseFromStr(r,e=!1){if(r==="address")return{address:null};if(r==="bool")return{bool:null};if(r==="u8")return{u8:null};if(r==="u16")return{u16:null};if(r==="u32")return{u32:null};if(r==="u64")return{u64:null};if(r==="u128")return{u128:null};if(r==="u256")return{u256:null};if(r==="signer")return{signer:null};const u=r.match(o);if(u)return{vector:t.parseFromStr(u[1],e)};const n=r.match(l);if(n)return{struct:{address:e?i.normalizeSuiAddress(n[1]):n[1],module:n[2],name:n[3],typeParams:n[5]===void 0?[]:t.parseStructTypeArgs(n[5],e)}};throw new Error(`Encountered unexpected token when parsing type args for ${r}`)}static parseStructTypeArgs(r,e=!1){return s.splitGenericParameters(r).map(u=>t.parseFromStr(u,e))}static tagToString(r){if("bool"in r)return"bool";if("u8"in r)return"u8";if("u16"in r)return"u16";if("u32"in r)return"u32";if("u64"in r)return"u64";if("u128"in r)return"u128";if("u256"in r)return"u256";if("address"in r)return"address";if("signer"in r)return"signer";if("vector"in r)return`vector<${t.tagToString(r.vector)}>`;if("struct"in r){const e=r.struct,u=e.typeParams.map(t.tagToString).join(", ");return`${e.address}::${e.module}::${e.name}${u?`<${u}>`:""}`}throw new Error("Invalid TypeTag")}}exports.TypeTagSerializer=t;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function l(n){let e=BigInt(n);const t=[];let r=0;if(e===0n)return[0];for(;e>0;)t[r]=Number(e&0x7fn),e>>=7n,e>0n&&(t[r]|=128),r+=1;return t}function u(n){let e=0n,t=0n,r=0;for(;;){if(r>=n.length)throw new Error("ULEB decode error: buffer overflow");const o=n[r];if(r+=1,e+=BigInt(o&127)<<t,!(o&128))break;t+=7n}if(e>BigInt(Number.MAX_SAFE_INTEGER))throw new Error("ULEB decode error: value exceeds MAX_SAFE_INTEGER");return{value:Number(e),length:r}}exports.ulebDecode=u;exports.ulebEncode=l;

package/dist/index373.js

@@ -1,76 +1,31 @@
-import { splitGenericParameters as s } from "./index339.js";
-import { normalizeSuiAddress as i } from "./index263.js";
-const o = /^vector<(.+)>$/, l = /^([^:]+)::([^:]+)::([^<]+)(<(.+)>)?/;
-class t {
-  static parseFromStr(r, e = !1) {
-    if (r === "address")
-      return { address: null };
-    if (r === "bool")
-      return { bool: null };
-    if (r === "u8")
-      return { u8: null };
-    if (r === "u16")
-      return { u16: null };
-    if (r === "u32")
-      return { u32: null };
-    if (r === "u64")
-      return { u64: null };
-    if (r === "u128")
-      return { u128: null };
-    if (r === "u256")
-      return { u256: null };
-    if (r === "signer")
-      return { signer: null };
-    const n = r.match(o);
-    if (n)
-      return {
-        vector: t.parseFromStr(n[1], e)
-      };
-    const u = r.match(l);
-    if (u)
-      return {
-        struct: {
-          address: e ? i(u[1]) : u[1],
-          module: u[2],
-          name: u[3],
-          typeParams: u[5] === void 0 ? [] : t.parseStructTypeArgs(u[5], e)
-        }
-      };
-    throw new Error(`Encountered unexpected token when parsing type args for ${r}`);
-  }
-  static parseStructTypeArgs(r, e = !1) {
-    return s(r).map(
-      (n) => t.parseFromStr(n, e)
-    );
-  }
-  static tagToString(r) {
-    if ("bool" in r)
-      return "bool";
-    if ("u8" in r)
-      return "u8";
-    if ("u16" in r)
-      return "u16";
-    if ("u32" in r)
-      return "u32";
-    if ("u64" in r)
-      return "u64";
-    if ("u128" in r)
-      return "u128";
-    if ("u256" in r)
-      return "u256";
-    if ("address" in r)
-      return "address";
-    if ("signer" in r)
-      return "signer";
-    if ("vector" in r)
-      return `vector<${t.tagToString(r.vector)}>`;
-    if ("struct" in r) {
-      const e = r.struct, n = e.typeParams.map(t.tagToString).join(", ");
-      return `${e.address}::${e.module}::${e.name}${n ? `<${n}>` : ""}`;
-    }
-    throw new Error("Invalid TypeTag");
+function l(t) {
+  let e = BigInt(t);
+  const n = [];
+  let r = 0;
+  if (e === 0n)
+    return [0];
+  for (; e > 0; )
+    n[r] = Number(e & 0x7fn), e >>= 7n, e > 0n && (n[r] |= 128), r += 1;
+  return n;
+}
+function u(t) {
+  let e = 0n, n = 0n, r = 0;
+  for (; ; ) {
+    if (r >= t.length)
+      throw new Error("ULEB decode error: buffer overflow");
+    const o = t[r];
+    if (r += 1, e += BigInt(o & 127) << n, !(o & 128))
+      break;
+    n += 7n;
   }
+  if (e > BigInt(Number.MAX_SAFE_INTEGER))
+    throw new Error("ULEB decode error: value exceeds MAX_SAFE_INTEGER");
+  return {
+    value: Number(e),
+    length: r
+  };
 }
 export {
-  t as TypeTagSerializer
+  u as ulebDecode,
+  l as ulebEncode
 };

package/dist/index374.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./index372.cjs"),n=require("./index376.cjs");function c(r){switch(r){case"u8":return e.bcs.u8();case"u16":return e.bcs.u16();case"u32":return e.bcs.u32();case"u64":return e.bcs.u64();case"u128":return e.bcs.u128();case"u256":return e.bcs.u256();case"bool":return e.bcs.bool();case"string":return e.bcs.string();case"id":case"address":return n.Address}const s=r.match(/^(vector|option)<(.+)>$/);if(s){const[u,t]=s.slice(1);return u==="vector"?e.bcs.vector(c(t)):e.bcs.option(c(t))}throw new Error(`Invalid Pure type name: ${r}`)}exports.pureBcsSchemaFromTypeName=c;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const h=require("./index373.cjs"),o=require("./index342.cjs");class a{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))}ensureSizeOrGrow(t){const i=this.bytePosition+t;if(i>this.size){const e=Math.min(this.maxSize,Math.max(this.size+i,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(t){return this.bytePosition+=t,this}write8(t){return this.ensureSizeOrGrow(1),this.dataView.setUint8(this.bytePosition,Number(t)),this.shift(1)}writeBytes(t){this.ensureSizeOrGrow(t.length);for(let i=0;i<t.length;i++)this.dataView.setUint8(this.bytePosition+i,t[i]);return this.shift(t.length)}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(i=>this.write8(i)),this}write128(t){return n(BigInt(t),16).forEach(i=>this.write8(i)),this}write256(t){return n(BigInt(t),32).forEach(i=>this.write8(i)),this}writeULEB(t){return h.ulebEncode(t).forEach(i=>this.write8(i)),this}writeVec(t,i){return this.writeULEB(t.length),Array.from(t).forEach((e,s)=>i(this,e,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 i=new Uint8Array(t);let e=0;for(;r>0;)i[e]=Number(r%BigInt(256)),r=r/BigInt(256),e+=1;return i}exports.BcsWriter=a;