wowok 1.8.2 → 2.1.9

package/dist/cjs/multisig/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var multisig_exports = {};
+__export(multisig_exports, {
+  MultiSigPublicKey: () => import_publickey.MultiSigPublicKey,
+  MultiSigSigner: () => import_signer.MultiSigSigner,
+  parsePartialSignatures: () => import_publickey.parsePartialSignatures
+});
+module.exports = __toCommonJS(multisig_exports);
+var import_signer = require("./signer.js");
+var import_publickey = require("./publickey.js");

package/dist/cjs/multisig/publickey.d.ts

@@ -0,0 +1,79 @@
+import { bcs } from "../bcs/index.js";
+import type { Signer } from "../cryptography/keypair.js";
+import { PublicKey } from "../cryptography/publickey.js";
+import type { SignatureScheme } from "../cryptography/signature-scheme.js";
+import { MultiSigSigner } from "./signer.js";
+type ParsedPartialMultiSigSignature = {
+    signatureScheme: SignatureScheme;
+    signature: Uint8Array;
+    publicKey: PublicKey;
+    weight: number;
+};
+export declare const MAX_SIGNER_IN_MULTISIG = 10;
+export declare const MIN_SIGNER_IN_MULTISIG = 1;
+export type MultiSigPublicKeyStruct = ReturnType<typeof bcs.MultiSigPublicKey.parse>;
+export type MultiSigStruct = ReturnType<typeof bcs.MultiSig.parse>;
+export type CompressedSignature = ReturnType<typeof bcs.CompressedSignature.parse>;
+export type PublicKeyEnum = ReturnType<typeof bcs.PublicKey.parse>;
+/**
+ * A MultiSig public key
+ */
+export declare class MultiSigPublicKey extends PublicKey {
+    private rawBytes;
+    private multisigPublicKey;
+    private publicKeys;
+    /**
+     * Create a new MultiSigPublicKey object
+     */
+    constructor(
+    /**
+     *  MultiSig public key as buffer or base-64 encoded string
+     */
+    value: string | Uint8Array | MultiSigPublicKeyStruct);
+    /**
+     * 	A static method to create a new MultiSig publickey instance from a set of public keys and their associated weights pairs and threshold.
+     */
+    static fromPublicKeys({ threshold, publicKeys, }: {
+        threshold: number;
+        publicKeys: {
+            publicKey: PublicKey;
+            weight: number;
+        }[];
+    }): MultiSigPublicKey;
+    /**
+     * Checks if two MultiSig public keys are equal
+     */
+    equals(publicKey: MultiSigPublicKey): boolean;
+    /**
+     * Return the byte array representation of the MultiSig public key
+     */
+    toRawBytes(): Uint8Array<ArrayBuffer>;
+    getPublicKeys(): {
+        weight: number;
+        publicKey: PublicKey;
+    }[];
+    getThreshold(): number;
+    getSigner(...signers: [signer: Signer]): MultiSigSigner;
+    /**
+     * Return the Sui address associated with this MultiSig public key
+     */
+    toWAddress(): string;
+    /**
+     * Return the Sui address associated with this MultiSig public key
+     */
+    flag(): number;
+    /**
+     * Verifies that the signature is valid for for the provided message
+     */
+    verify(message: Uint8Array, multisigSignature: string): Promise<boolean>;
+    /**
+     * Combines multiple partial signatures into a single multisig, ensuring that each public key signs only once
+     * and that all the public keys involved are known and valid, and then serializes multisig into the standard format
+     */
+    combinePartialSignatures(signatures: string[]): string;
+}
+/**
+ * Parse multisig structure into an array of individual signatures: signature scheme, the actual individual signature, public key and its weight.
+ */
+export declare function parsePartialSignatures(multisig: MultiSigStruct): ParsedPartialMultiSigSignature[];
+export {};

package/dist/cjs/multisig/publickey.js

@@ -0,0 +1,296 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var publickey_exports = {};
+__export(publickey_exports, {
+  MAX_SIGNER_IN_MULTISIG: () => MAX_SIGNER_IN_MULTISIG,
+  MIN_SIGNER_IN_MULTISIG: () => MIN_SIGNER_IN_MULTISIG,
+  MultiSigPublicKey: () => MultiSigPublicKey,
+  parsePartialSignatures: () => parsePartialSignatures
+});
+module.exports = __toCommonJS(publickey_exports);
+var import_bcs = require("@mysten/bcs");
+var import_blake2b = require("@noble/hashes/blake2b");
+var import_utils = require("@noble/hashes/utils");
+var import_bcs2 = require("../bcs/index.js");
+var import_publickey = require("../cryptography/publickey.js");
+var import_signature_scheme = require("../cryptography/signature-scheme.js");
+var import_signature = require("../cryptography/signature.js");
+var import_sui_types = require("../utils/sui-types.js");
+var import_verify = require("../verify/index.js");
+var import_signer = require("./signer.js");
+const MAX_SIGNER_IN_MULTISIG = 10;
+const MIN_SIGNER_IN_MULTISIG = 1;
+class MultiSigPublicKey extends import_publickey.PublicKey {
+  /**
+   * Create a new MultiSigPublicKey object
+   */
+  constructor(value) {
+    super();
+    __publicField(this, "rawBytes");
+    __publicField(this, "multisigPublicKey");
+    __publicField(this, "publicKeys");
+    if (typeof value === "string") {
+      this.rawBytes = (0, import_bcs.fromBase64)(value);
+      this.multisigPublicKey = import_bcs2.bcs.MultiSigPublicKey.parse(this.rawBytes);
+    } else if (value instanceof Uint8Array) {
+      this.rawBytes = value;
+      this.multisigPublicKey = import_bcs2.bcs.MultiSigPublicKey.parse(this.rawBytes);
+    } else {
+      this.multisigPublicKey = value;
+      this.rawBytes = import_bcs2.bcs.MultiSigPublicKey.serialize(value).toBytes();
+    }
+    if (this.multisigPublicKey.threshold < 1) {
+      throw new Error("Invalid threshold");
+    }
+    const seenPublicKeys = /* @__PURE__ */ new Set();
+    this.publicKeys = this.multisigPublicKey.pk_map.map(
+      ({ pubKey, weight }) => {
+        const [scheme, bytes] = Object.entries(pubKey).filter(
+          ([name]) => name !== "$kind"
+        )[0];
+        const publicKeyStr = Uint8Array.from(bytes).toString();
+        if (seenPublicKeys.has(publicKeyStr)) {
+          throw new Error(
+            `Multisig does not support duplicate public keys`
+          );
+        }
+        seenPublicKeys.add(publicKeyStr);
+        if (weight < 1) {
+          throw new Error(`Invalid weight`);
+        }
+        return {
+          publicKey: (0, import_verify.publicKeyFromRawBytes)(
+            scheme,
+            Uint8Array.from(bytes)
+          ),
+          weight
+        };
+      }
+    );
+    const totalWeight = this.publicKeys.reduce(
+      (sum, { weight }) => sum + weight,
+      0
+    );
+    if (this.multisigPublicKey.threshold > totalWeight) {
+      throw new Error(`Unreachable threshold`);
+    }
+    if (this.publicKeys.length > MAX_SIGNER_IN_MULTISIG) {
+      throw new Error(
+        `Max number of signers in a multisig is ${MAX_SIGNER_IN_MULTISIG}`
+      );
+    }
+    if (this.publicKeys.length < MIN_SIGNER_IN_MULTISIG) {
+      throw new Error(
+        `Min number of signers in a multisig is ${MIN_SIGNER_IN_MULTISIG}`
+      );
+    }
+  }
+  /**
+   * 	A static method to create a new MultiSig publickey instance from a set of public keys and their associated weights pairs and threshold.
+   */
+  static fromPublicKeys({
+    threshold,
+    publicKeys
+  }) {
+    return new MultiSigPublicKey({
+      pk_map: publicKeys.map(({ publicKey, weight }) => {
+        const scheme = import_signature_scheme.SIGNATURE_FLAG_TO_SCHEME[publicKey.flag()];
+        return {
+          pubKey: {
+            [scheme]: publicKey.toRawBytes()
+          },
+          weight
+        };
+      }),
+      threshold
+    });
+  }
+  /**
+   * Checks if two MultiSig public keys are equal
+   */
+  equals(publicKey) {
+    return super.equals(publicKey);
+  }
+  /**
+   * Return the byte array representation of the MultiSig public key
+   */
+  toRawBytes() {
+    return this.rawBytes;
+  }
+  getPublicKeys() {
+    return this.publicKeys;
+  }
+  getThreshold() {
+    return this.multisigPublicKey.threshold;
+  }
+  getSigner(...signers) {
+    return new import_signer.MultiSigSigner(this, signers);
+  }
+  /**
+   * Return the Sui address associated with this MultiSig public key
+   */
+  toWAddress() {
+    const maxLength = 1 + (64 + 1) * MAX_SIGNER_IN_MULTISIG + 2;
+    const tmp = new Uint8Array(maxLength);
+    tmp.set([import_signature_scheme.SIGNATURE_SCHEME_TO_FLAG["MultiSig"]]);
+    tmp.set(
+      import_bcs2.bcs.u16().serialize(this.multisigPublicKey.threshold).toBytes(),
+      1
+    );
+    let i = 3;
+    for (const { publicKey, weight } of this.publicKeys) {
+      const bytes = publicKey.toWBytes();
+      tmp.set(bytes, i);
+      i += bytes.length;
+      tmp.set([weight], i++);
+    }
+    return (0, import_sui_types.normalizeWowAddress)(
+      (0, import_utils.bytesToHex)((0, import_blake2b.blake2b)(tmp.slice(0, i), { dkLen: 32 }))
+    );
+  }
+  /**
+   * Return the Sui address associated with this MultiSig public key
+   */
+  flag() {
+    return import_signature_scheme.SIGNATURE_SCHEME_TO_FLAG["MultiSig"];
+  }
+  /**
+   * Verifies that the signature is valid for for the provided message
+   */
+  async verify(message, multisigSignature) {
+    const parsed = (0, import_signature.parseSerializedSignature)(multisigSignature);
+    if (parsed.signatureScheme !== "MultiSig") {
+      throw new Error("Invalid signature scheme");
+    }
+    const { multisig } = parsed;
+    let signatureWeight = 0;
+    if (!(0, import_publickey.bytesEqual)(
+      import_bcs2.bcs.MultiSigPublicKey.serialize(
+        this.multisigPublicKey
+      ).toBytes(),
+      import_bcs2.bcs.MultiSigPublicKey.serialize(multisig.multisig_pk).toBytes()
+    )) {
+      return false;
+    }
+    for (const { publicKey, weight, signature } of parsePartialSignatures(
+      multisig
+    )) {
+      if (!await publicKey.verify(message, signature)) {
+        return false;
+      }
+      signatureWeight += weight;
+    }
+    return signatureWeight >= this.multisigPublicKey.threshold;
+  }
+  /**
+   * Combines multiple partial signatures into a single multisig, ensuring that each public key signs only once
+   * and that all the public keys involved are known and valid, and then serializes multisig into the standard format
+   */
+  combinePartialSignatures(signatures) {
+    if (signatures.length > MAX_SIGNER_IN_MULTISIG) {
+      throw new Error(
+        `Max number of signatures in a multisig is ${MAX_SIGNER_IN_MULTISIG}`
+      );
+    }
+    let bitmap = 0;
+    const compressedSignatures = new Array(
+      signatures.length
+    );
+    for (let i = 0; i < signatures.length; i++) {
+      const parsed = (0, import_signature.parseSerializedSignature)(signatures[i]);
+      if (parsed.signatureScheme === "MultiSig") {
+        throw new Error("MultiSig is not supported inside MultiSig");
+      }
+      const publicKey = parsed.publicKey;
+      compressedSignatures[i] = {
+        [parsed.signatureScheme]: parsed.signature
+      };
+      let publicKeyIndex;
+      for (let j = 0; j < this.publicKeys.length; j++) {
+        if ((0, import_publickey.bytesEqual)(
+          publicKey,
+          this.publicKeys[j].publicKey.toRawBytes()
+        )) {
+          if (bitmap & 1 << j) {
+            throw new Error(
+              "Received multiple signatures from the same public key"
+            );
+          }
+          publicKeyIndex = j;
+          break;
+        }
+      }
+      if (publicKeyIndex === void 0) {
+        throw new Error("Received signature from unknown public key");
+      }
+      bitmap |= 1 << publicKeyIndex;
+    }
+    const multisig = {
+      sigs: compressedSignatures,
+      bitmap,
+      multisig_pk: this.multisigPublicKey
+    };
+    const bytes = import_bcs2.bcs.MultiSig.serialize(multisig, {
+      maxSize: 8192
+    }).toBytes();
+    const tmp = new Uint8Array(bytes.length + 1);
+    tmp.set([import_signature_scheme.SIGNATURE_SCHEME_TO_FLAG["MultiSig"]]);
+    tmp.set(bytes, 1);
+    return (0, import_bcs.toBase64)(tmp);
+  }
+}
+function parsePartialSignatures(multisig) {
+  const res = new Array(
+    multisig.sigs.length
+  );
+  for (let i = 0; i < multisig.sigs.length; i++) {
+    const [signatureScheme, signature] = Object.entries(
+      multisig.sigs[i]
+    ).filter(([name]) => name !== "$kind")[0];
+    const indices = asIndices(multisig.bitmap);
+    const pkIndex = indices[i];
+    const pair = multisig.multisig_pk.pk_map[pkIndex];
+    const pkBytes = Uint8Array.from(Object.values(pair.pubKey)[0]);
+    if (signatureScheme === "MultiSig") {
+      throw new Error("MultiSig is not supported inside MultiSig");
+    }
+    const publicKey = (0, import_verify.publicKeyFromRawBytes)(signatureScheme, pkBytes);
+    res[i] = {
+      signatureScheme,
+      signature: Uint8Array.from(signature),
+      publicKey,
+      weight: pair.weight
+    };
+  }
+  return res;
+}
+function asIndices(bitmap) {
+  if (bitmap < 0 || bitmap > 1024) {
+    throw new Error("Invalid bitmap");
+  }
+  const res = [];
+  for (let i = 0; i < 10; i++) {
+    if ((bitmap & 1 << i) !== 0) {
+      res.push(i);
+    }
+  }
+  return Uint8Array.from(res);
+}

package/dist/cjs/multisig/signer.d.ts

@@ -0,0 +1,20 @@
+import type { SignatureScheme } from "../cryptography/index.js";
+import { Signer } from "../cryptography/index.js";
+import type { MultiSigPublicKey } from "./publickey.js";
+export declare class MultiSigSigner extends Signer {
+    #private;
+    constructor(pubkey: MultiSigPublicKey, signers?: Signer[]);
+    getKeyScheme(): SignatureScheme;
+    getPublicKey(): MultiSigPublicKey;
+    sign(_data: Uint8Array): never;
+    /** @deprecated use `sign` instead */
+    signData(_data: Uint8Array): never;
+    signTransaction(bytes: Uint8Array): Promise<{
+        signature: string;
+        bytes: string;
+    }>;
+    signPersonalMessage(bytes: Uint8Array): Promise<{
+        signature: string;
+        bytes: string;
+    }>;
+}

package/dist/cjs/multisig/signer.js

@@ -0,0 +1,114 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var signer_exports = {};
+__export(signer_exports, {
+  MultiSigSigner: () => MultiSigSigner
+});
+module.exports = __toCommonJS(signer_exports);
+var import_bcs = require("@mysten/bcs");
+var import_cryptography = require("../cryptography/index.js");
+var _pubkey, _signers;
+class MultiSigSigner extends import_cryptography.Signer {
+  constructor(pubkey, signers = []) {
+    super();
+    __privateAdd(this, _pubkey);
+    __privateAdd(this, _signers);
+    __privateSet(this, _pubkey, pubkey);
+    __privateSet(this, _signers, signers);
+    const uniqueKeys = /* @__PURE__ */ new Set();
+    let combinedWeight = 0;
+    const weights = pubkey.getPublicKeys().map(({ weight, publicKey }) => ({
+      weight,
+      address: publicKey.toWAddress()
+    }));
+    for (const signer of signers) {
+      const address = signer.toWAddress();
+      if (uniqueKeys.has(address)) {
+        throw new Error(
+          `Can't create MultiSigSigner with duplicate signers`
+        );
+      }
+      uniqueKeys.add(address);
+      const weight = weights.find((w) => w.address === address)?.weight;
+      if (!weight) {
+        throw new Error(
+          `Signer ${address} is not part of the MultiSig public key`
+        );
+      }
+      combinedWeight += weight;
+    }
+    if (combinedWeight < pubkey.getThreshold()) {
+      throw new Error(
+        `Combined weight of signers is less than threshold`
+      );
+    }
+  }
+  getKeyScheme() {
+    return "MultiSig";
+  }
+  getPublicKey() {
+    return __privateGet(this, _pubkey);
+  }
+  sign(_data) {
+    throw new Error(
+      "MultiSigSigner does not support signing directly. Use signTransaction or signPersonalMessage instead"
+    );
+  }
+  /** @deprecated use `sign` instead */
+  signData(_data) {
+    throw new Error(
+      "MultiSigSigner does not support signing directly. Use signTransaction or signPersonalMessage instead"
+    );
+  }
+  async signTransaction(bytes) {
+    const signature = __privateGet(this, _pubkey).combinePartialSignatures(
+      await Promise.all(
+        __privateGet(this, _signers).map(
+          async (signer) => (await signer.signTransaction(bytes)).signature
+        )
+      )
+    );
+    return {
+      signature,
+      bytes: (0, import_bcs.toBase64)(bytes)
+    };
+  }
+  async signPersonalMessage(bytes) {
+    const signature = __privateGet(this, _pubkey).combinePartialSignatures(
+      await Promise.all(
+        __privateGet(this, _signers).map(
+          async (signer) => (await signer.signPersonalMessage(bytes)).signature
+        )
+      )
+    );
+    return {
+      signature,
+      bytes: (0, import_bcs.toBase64)(bytes)
+    };
+  }
+}
+_pubkey = new WeakMap();
+_signers = new WeakMap();

package/dist/cjs/package.json

@@ -0,0 +1,5 @@
+{
+  "private": true,
+  "type": "commonjs",
+  "sideEffects": false
+}

package/dist/cjs/transactions/Arguments.d.ts

@@ -0,0 +1,57 @@
+import type { Argument } from "./data/internal.js";
+import type { Inputs } from "./Inputs.js";
+import { createPure } from "./pure.js";
+import type { Transaction, TransactionObjectArgument } from "./Transaction.js";
+export declare const Arguments: {
+    pure: ReturnType<typeof createPure<(tx: Transaction) => Argument>>;
+    object: {
+        (value: import("./Transaction.js").TransactionObjectInput): TransactionObjectArgument;
+        system(options?: {
+            mutable?: boolean;
+        } | undefined): TransactionObjectArgument;
+        clock(): TransactionObjectArgument;
+        random(): TransactionObjectArgument;
+        denyList(options?: {
+            mutable?: boolean;
+        } | undefined): TransactionObjectArgument;
+        registrar(options?: {
+            mutable?: boolean;
+        } | undefined): TransactionObjectArgument;
+        mutRegistrar(): TransactionObjectArgument;
+        entity(options?: {
+            mutable?: boolean;
+        } | undefined): TransactionObjectArgument;
+        mutEntity(): TransactionObjectArgument;
+        option({ type, value, }: {
+            type: string;
+            value: import("./Transaction.js").TransactionObjectInput | null;
+        }): (tx: Transaction) => import("./Transaction.js").TransactionResult;
+    };
+    sharedObjectRef: (args_0: {
+        objectId: string;
+        mutable: boolean;
+        initialSharedVersion: number | string;
+    }) => (tx: Transaction) => {
+        $kind: "Input";
+        Input: number;
+        type?: "object";
+    };
+    objectRef: (args_0: {
+        objectId: string;
+        version: string | number;
+        digest: string;
+    }) => (tx: Transaction) => {
+        $kind: "Input";
+        Input: number;
+        type?: "object";
+    };
+    receivingRef: (args_0: {
+        objectId: string;
+        version: string | number;
+        digest: string;
+    }) => (tx: Transaction) => {
+        $kind: "Input";
+        Input: number;
+        type?: "object";
+    };
+};

package/dist/cjs/transactions/Arguments.js

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Arguments_exports = {};
+__export(Arguments_exports, {
+  Arguments: () => Arguments
+});
+module.exports = __toCommonJS(Arguments_exports);
+var import_object = require("./object.js");
+var import_pure = require("./pure.js");
+const Arguments = {
+  pure: (0, import_pure.createPure)(
+    (value) => (tx) => tx.pure(value)
+  ),
+  object: (0, import_object.createObjectMethods)(
+    (value) => (tx) => tx.object(value)
+  ),
+  sharedObjectRef: (...args) => (tx) => tx.sharedObjectRef(...args),
+  objectRef: (...args) => (tx) => tx.objectRef(...args),
+  receivingRef: (...args) => (tx) => tx.receivingRef(...args)
+};