wowok 1.8.2 → 2.1.9

package/dist/esm/multisig/publickey.js

@@ -0,0 +1,280 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { fromBase64, toBase64 } from "@mysten/bcs";
+import { blake2b } from "@noble/hashes/blake2b";
+import { bytesToHex } from "@noble/hashes/utils";
+import { bcs } from "../bcs/index.js";
+import { bytesEqual, PublicKey } from "../cryptography/publickey.js";
+import {
+  SIGNATURE_FLAG_TO_SCHEME,
+  SIGNATURE_SCHEME_TO_FLAG
+} from "../cryptography/signature-scheme.js";
+import { parseSerializedSignature } from "../cryptography/signature.js";
+import { normalizeWowAddress } from "../utils/sui-types.js";
+import { publicKeyFromRawBytes } from "../verify/index.js";
+import { MultiSigSigner } from "./signer.js";
+const MAX_SIGNER_IN_MULTISIG = 10;
+const MIN_SIGNER_IN_MULTISIG = 1;
+class MultiSigPublicKey extends PublicKey {
+  /**
+   * Create a new MultiSigPublicKey object
+   */
+  constructor(value) {
+    super();
+    __publicField(this, "rawBytes");
+    __publicField(this, "multisigPublicKey");
+    __publicField(this, "publicKeys");
+    if (typeof value === "string") {
+      this.rawBytes = fromBase64(value);
+      this.multisigPublicKey = bcs.MultiSigPublicKey.parse(this.rawBytes);
+    } else if (value instanceof Uint8Array) {
+      this.rawBytes = value;
+      this.multisigPublicKey = bcs.MultiSigPublicKey.parse(this.rawBytes);
+    } else {
+      this.multisigPublicKey = value;
+      this.rawBytes = 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: 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 = 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 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([SIGNATURE_SCHEME_TO_FLAG["MultiSig"]]);
+    tmp.set(
+      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 normalizeWowAddress(
+      bytesToHex(blake2b(tmp.slice(0, i), { dkLen: 32 }))
+    );
+  }
+  /**
+   * Return the Sui address associated with this MultiSig public key
+   */
+  flag() {
+    return SIGNATURE_SCHEME_TO_FLAG["MultiSig"];
+  }
+  /**
+   * Verifies that the signature is valid for for the provided message
+   */
+  async verify(message, multisigSignature) {
+    const parsed = parseSerializedSignature(multisigSignature);
+    if (parsed.signatureScheme !== "MultiSig") {
+      throw new Error("Invalid signature scheme");
+    }
+    const { multisig } = parsed;
+    let signatureWeight = 0;
+    if (!bytesEqual(
+      bcs.MultiSigPublicKey.serialize(
+        this.multisigPublicKey
+      ).toBytes(),
+      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 = 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 (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 = bcs.MultiSig.serialize(multisig, {
+      maxSize: 8192
+    }).toBytes();
+    const tmp = new Uint8Array(bytes.length + 1);
+    tmp.set([SIGNATURE_SCHEME_TO_FLAG["MultiSig"]]);
+    tmp.set(bytes, 1);
+    return 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 = 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);
+}
+export {
+  MAX_SIGNER_IN_MULTISIG,
+  MIN_SIGNER_IN_MULTISIG,
+  MultiSigPublicKey,
+  parsePartialSignatures
+};

package/dist/esm/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/esm/multisig/signer.js

@@ -0,0 +1,94 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+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 _pubkey, _signers;
+import { toBase64 } from "@mysten/bcs";
+import { Signer } from "../cryptography/index.js";
+class MultiSigSigner extends 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: 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: toBase64(bytes)
+    };
+  }
+}
+_pubkey = new WeakMap();
+_signers = new WeakMap();
+export {
+  MultiSigSigner
+};

package/dist/esm/package.json

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

package/dist/esm/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/esm/transactions/Arguments.js

@@ -0,0 +1,16 @@
+import { createObjectMethods } from "./object.js";
+import { createPure } from "./pure.js";
+const Arguments = {
+  pure: createPure(
+    (value) => (tx) => tx.pure(value)
+  ),
+  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)
+};
+export {
+  Arguments
+};

package/dist/esm/transactions/Commands.d.ts

@@ -0,0 +1,57 @@
+import type { InferInput } from "valibot";
+import type { Argument, CallArg, Command } from "./data/internal.js";
+import { ArgumentSchema } from "./data/internal.js";
+import type { AsyncTransactionThunk, Transaction } from "./Transaction.js";
+export type TransactionArgument = InferInput<typeof ArgumentSchema> | ((tx: Transaction) => InferInput<typeof ArgumentSchema>) | AsyncTransactionThunk;
+export type TransactionInput = CallArg;
+export declare enum UpgradePolicy {
+    COMPATIBLE = 0,
+    ADDITIVE = 128,
+    DEP_ONLY = 192
+}
+type TransactionShape<T extends Command["$kind"]> = {
+    $kind: T;
+} & {
+    [K in T]: Extract<Command, {
+        [K in T]: any;
+    }>[T];
+};
+/**
+ * Simple helpers used to construct transactions:
+ */
+export declare const Commands: {
+    MoveCall(input: {
+        package: string;
+        module: string;
+        function: string;
+        arguments?: Argument[];
+        typeArguments?: string[];
+    } | {
+        target: string;
+        arguments?: Argument[];
+        typeArguments?: string[];
+    }): TransactionShape<"MoveCall">;
+    TransferObjects(objects: InferInput<typeof ArgumentSchema>[], address: InferInput<typeof ArgumentSchema>): TransactionShape<"TransferObjects">;
+    SplitCoins(coin: InferInput<typeof ArgumentSchema>, amounts: InferInput<typeof ArgumentSchema>[]): TransactionShape<"SplitCoins">;
+    MergeCoins(destination: InferInput<typeof ArgumentSchema>, sources: InferInput<typeof ArgumentSchema>[]): TransactionShape<"MergeCoins">;
+    Publish({ modules, dependencies, }: {
+        modules: number[][] | string[];
+        dependencies: string[];
+    }): TransactionShape<"Publish">;
+    Upgrade({ modules, dependencies, package: packageId, ticket, }: {
+        modules: number[][] | string[];
+        dependencies: string[];
+        package: string;
+        ticket: InferInput<typeof ArgumentSchema>;
+    }): TransactionShape<"Upgrade">;
+    MakeMoveVec({ type, elements, }: {
+        type?: string;
+        elements: InferInput<typeof ArgumentSchema>[];
+    }): TransactionShape<"MakeMoveVec">;
+    Intent({ name, inputs, data, }: {
+        name: string;
+        inputs?: Record<string, InferInput<typeof ArgumentSchema> | InferInput<typeof ArgumentSchema>[]>;
+        data?: Record<string, unknown>;
+    }): TransactionShape<"$Intent">;
+};
+export {};

package/dist/esm/transactions/Commands.js

@@ -0,0 +1,123 @@
+import { toBase64 } from "@mysten/bcs";
+import { parse } from "valibot";
+import { normalizeWowObjectId } from "../utils/sui-types.js";
+import { ArgumentSchema } from "./data/internal.js";
+var UpgradePolicy = /* @__PURE__ */ ((UpgradePolicy2) => {
+  UpgradePolicy2[UpgradePolicy2["COMPATIBLE"] = 0] = "COMPATIBLE";
+  UpgradePolicy2[UpgradePolicy2["ADDITIVE"] = 128] = "ADDITIVE";
+  UpgradePolicy2[UpgradePolicy2["DEP_ONLY"] = 192] = "DEP_ONLY";
+  return UpgradePolicy2;
+})(UpgradePolicy || {});
+const Commands = {
+  MoveCall(input) {
+    const [pkg, mod = "", fn = ""] = "target" in input ? input.target.split("::") : [input.package, input.module, input.function];
+    return {
+      $kind: "MoveCall",
+      MoveCall: {
+        package: pkg,
+        module: mod,
+        function: fn,
+        typeArguments: input.typeArguments ?? [],
+        arguments: input.arguments ?? []
+      }
+    };
+  },
+  TransferObjects(objects, address) {
+    return {
+      $kind: "TransferObjects",
+      TransferObjects: {
+        objects: objects.map((o) => parse(ArgumentSchema, o)),
+        address: parse(ArgumentSchema, address)
+      }
+    };
+  },
+  SplitCoins(coin, amounts) {
+    return {
+      $kind: "SplitCoins",
+      SplitCoins: {
+        coin: parse(ArgumentSchema, coin),
+        amounts: amounts.map((o) => parse(ArgumentSchema, o))
+      }
+    };
+  },
+  MergeCoins(destination, sources) {
+    return {
+      $kind: "MergeCoins",
+      MergeCoins: {
+        destination: parse(ArgumentSchema, destination),
+        sources: sources.map((o) => parse(ArgumentSchema, o))
+      }
+    };
+  },
+  Publish({
+    modules,
+    dependencies
+  }) {
+    return {
+      $kind: "Publish",
+      Publish: {
+        modules: modules.map(
+          (module) => typeof module === "string" ? module : toBase64(new Uint8Array(module))
+        ),
+        dependencies: dependencies.map(
+          (dep) => normalizeWowObjectId(dep)
+        )
+      }
+    };
+  },
+  Upgrade({
+    modules,
+    dependencies,
+    package: packageId,
+    ticket
+  }) {
+    return {
+      $kind: "Upgrade",
+      Upgrade: {
+        modules: modules.map(
+          (module) => typeof module === "string" ? module : toBase64(new Uint8Array(module))
+        ),
+        dependencies: dependencies.map(
+          (dep) => normalizeWowObjectId(dep)
+        ),
+        package: packageId,
+        ticket: parse(ArgumentSchema, ticket)
+      }
+    };
+  },
+  MakeMoveVec({
+    type,
+    elements
+  }) {
+    return {
+      $kind: "MakeMoveVec",
+      MakeMoveVec: {
+        type: type ?? null,
+        elements: elements.map((o) => parse(ArgumentSchema, o))
+      }
+    };
+  },
+  Intent({
+    name,
+    inputs = {},
+    data = {}
+  }) {
+    return {
+      $kind: "$Intent",
+      $Intent: {
+        name,
+        inputs: Object.fromEntries(
+          Object.entries(inputs).map(([key, value]) => [
+            key,
+            Array.isArray(value) ? value.map((o) => parse(ArgumentSchema, o)) : parse(ArgumentSchema, value)
+          ])
+        ),
+        data
+      }
+    };
+  }
+};
+export {
+  Commands,
+  UpgradePolicy
+};

package/dist/esm/transactions/Inputs.d.ts

@@ -0,0 +1,22 @@
+import type { SerializedBcs } from "@mysten/bcs";
+import type { CallArg, ObjectRef } from "./data/internal.js";
+declare function Pure(data: Uint8Array | SerializedBcs<any>): Extract<CallArg, {
+    Pure: unknown;
+}>;
+export declare const Inputs: {
+    Pure: typeof Pure;
+    ObjectRef({ objectId, digest, version, }: ObjectRef): Extract<CallArg, {
+        Object: unknown;
+    }>;
+    SharedObjectRef({ objectId, mutable, initialSharedVersion, }: {
+        objectId: string;
+        mutable: boolean;
+        initialSharedVersion: number | string;
+    }): Extract<CallArg, {
+        Object: unknown;
+    }>;
+    ReceivingRef({ objectId, digest, version, }: ObjectRef): Extract<CallArg, {
+        Object: unknown;
+    }>;
+};
+export {};