@gardenfi/swap 0.1.3-beta.12 → 0.1.3-beta.13

package/dist/index373.js

@@ -1,12 +1,357 @@
-import { normalizeSuiObjectId as S } from "./index118.js";
-BigInt(1e9);
-const x = "0x1", o = "0x2";
-S("0x6");
-const I = `${o}::sui::SUI`;
-S("0x5");
-S("0x8");
+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 "./index327.js";
+import { ulebEncode as y } from "./index371.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"
+    });
+  },
+  /**
+   * 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
+   *
+   */
+  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}`);
+      }
+    });
+  },
+  /**
+   * Creates a BcsType representing a variable length byte array
+   *
+   * @example
+   * bcs.byteVector().serialize([1, 2, 3]).toBytes() // Uint8Array [3, 1, 2, 3]
+   */
+  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}`);
+      }
+    });
+  },
+  /**
+   * Creates a BcsType that can ser/de string values.  Strings will be UTF-8 encoded
+   * @example
+   * bcs.string().serialize('a').toBytes() // Uint8Array [ 1, 97 ]
+   */
+  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"
+    });
+  },
+  /**
+   * 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 ]
+   */
+  fixedArray: $,
+  /**
+   * 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 ]
+   */
+  option: b,
+  /**
+   * 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 ]
+   */
+  vector: T,
+  /**
+   * 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 ]
+   */
+  tuple(e, r) {
+    return new E({
+      fields: e,
+      ...r
+    });
+  },
+  /**
+   * 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 ]
+   */
+  struct(e, r, a) {
+    return new g({
+      name: e,
+      fields: r,
+      ...a
+    });
+  },
+  /**
+   * 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 ]
+   */
+  enum(e, r, a) {
+    return new h({
+      name: e,
+      fields: r,
+      ...a
+    });
+  },
+  /**
+   * 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 ]
+   */
+  map: M,
+  /**
+   * 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
+   */
+  lazy(e) {
+    return l(e);
+  }
+};
 export {
-  x as MOVE_STDLIB_ADDRESS,
-  o as SUI_FRAMEWORK_ADDRESS,
-  I as SUI_TYPE_ARG
+  c as bcs
 };

package/dist/index374.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./index321.cjs"),o=require("./index118.cjs"),u=require("./index373.cjs"),a="object",d="ID",i="ascii",f="String",T="string",l="String",b="option",_="Option";function m(e){const t=typeof e.body=="object"&&"datatype"in e.body?e.body.datatype:null;return!!t&&o.normalizeSuiAddress(t.package)===o.normalizeSuiAddress("0x2")&&t.module==="tx_context"&&t.type==="TxContext"}function c(e){if(typeof e=="string")switch(e){case"address":return r.bcs.Address;case"bool":return r.bcs.Bool;case"u8":return r.bcs.U8;case"u16":return r.bcs.U16;case"u32":return r.bcs.U32;case"u64":return r.bcs.U64;case"u128":return r.bcs.U128;case"u256":return r.bcs.U256;default:throw new Error(`Unknown type signature ${e}`)}if("vector"in e){if(e.vector==="u8")return r.bcs.byteVector().transform({input:n=>typeof n=="string"?new TextEncoder().encode(n):n,output:n=>n});const t=c(e.vector);return t?r.bcs.vector(t):null}if("datatype"in e){const t=o.normalizeSuiAddress(e.datatype.package);if(t===o.normalizeSuiAddress(u.MOVE_STDLIB_ADDRESS)){if(e.datatype.module===i&&e.datatype.type===f||e.datatype.module===T&&e.datatype.type===l)return r.bcs.String;if(e.datatype.module===b&&e.datatype.type===_){const n=c(e.datatype.typeParameters[0]);return n?r.bcs.vector(n):null}}if(t===o.normalizeSuiAddress(u.SUI_FRAMEWORK_ADDRESS)&&e.datatype.module===a&&e.datatype.type===d)return r.bcs.Address}return null}function U(e){return typeof e=="object"&&"Reference"in e?{ref:"&",body:s(e.Reference)}:typeof e=="object"&&"MutableReference"in e?{ref:"&mut",body:s(e.MutableReference)}:{ref:null,body:s(e)}}function s(e){if(typeof e=="string")switch(e){case"Address":return"address";case"Bool":return"bool";case"U8":return"u8";case"U16":return"u16";case"U32":return"u32";case"U64":return"u64";case"U128":return"u128";case"U256":return"u256";default:throw new Error(`Unexpected type ${e}`)}if("Vector"in e)return{vector:s(e.Vector)};if("Struct"in e)return{datatype:{package:e.Struct.address,module:e.Struct.module,type:e.Struct.name,typeParameters:e.Struct.typeArguments.map(s)}};if("TypeParameter"in e)return{typeParameter:e.TypeParameter};throw new Error(`Unexpected type ${JSON.stringify(e)}`)}exports.getPureBcsSchema=c;exports.isTxContext=m;exports.normalizedTypeToMoveTypeSignature=U;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const u=require("./index261.cjs"),r=require("./index262.cjs"),i=require("./index263.cjs"),t=require("./index373.cjs"),o=require("./index265.cjs"),m=require("./index379.cjs");function x(e){return t.bcs.u64({name:"unsafe_u64",...e}).transform({input:c=>c,output:c=>Number(c)})}function z(e){return t.bcs.enum("Option",{None:null,Some:e})}const s=t.bcs.bytes(o.SUI_ADDRESS_LENGTH).transform({validate:e=>{const c=typeof e=="string"?e:i.toHex(e);if(!c||!o.isValidSuiAddress(o.normalizeSuiAddress(c)))throw new Error(`Invalid Sui address ${c}`)},input:e=>typeof e=="string"?i.fromHex(o.normalizeSuiAddress(e)):e,output:e=>o.normalizeSuiAddress(i.toHex(e))}),g=t.bcs.byteVector().transform({name:"ObjectDigest",input:e=>u.fromBase58(e),output:e=>u.toBase58(new Uint8Array(e)),validate:e=>{if(u.fromBase58(e).length!==32)throw new Error("ObjectDigest must be 32 bytes")}}),a=t.bcs.struct("SuiObjectRef",{objectId:s,version:t.bcs.u64(),digest:g}),d=t.bcs.struct("SharedObjectRef",{objectId:s,initialSharedVersion:t.bcs.u64(),mutable:t.bcs.bool()}),p=t.bcs.enum("ObjectArg",{ImmOrOwnedObject:a,SharedObject:d,Receiving:a}),U=t.bcs.enum("Owner",{AddressOwner:s,ObjectOwner:s,Shared:t.bcs.struct("Shared",{initialSharedVersion:t.bcs.u64()}),Immutable:null,ConsensusAddressOwner:t.bcs.struct("ConsensusAddressOwner",{owner:s,startVersion:t.bcs.u64()})}),S=t.bcs.enum("CallArg",{Pure:t.bcs.struct("Pure",{bytes:t.bcs.byteVector().transform({input:e=>typeof e=="string"?r.fromBase64(e):e,output:e=>r.toBase64(new Uint8Array(e))})}),Object:p}),b=t.bcs.enum("TypeTag",{bool:null,u8:null,u64:null,u128:null,address:null,signer:null,vector:t.bcs.lazy(()=>b),struct:t.bcs.lazy(()=>M),u16:null,u32:null,u256:null}),l=b.transform({input:e=>typeof e=="string"?m.TypeTagSerializer.parseFromStr(e,!0):e,output:e=>m.TypeTagSerializer.tagToString(e)}),n=t.bcs.enum("Argument",{GasCoin:null,Input:t.bcs.u16(),Result:t.bcs.u16(),NestedResult:t.bcs.tuple([t.bcs.u16(),t.bcs.u16()])}),y=t.bcs.struct("ProgrammableMoveCall",{package:s,module:t.bcs.string(),function:t.bcs.string(),typeArguments:t.bcs.vector(l),arguments:t.bcs.vector(n)}),f=t.bcs.enum("Command",{MoveCall:y,TransferObjects:t.bcs.struct("TransferObjects",{objects:t.bcs.vector(n),address:n}),SplitCoins:t.bcs.struct("SplitCoins",{coin:n,amounts:t.bcs.vector(n)}),MergeCoins:t.bcs.struct("MergeCoins",{destination:n,sources:t.bcs.vector(n)}),Publish:t.bcs.struct("Publish",{modules:t.bcs.vector(t.bcs.byteVector().transform({input:e=>typeof e=="string"?r.fromBase64(e):e,output:e=>r.toBase64(new Uint8Array(e))})),dependencies:t.bcs.vector(s)}),MakeMoveVec:t.bcs.struct("MakeMoveVec",{type:z(l).transform({input:e=>e===null?{None:!0}:{Some:e},output:e=>e.Some??null}),elements:t.bcs.vector(n)}),Upgrade:t.bcs.struct("Upgrade",{modules:t.bcs.vector(t.bcs.byteVector().transform({input:e=>typeof e=="string"?r.fromBase64(e):e,output:e=>r.toBase64(new Uint8Array(e))})),dependencies:t.bcs.vector(s),package:s,ticket:n})}),T=t.bcs.struct("ProgrammableTransaction",{inputs:t.bcs.vector(S),commands:t.bcs.vector(f)}),A=t.bcs.enum("TransactionKind",{ProgrammableTransaction:T,ChangeEpoch:null,Genesis:null,ConsensusCommitPrologue:null}),O=t.bcs.enum("TransactionExpiration",{None:null,Epoch:x()}),M=t.bcs.struct("StructTag",{address:s,module:t.bcs.string(),name:t.bcs.string(),typeParams:t.bcs.vector(b)}),P=t.bcs.struct("GasData",{payment:t.bcs.vector(a),owner:s,price:t.bcs.u64(),budget:t.bcs.u64()}),h=t.bcs.struct("TransactionDataV1",{kind:A,sender:s,gasData:P,expiration:O}),C=t.bcs.enum("TransactionData",{V1:h}),D=t.bcs.enum("IntentScope",{TransactionData:null,TransactionEffects:null,CheckpointSummary:null,PersonalMessage:null}),I=t.bcs.enum("IntentVersion",{V0:null}),V=t.bcs.enum("AppId",{Sui:null}),j=t.bcs.struct("Intent",{scope:D,version:I,appId:V});function k(e){return t.bcs.struct(`IntentMessage<${e.name}>`,{intent:j,value:e})}const v=t.bcs.enum("CompressedSignature",{ED25519:t.bcs.bytes(64),Secp256k1:t.bcs.bytes(64),Secp256r1:t.bcs.bytes(64),ZkLogin:t.bcs.byteVector(),Passkey:t.bcs.byteVector()}),w=t.bcs.enum("PublicKey",{ED25519:t.bcs.bytes(32),Secp256k1:t.bcs.bytes(33),Secp256r1:t.bcs.bytes(33),ZkLogin:t.bcs.byteVector(),Passkey:t.bcs.bytes(33)}),E=t.bcs.struct("MultiSigPkMap",{pubKey:w,weight:t.bcs.u8()}),B=t.bcs.struct("MultiSigPublicKey",{pk_map:t.bcs.vector(E),threshold:t.bcs.u16()}),q=t.bcs.struct("MultiSig",{sigs:t.bcs.vector(v),bitmap:t.bcs.u16(),multisig_pk:B}),K=t.bcs.byteVector().transform({input:e=>typeof e=="string"?r.fromBase64(e):e,output:e=>r.toBase64(new Uint8Array(e))}),R=t.bcs.struct("SenderSignedTransaction",{intentMessage:k(C),txSignatures:t.bcs.vector(K)}),G=t.bcs.vector(R,{name:"SenderSignedData"}),N=t.bcs.struct("PasskeyAuthenticator",{authenticatorData:t.bcs.byteVector(),clientDataJson:t.bcs.string(),userSignature:t.bcs.byteVector()});exports.Address=s;exports.AppId=V;exports.Argument=n;exports.CallArg=S;exports.Command=f;exports.CompressedSignature=v;exports.GasData=P;exports.Intent=j;exports.IntentMessage=k;exports.IntentScope=D;exports.IntentVersion=I;exports.MultiSig=q;exports.MultiSigPkMap=E;exports.MultiSigPublicKey=B;exports.ObjectArg=p;exports.ObjectDigest=g;exports.Owner=U;exports.PasskeyAuthenticator=N;exports.ProgrammableMoveCall=y;exports.ProgrammableTransaction=T;exports.PublicKey=w;exports.SenderSignedData=G;exports.SenderSignedTransaction=R;exports.SharedObjectRef=d;exports.StructTag=M;exports.SuiObjectRef=a;exports.TransactionData=C;exports.TransactionDataV1=h;exports.TransactionExpiration=O;exports.TransactionKind=A;exports.TypeTag=l;exports.base64String=K;