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

package/dist/index373.js

@@ -1,12 +1,357 @@
-import { toHex as n } from "./index117.js";
-import { blake2b as c } from "./index385.js";
-import { bcs as t } from "./index317.js";
-function m(r, a, s) {
-  const i = t.Address.serialize(r).toBytes(), o = t.TypeTag.serialize(a).toBytes(), d = t.u64().serialize(s.length).toBytes(), e = c.create({
-    dkLen: 32
+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}`);
+    }
   });
-  return e.update(new Uint8Array([240])), e.update(i), e.update(d), e.update(s), e.update(o), `0x${n(e.digest().slice(0, 32))}`;
 }
+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 {
-  m as deriveDynamicFieldID
+  c as bcs
 };

package/dist/index374.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function t(e){return`[${e.slice(2)}]`}exports.encodeLabelhash=t;
+"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;

package/dist/index374.js

@@ -1,6 +1,278 @@
-function n(e) {
-  return `[${e.slice(2)}]`;
+import { toBase58 as g, fromBase58 as l } from "./index261.js";
+import { toBase64 as o, fromBase64 as u } from "./index262.js";
+import { fromHex as b, toHex as m } from "./index263.js";
+import { bcs as t } from "./index373.js";
+import { SUI_ADDRESS_LENGTH as S, normalizeSuiAddress as a, isValidSuiAddress as y } from "./index265.js";
+import { TypeTagSerializer as p } from "./index379.js";
+function f(e) {
+  return t.u64({
+    name: "unsafe_u64",
+    ...e
+  }).transform({
+    input: (s) => s,
+    output: (s) => Number(s)
+  });
 }
+function T(e) {
+  return t.enum("Option", {
+    None: null,
+    Some: e
+  });
+}
+const n = t.bytes(S).transform({
+  validate: (e) => {
+    const s = typeof e == "string" ? e : m(e);
+    if (!s || !y(a(s)))
+      throw new Error(`Invalid Sui address ${s}`);
+  },
+  input: (e) => typeof e == "string" ? b(a(e)) : e,
+  output: (e) => a(m(e))
+}), O = t.byteVector().transform({
+  name: "ObjectDigest",
+  input: (e) => l(e),
+  output: (e) => g(new Uint8Array(e)),
+  validate: (e) => {
+    if (l(e).length !== 32)
+      throw new Error("ObjectDigest must be 32 bytes");
+  }
+}), c = t.struct("SuiObjectRef", {
+  objectId: n,
+  version: t.u64(),
+  digest: O
+}), A = t.struct("SharedObjectRef", {
+  objectId: n,
+  initialSharedVersion: t.u64(),
+  mutable: t.bool()
+}), h = t.enum("ObjectArg", {
+  ImmOrOwnedObject: c,
+  SharedObject: A,
+  Receiving: c
+}), Q = t.enum("Owner", {
+  AddressOwner: n,
+  ObjectOwner: n,
+  Shared: t.struct("Shared", {
+    initialSharedVersion: t.u64()
+  }),
+  Immutable: null,
+  ConsensusAddressOwner: t.struct("ConsensusAddressOwner", {
+    owner: n,
+    startVersion: t.u64()
+  })
+}), V = t.enum("CallArg", {
+  Pure: t.struct("Pure", {
+    bytes: t.byteVector().transform({
+      input: (e) => typeof e == "string" ? u(e) : e,
+      output: (e) => o(new Uint8Array(e))
+    })
+  }),
+  Object: h
+}), i = t.enum("TypeTag", {
+  bool: null,
+  u8: null,
+  u64: null,
+  u128: null,
+  address: null,
+  signer: null,
+  vector: t.lazy(() => i),
+  struct: t.lazy(() => D),
+  u16: null,
+  u32: null,
+  u256: null
+}), d = i.transform({
+  input: (e) => typeof e == "string" ? p.parseFromStr(e, !0) : e,
+  output: (e) => p.tagToString(e)
+}), r = t.enum("Argument", {
+  GasCoin: null,
+  Input: t.u16(),
+  Result: t.u16(),
+  NestedResult: t.tuple([t.u16(), t.u16()])
+}), M = t.struct("ProgrammableMoveCall", {
+  package: n,
+  module: t.string(),
+  function: t.string(),
+  typeArguments: t.vector(d),
+  arguments: t.vector(r)
+}), P = t.enum("Command", {
+  /**
+   * A Move Call - any public Move function can be called via
+   * this transaction. The results can be used that instant to pass
+   * into the next transaction.
+   */
+  MoveCall: M,
+  /**
+   * Transfer vector of objects to a receiver.
+   */
+  TransferObjects: t.struct("TransferObjects", {
+    objects: t.vector(r),
+    address: r
+  }),
+  // /**
+  //  * Split `amount` from a `coin`.
+  //  */
+  SplitCoins: t.struct("SplitCoins", {
+    coin: r,
+    amounts: t.vector(r)
+  }),
+  // /**
+  //  * Merge Vector of Coins (`sources`) into a `destination`.
+  //  */
+  MergeCoins: t.struct("MergeCoins", {
+    destination: r,
+    sources: t.vector(r)
+  }),
+  // /**
+  //  * Publish a Move module.
+  //  */
+  Publish: t.struct("Publish", {
+    modules: t.vector(
+      t.byteVector().transform({
+        input: (e) => typeof e == "string" ? u(e) : e,
+        output: (e) => o(new Uint8Array(e))
+      })
+    ),
+    dependencies: t.vector(n)
+  }),
+  // /**
+  //  * Build a vector of objects using the input arguments.
+  //  * It is impossible to export construct a `vector<T: key>` otherwise,
+  //  * so this call serves a utility function.
+  //  */
+  MakeMoveVec: t.struct("MakeMoveVec", {
+    type: T(d).transform({
+      input: (e) => e === null ? {
+        None: !0
+      } : {
+        Some: e
+      },
+      output: (e) => e.Some ?? null
+    }),
+    elements: t.vector(r)
+  }),
+  Upgrade: t.struct("Upgrade", {
+    modules: t.vector(
+      t.byteVector().transform({
+        input: (e) => typeof e == "string" ? u(e) : e,
+        output: (e) => o(new Uint8Array(e))
+      })
+    ),
+    dependencies: t.vector(n),
+    package: n,
+    ticket: r
+  })
+}), C = t.struct("ProgrammableTransaction", {
+  inputs: t.vector(V),
+  commands: t.vector(P)
+}), k = t.enum("TransactionKind", {
+  ProgrammableTransaction: C,
+  ChangeEpoch: null,
+  Genesis: null,
+  ConsensusCommitPrologue: null
+}), w = t.enum("TransactionExpiration", {
+  None: null,
+  Epoch: f()
+}), D = t.struct("StructTag", {
+  address: n,
+  module: t.string(),
+  name: t.string(),
+  typeParams: t.vector(i)
+}), I = t.struct("GasData", {
+  payment: t.vector(c),
+  owner: n,
+  price: t.u64(),
+  budget: t.u64()
+}), j = t.struct("TransactionDataV1", {
+  kind: k,
+  sender: n,
+  gasData: I,
+  expiration: w
+}), v = t.enum("TransactionData", {
+  V1: j
+}), E = t.enum("IntentScope", {
+  TransactionData: null,
+  TransactionEffects: null,
+  CheckpointSummary: null,
+  PersonalMessage: null
+}), R = t.enum("IntentVersion", {
+  V0: null
+}), U = t.enum("AppId", {
+  Sui: null
+}), x = t.struct("Intent", {
+  scope: E,
+  version: R,
+  appId: U
+});
+function K(e) {
+  return t.struct(`IntentMessage<${e.name}>`, {
+    intent: x,
+    value: e
+  });
+}
+const N = t.enum("CompressedSignature", {
+  ED25519: t.bytes(64),
+  Secp256k1: t.bytes(64),
+  Secp256r1: t.bytes(64),
+  ZkLogin: t.byteVector(),
+  Passkey: t.byteVector()
+}), _ = t.enum("PublicKey", {
+  ED25519: t.bytes(32),
+  Secp256k1: t.bytes(33),
+  Secp256r1: t.bytes(33),
+  ZkLogin: t.byteVector(),
+  Passkey: t.bytes(33)
+}), G = t.struct("MultiSigPkMap", {
+  pubKey: _,
+  weight: t.u8()
+}), z = t.struct("MultiSigPublicKey", {
+  pk_map: t.vector(G),
+  threshold: t.u16()
+}), W = t.struct("MultiSig", {
+  sigs: t.vector(N),
+  bitmap: t.u16(),
+  multisig_pk: z
+}), B = t.byteVector().transform({
+  input: (e) => typeof e == "string" ? u(e) : e,
+  output: (e) => o(new Uint8Array(e))
+}), H = t.struct("SenderSignedTransaction", {
+  intentMessage: K(v),
+  txSignatures: t.vector(B)
+}), X = t.vector(H, {
+  name: "SenderSignedData"
+}), Y = t.struct("PasskeyAuthenticator", {
+  authenticatorData: t.byteVector(),
+  clientDataJson: t.string(),
+  userSignature: t.byteVector()
+});
 export {
-  n as encodeLabelhash
+  n as Address,
+  U as AppId,
+  r as Argument,
+  V as CallArg,
+  P as Command,
+  N as CompressedSignature,
+  I as GasData,
+  x as Intent,
+  K as IntentMessage,
+  E as IntentScope,
+  R as IntentVersion,
+  W as MultiSig,
+  G as MultiSigPkMap,
+  z as MultiSigPublicKey,
+  h as ObjectArg,
+  O as ObjectDigest,
+  Q as Owner,
+  Y as PasskeyAuthenticator,
+  M as ProgrammableMoveCall,
+  C as ProgrammableTransaction,
+  _ as PublicKey,
+  X as SenderSignedData,
+  H as SenderSignedTransaction,
+  A as SharedObjectRef,
+  D as StructTag,
+  c as SuiObjectRef,
+  v as TransactionData,
+  j as TransactionDataV1,
+  w as TransactionExpiration,
+  k as TransactionKind,
+  d as TypeTag,
+  B as base64String
 };