@haneullabs/haneul 0.1.0

package/dist/cjs/multisig/publickey.js

@@ -0,0 +1,260 @@
+"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 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("@haneullabs/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_haneul_types = require("../utils/haneul-types.js");
+var import_verify = require("../verify/index.js");
+var import_publickey2 = require("../zklogin/publickey.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, options = {}) {
+    super();
+    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), options),
+        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 Haneul address associated with this MultiSig public key
+   */
+  toHaneulAddress() {
+    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.toHaneulBytes();
+      tmp.set(bytes, i);
+      i += bytes.length;
+      tmp.set([weight], i++);
+    }
+    return (0, import_haneul_types.normalizeHaneulAddress)((0, import_utils.bytesToHex)((0, import_blake2b.blake2b)(tmp.slice(0, i), { dkLen: 32 })));
+  }
+  /**
+   * Return the Haneul 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");
+      }
+      let publicKey;
+      if (parsed.signatureScheme === "ZkLogin") {
+        publicKey = (0, import_publickey2.toZkLoginPublicIdentifier)(
+          parsed.zkLogin?.addressSeed,
+          parsed.zkLogin?.iss
+        ).toRawBytes();
+      } else {
+        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, options = {}) {
+  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 pkIndex = asIndices(multisig.bitmap).at(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, options);
+    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);
+}
+//# sourceMappingURL=publickey.js.map

package/dist/cjs/multisig/publickey.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/multisig/publickey.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromBase64, toBase64 } from '@haneullabs/bcs';\nimport { blake2b } from '@noble/hashes/blake2b';\nimport { bytesToHex } from '@noble/hashes/utils';\n\nimport { bcs } from '../bcs/index.js';\nimport type { Signer } from '../cryptography/keypair.js';\nimport { bytesEqual, PublicKey } from '../cryptography/publickey.js';\nimport {\n\tSIGNATURE_FLAG_TO_SCHEME,\n\tSIGNATURE_SCHEME_TO_FLAG,\n} from '../cryptography/signature-scheme.js';\nimport type { SignatureFlag, SignatureScheme } from '../cryptography/signature-scheme.js';\nimport { parseSerializedSignature } from '../cryptography/signature.js';\nimport { normalizeHaneulAddress } from '../utils/haneul-types.js';\n// eslint-disable-next-line import/no-cycle\nimport { publicKeyFromRawBytes } from '../verify/index.js';\nimport type { ZkLoginCompatibleClient } from '../zklogin/publickey.js';\nimport { toZkLoginPublicIdentifier } from '../zklogin/publickey.js';\nimport { MultiSigSigner } from './signer.js';\n\ntype CompressedSignature =\n\t| { ED25519: Uint8Array }\n\t| { Secp256k1: Uint8Array }\n\t| { Secp256r1: Uint8Array }\n\t| { ZkLogin: Uint8Array }\n\t| { Passkey: Uint8Array };\n\ntype PublicKeyEnum =\n\t| { ED25519: Uint8Array }\n\t| { Secp256k1: Uint8Array }\n\t| { Secp256r1: Uint8Array }\n\t| { ZkLogin: Uint8Array }\n\t| { Passkey: Uint8Array };\n\ntype PubkeyEnumWeightPair = {\n\tpubKey: PublicKeyEnum;\n\tweight: number;\n};\n\ntype MultiSigPublicKeyStruct = {\n\tpk_map: PubkeyEnumWeightPair[];\n\tthreshold: number;\n};\n\nexport type MultiSigStruct = {\n\tsigs: CompressedSignature[];\n\tbitmap: number;\n\tmultisig_pk: MultiSigPublicKeyStruct;\n};\n\ntype ParsedPartialMultiSigSignature = {\n\tsignatureScheme: SignatureScheme;\n\tsignature: Uint8Array;\n\tpublicKey: PublicKey;\n\tweight: number;\n};\n\nexport const MAX_SIGNER_IN_MULTISIG = 10;\nexport const MIN_SIGNER_IN_MULTISIG = 1;\n/**\n * A MultiSig public key\n */\nexport class MultiSigPublicKey extends PublicKey {\n\tprivate rawBytes: Uint8Array<ArrayBuffer>;\n\tprivate multisigPublicKey: MultiSigPublicKeyStruct;\n\tprivate publicKeys: {\n\t\tweight: number;\n\t\tpublicKey: PublicKey;\n\t}[];\n\t/**\n\t * Create a new MultiSigPublicKey object\n\t */\n\tconstructor(\n\t\t/**\n\t\t *  MultiSig public key as buffer or base-64 encoded string\n\t\t */\n\t\tvalue: string | Uint8Array | MultiSigPublicKeyStruct,\n\t\toptions: { client?: ZkLoginCompatibleClient } = {},\n\t) {\n\t\tsuper();\n\n\t\tif (typeof value === 'string') {\n\t\t\tthis.rawBytes = fromBase64(value);\n\n\t\t\tthis.multisigPublicKey = bcs.MultiSigPublicKey.parse(this.rawBytes);\n\t\t} else if (value instanceof Uint8Array) {\n\t\t\tthis.rawBytes = value as Uint8Array<ArrayBuffer>;\n\t\t\tthis.multisigPublicKey = bcs.MultiSigPublicKey.parse(this.rawBytes);\n\t\t} else {\n\t\t\tthis.multisigPublicKey = value;\n\t\t\tthis.rawBytes = bcs.MultiSigPublicKey.serialize(value).toBytes();\n\t\t}\n\t\tif (this.multisigPublicKey.threshold < 1) {\n\t\t\tthrow new Error('Invalid threshold');\n\t\t}\n\n\t\tconst seenPublicKeys = new Set<string>();\n\n\t\tthis.publicKeys = this.multisigPublicKey.pk_map.map(({ pubKey, weight }) => {\n\t\t\tconst [scheme, bytes] = Object.entries(pubKey).filter(([name]) => name !== '$kind')[0] as [\n\t\t\t\tSignatureScheme,\n\t\t\t\tUint8Array,\n\t\t\t];\n\t\t\tconst publicKeyStr = Uint8Array.from(bytes).toString();\n\n\t\t\tif (seenPublicKeys.has(publicKeyStr)) {\n\t\t\t\tthrow new Error(`Multisig does not support duplicate public keys`);\n\t\t\t}\n\t\t\tseenPublicKeys.add(publicKeyStr);\n\n\t\t\tif (weight < 1) {\n\t\t\t\tthrow new Error(`Invalid weight`);\n\t\t\t}\n\n\t\t\treturn {\n\t\t\t\tpublicKey: publicKeyFromRawBytes(scheme, Uint8Array.from(bytes), options),\n\t\t\t\tweight,\n\t\t\t};\n\t\t});\n\n\t\tconst totalWeight = this.publicKeys.reduce((sum, { weight }) => sum + weight, 0);\n\n\t\tif (this.multisigPublicKey.threshold > totalWeight) {\n\t\t\tthrow new Error(`Unreachable threshold`);\n\t\t}\n\n\t\tif (this.publicKeys.length > MAX_SIGNER_IN_MULTISIG) {\n\t\t\tthrow new Error(`Max number of signers in a multisig is ${MAX_SIGNER_IN_MULTISIG}`);\n\t\t}\n\n\t\tif (this.publicKeys.length < MIN_SIGNER_IN_MULTISIG) {\n\t\t\tthrow new Error(`Min number of signers in a multisig is ${MIN_SIGNER_IN_MULTISIG}`);\n\t\t}\n\t}\n\t/**\n\t * \tA static method to create a new MultiSig publickey instance from a set of public keys and their associated weights pairs and threshold.\n\t */\n\n\tstatic fromPublicKeys({\n\t\tthreshold,\n\t\tpublicKeys,\n\t}: {\n\t\tthreshold: number;\n\t\tpublicKeys: { publicKey: PublicKey; weight: number }[];\n\t}) {\n\t\treturn new MultiSigPublicKey({\n\t\t\tpk_map: publicKeys.map(({ publicKey, weight }) => {\n\t\t\t\tconst scheme = SIGNATURE_FLAG_TO_SCHEME[publicKey.flag() as SignatureFlag];\n\n\t\t\t\treturn {\n\t\t\t\t\tpubKey: { [scheme]: publicKey.toRawBytes() } as PublicKeyEnum,\n\t\t\t\t\tweight,\n\t\t\t\t};\n\t\t\t}),\n\t\t\tthreshold,\n\t\t});\n\t}\n\n\t/**\n\t * Checks if two MultiSig public keys are equal\n\t */\n\toverride equals(publicKey: MultiSigPublicKey): boolean {\n\t\treturn super.equals(publicKey);\n\t}\n\n\t/**\n\t * Return the byte array representation of the MultiSig public key\n\t */\n\ttoRawBytes(): Uint8Array<ArrayBuffer> {\n\t\treturn this.rawBytes;\n\t}\n\n\tgetPublicKeys() {\n\t\treturn this.publicKeys;\n\t}\n\n\tgetThreshold() {\n\t\treturn this.multisigPublicKey.threshold;\n\t}\n\n\tgetSigner(...signers: [signer: Signer]) {\n\t\treturn new MultiSigSigner(this, signers);\n\t}\n\n\t/**\n\t * Return the Haneul address associated with this MultiSig public key\n\t */\n\toverride toHaneulAddress(): string {\n\t\t// max length = 1 flag byte + (max pk size + max weight size (u8)) * max signer size + 2 threshold bytes (u16)\n\t\tconst maxLength = 1 + (64 + 1) * MAX_SIGNER_IN_MULTISIG + 2;\n\t\tconst tmp = new Uint8Array(maxLength);\n\t\ttmp.set([SIGNATURE_SCHEME_TO_FLAG['MultiSig']]);\n\n\t\ttmp.set(bcs.u16().serialize(this.multisigPublicKey.threshold).toBytes(), 1);\n\t\t// The initial value 3 ensures that following data will be after the flag byte and threshold bytes\n\t\tlet i = 3;\n\t\tfor (const { publicKey, weight } of this.publicKeys) {\n\t\t\tconst bytes = publicKey.toHaneulBytes();\n\t\t\ttmp.set(bytes, i);\n\t\t\ti += bytes.length;\n\t\t\ttmp.set([weight], i++);\n\t\t}\n\t\treturn normalizeHaneulAddress(bytesToHex(blake2b(tmp.slice(0, i), { dkLen: 32 })));\n\t}\n\n\t/**\n\t * Return the Haneul address associated with this MultiSig public key\n\t */\n\tflag(): number {\n\t\treturn SIGNATURE_SCHEME_TO_FLAG['MultiSig'];\n\t}\n\n\t/**\n\t * Verifies that the signature is valid for for the provided message\n\t */\n\tasync verify(message: Uint8Array, multisigSignature: string): Promise<boolean> {\n\t\t// Multisig verification only supports serialized signature\n\t\tconst parsed = parseSerializedSignature(multisigSignature);\n\n\t\tif (parsed.signatureScheme !== 'MultiSig') {\n\t\t\tthrow new Error('Invalid signature scheme');\n\t\t}\n\n\t\tconst { multisig } = parsed;\n\n\t\tlet signatureWeight = 0;\n\n\t\tif (\n\t\t\t!bytesEqual(\n\t\t\t\tbcs.MultiSigPublicKey.serialize(this.multisigPublicKey).toBytes(),\n\t\t\t\tbcs.MultiSigPublicKey.serialize(multisig.multisig_pk).toBytes(),\n\t\t\t)\n\t\t) {\n\t\t\treturn false;\n\t\t}\n\n\t\tfor (const { publicKey, weight, signature } of parsePartialSignatures(multisig)) {\n\t\t\tif (!(await publicKey.verify(message, signature))) {\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\tsignatureWeight += weight;\n\t\t}\n\n\t\treturn signatureWeight >= this.multisigPublicKey.threshold;\n\t}\n\n\t/**\n\t * Combines multiple partial signatures into a single multisig, ensuring that each public key signs only once\n\t * and that all the public keys involved are known and valid, and then serializes multisig into the standard format\n\t */\n\tcombinePartialSignatures(signatures: string[]): string {\n\t\tif (signatures.length > MAX_SIGNER_IN_MULTISIG) {\n\t\t\tthrow new Error(`Max number of signatures in a multisig is ${MAX_SIGNER_IN_MULTISIG}`);\n\t\t}\n\n\t\tlet bitmap = 0;\n\t\tconst compressedSignatures: CompressedSignature[] = new Array(signatures.length);\n\n\t\tfor (let i = 0; i < signatures.length; i++) {\n\t\t\tconst parsed = parseSerializedSignature(signatures[i]);\n\t\t\tif (parsed.signatureScheme === 'MultiSig') {\n\t\t\t\tthrow new Error('MultiSig is not supported inside MultiSig');\n\t\t\t}\n\n\t\t\tlet publicKey;\n\t\t\tif (parsed.signatureScheme === 'ZkLogin') {\n\t\t\t\tpublicKey = toZkLoginPublicIdentifier(\n\t\t\t\t\tparsed.zkLogin?.addressSeed,\n\t\t\t\t\tparsed.zkLogin?.iss,\n\t\t\t\t).toRawBytes();\n\t\t\t} else {\n\t\t\t\tpublicKey = parsed.publicKey;\n\t\t\t}\n\n\t\t\tcompressedSignatures[i] = {\n\t\t\t\t[parsed.signatureScheme]: parsed.signature,\n\t\t\t} as CompressedSignature;\n\n\t\t\tlet publicKeyIndex;\n\t\t\tfor (let j = 0; j < this.publicKeys.length; j++) {\n\t\t\t\tif (bytesEqual(publicKey, this.publicKeys[j].publicKey.toRawBytes())) {\n\t\t\t\t\tif (bitmap & (1 << j)) {\n\t\t\t\t\t\tthrow new Error('Received multiple signatures from the same public key');\n\t\t\t\t\t}\n\n\t\t\t\t\tpublicKeyIndex = j;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (publicKeyIndex === undefined) {\n\t\t\t\tthrow new Error('Received signature from unknown public key');\n\t\t\t}\n\n\t\t\tbitmap |= 1 << publicKeyIndex;\n\t\t}\n\n\t\tconst multisig: MultiSigStruct = {\n\t\t\tsigs: compressedSignatures,\n\t\t\tbitmap,\n\t\t\tmultisig_pk: this.multisigPublicKey,\n\t\t};\n\t\tconst bytes = bcs.MultiSig.serialize(multisig, { maxSize: 8192 }).toBytes();\n\t\tconst tmp = new Uint8Array(bytes.length + 1);\n\t\ttmp.set([SIGNATURE_SCHEME_TO_FLAG['MultiSig']]);\n\t\ttmp.set(bytes, 1);\n\t\treturn toBase64(tmp);\n\t}\n}\n\n/**\n * Parse multisig structure into an array of individual signatures: signature scheme, the actual individual signature, public key and its weight.\n */\nexport function parsePartialSignatures(\n\tmultisig: MultiSigStruct,\n\toptions: { client?: ZkLoginCompatibleClient } = {},\n): ParsedPartialMultiSigSignature[] {\n\tconst res: ParsedPartialMultiSigSignature[] = new Array(multisig.sigs.length);\n\tfor (let i = 0; i < multisig.sigs.length; i++) {\n\t\tconst [signatureScheme, signature] = Object.entries(multisig.sigs[i]).filter(\n\t\t\t([name]) => name !== '$kind',\n\t\t)[0] as [SignatureScheme, Uint8Array];\n\t\tconst pkIndex = asIndices(multisig.bitmap).at(i)!;\n\t\tconst pair = multisig.multisig_pk.pk_map[pkIndex];\n\t\tconst pkBytes = Uint8Array.from(Object.values(pair.pubKey)[0]);\n\n\t\tif (signatureScheme === 'MultiSig') {\n\t\t\tthrow new Error('MultiSig is not supported inside MultiSig');\n\t\t}\n\n\t\tconst publicKey = publicKeyFromRawBytes(signatureScheme, pkBytes, options);\n\n\t\tres[i] = {\n\t\t\tsignatureScheme,\n\t\t\tsignature: Uint8Array.from(signature),\n\t\t\tpublicKey: publicKey,\n\t\t\tweight: pair.weight,\n\t\t};\n\t}\n\treturn res;\n}\n\nfunction asIndices(bitmap: number): Uint8Array {\n\tif (bitmap < 0 || bitmap > 1024) {\n\t\tthrow new Error('Invalid bitmap');\n\t}\n\tconst res: number[] = [];\n\tfor (let i = 0; i < 10; i++) {\n\t\tif ((bitmap & (1 << i)) !== 0) {\n\t\t\tres.push(i);\n\t\t}\n\t}\n\treturn Uint8Array.from(res);\n}\n"],
+  "mappings": "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",
+  "names": ["import_bcs", "import_publickey"]
+}

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,105 @@
+"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("@haneullabs/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.toHaneulAddress()
+    }));
+    for (const signer of signers) {
+      const address = signer.toHaneulAddress();
+      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();
+//# sourceMappingURL=signer.js.map

package/dist/cjs/multisig/signer.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/multisig/signer.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\nimport { toBase64 } from '@haneullabs/bcs';\n\nimport type { SignatureScheme } from '../cryptography/index.js';\nimport { Signer } from '../cryptography/index.js';\nimport type { MultiSigPublicKey } from './publickey.js';\n\nexport class MultiSigSigner extends Signer {\n\t#pubkey: MultiSigPublicKey;\n\t#signers: Signer[];\n\n\tconstructor(pubkey: MultiSigPublicKey, signers: Signer[] = []) {\n\t\tsuper();\n\t\tthis.#pubkey = pubkey;\n\t\tthis.#signers = signers;\n\n\t\tconst uniqueKeys = new Set();\n\t\tlet combinedWeight = 0;\n\n\t\tconst weights = pubkey.getPublicKeys().map(({ weight, publicKey }) => ({\n\t\t\tweight,\n\t\t\taddress: publicKey.toHaneulAddress(),\n\t\t}));\n\n\t\tfor (const signer of signers) {\n\t\t\tconst address = signer.toHaneulAddress();\n\t\t\tif (uniqueKeys.has(address)) {\n\t\t\t\tthrow new Error(`Can't create MultiSigSigner with duplicate signers`);\n\t\t\t}\n\t\t\tuniqueKeys.add(address);\n\n\t\t\tconst weight = weights.find((w) => w.address === address)?.weight;\n\n\t\t\tif (!weight) {\n\t\t\t\tthrow new Error(`Signer ${address} is not part of the MultiSig public key`);\n\t\t\t}\n\n\t\t\tcombinedWeight += weight;\n\t\t}\n\n\t\tif (combinedWeight < pubkey.getThreshold()) {\n\t\t\tthrow new Error(`Combined weight of signers is less than threshold`);\n\t\t}\n\t}\n\n\tgetKeyScheme(): SignatureScheme {\n\t\treturn 'MultiSig';\n\t}\n\n\tgetPublicKey(): MultiSigPublicKey {\n\t\treturn this.#pubkey;\n\t}\n\n\tsign(_data: Uint8Array): never {\n\t\tthrow new Error(\n\t\t\t'MultiSigSigner does not support signing directly. Use signTransaction or signPersonalMessage instead',\n\t\t);\n\t}\n\n\t/** @deprecated use `sign` instead */\n\tsignData(_data: Uint8Array): never {\n\t\tthrow new Error(\n\t\t\t'MultiSigSigner does not support signing directly. Use signTransaction or signPersonalMessage instead',\n\t\t);\n\t}\n\n\tasync signTransaction(bytes: Uint8Array) {\n\t\tconst signature = this.#pubkey.combinePartialSignatures(\n\t\t\tawait Promise.all(\n\t\t\t\tthis.#signers.map(async (signer) => (await signer.signTransaction(bytes)).signature),\n\t\t\t),\n\t\t);\n\n\t\treturn {\n\t\t\tsignature,\n\t\t\tbytes: toBase64(bytes),\n\t\t};\n\t}\n\n\tasync signPersonalMessage(bytes: Uint8Array) {\n\t\tconst signature = this.#pubkey.combinePartialSignatures(\n\t\t\tawait Promise.all(\n\t\t\t\tthis.#signers.map(async (signer) => (await signer.signPersonalMessage(bytes)).signature),\n\t\t\t),\n\t\t);\n\n\t\treturn {\n\t\t\tsignature,\n\t\t\tbytes: toBase64(bytes),\n\t\t};\n\t}\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,iBAAyB;AAGzB,0BAAuB;AALvB;AAQO,MAAM,uBAAuB,2BAAO;AAAA,EAI1C,YAAY,QAA2B,UAAoB,CAAC,GAAG;AAC9D,UAAM;AAJP;AACA;AAIC,uBAAK,SAAU;AACf,uBAAK,UAAW;AAEhB,UAAM,aAAa,oBAAI,IAAI;AAC3B,QAAI,iBAAiB;AAErB,UAAM,UAAU,OAAO,cAAc,EAAE,IAAI,CAAC,EAAE,QAAQ,UAAU,OAAO;AAAA,MACtE;AAAA,MACA,SAAS,UAAU,gBAAgB;AAAA,IACpC,EAAE;AAEF,eAAW,UAAU,SAAS;AAC7B,YAAM,UAAU,OAAO,gBAAgB;AACvC,UAAI,WAAW,IAAI,OAAO,GAAG;AAC5B,cAAM,IAAI,MAAM,oDAAoD;AAAA,MACrE;AACA,iBAAW,IAAI,OAAO;AAEtB,YAAM,SAAS,QAAQ,KAAK,CAAC,MAAM,EAAE,YAAY,OAAO,GAAG;AAE3D,UAAI,CAAC,QAAQ;AACZ,cAAM,IAAI,MAAM,UAAU,OAAO,yCAAyC;AAAA,MAC3E;AAEA,wBAAkB;AAAA,IACnB;AAEA,QAAI,iBAAiB,OAAO,aAAa,GAAG;AAC3C,YAAM,IAAI,MAAM,mDAAmD;AAAA,IACpE;AAAA,EACD;AAAA,EAEA,eAAgC;AAC/B,WAAO;AAAA,EACR;AAAA,EAEA,eAAkC;AACjC,WAAO,mBAAK;AAAA,EACb;AAAA,EAEA,KAAK,OAA0B;AAC9B,UAAM,IAAI;AAAA,MACT;AAAA,IACD;AAAA,EACD;AAAA;AAAA,EAGA,SAAS,OAA0B;AAClC,UAAM,IAAI;AAAA,MACT;AAAA,IACD;AAAA,EACD;AAAA,EAEA,MAAM,gBAAgB,OAAmB;AACxC,UAAM,YAAY,mBAAK,SAAQ;AAAA,MAC9B,MAAM,QAAQ;AAAA,QACb,mBAAK,UAAS,IAAI,OAAO,YAAY,MAAM,OAAO,gBAAgB,KAAK,GAAG,SAAS;AAAA,MACpF;AAAA,IACD;AAEA,WAAO;AAAA,MACN;AAAA,MACA,WAAO,qBAAS,KAAK;AAAA,IACtB;AAAA,EACD;AAAA,EAEA,MAAM,oBAAoB,OAAmB;AAC5C,UAAM,YAAY,mBAAK,SAAQ;AAAA,MAC9B,MAAM,QAAQ;AAAA,QACb,mBAAK,UAAS,IAAI,OAAO,YAAY,MAAM,OAAO,oBAAoB,KAAK,GAAG,SAAS;AAAA,MACxF;AAAA,IACD;AAEA,WAAO;AAAA,MACN;AAAA,MACA,WAAO,qBAAS,KAAK;AAAA,IACtB;AAAA,EACD;AACD;AAnFC;AACA;",
+  "names": []
+}

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,49 @@
+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;
+        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,33 @@
+"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)
+};
+//# sourceMappingURL=Arguments.js.map

package/dist/cjs/transactions/Arguments.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/transactions/Arguments.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Argument } from './data/internal.js';\nimport type { Inputs } from './Inputs.js';\nimport { createObjectMethods } from './object.js';\nimport { createPure } from './pure.js';\nimport type { Transaction, TransactionObjectArgument } from './Transaction.js';\n\nexport const Arguments = {\n\tpure: createPure<(tx: Transaction) => Argument>((value) => (tx) => tx.pure(value)) as ReturnType<\n\t\ttypeof createPure<(tx: Transaction) => Argument>\n\t>,\n\tobject: createObjectMethods<TransactionObjectArgument>((value) => (tx) => tx.object(value)),\n\tsharedObjectRef:\n\t\t(...args: Parameters<(typeof Inputs)['SharedObjectRef']>) =>\n\t\t(tx: Transaction) =>\n\t\t\ttx.sharedObjectRef(...args),\n\tobjectRef:\n\t\t(...args: Parameters<(typeof Inputs)['ObjectRef']>) =>\n\t\t(tx: Transaction) =>\n\t\t\ttx.objectRef(...args),\n\treceivingRef:\n\t\t(...args: Parameters<(typeof Inputs)['ReceivingRef']>) =>\n\t\t(tx: Transaction) =>\n\t\t\ttx.receivingRef(...args),\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,oBAAoC;AACpC,kBAA2B;AAGpB,MAAM,YAAY;AAAA,EACxB,UAAM,wBAA0C,CAAC,UAAU,CAAC,OAAO,GAAG,KAAK,KAAK,CAAC;AAAA,EAGjF,YAAQ,mCAA+C,CAAC,UAAU,CAAC,OAAO,GAAG,OAAO,KAAK,CAAC;AAAA,EAC1F,iBACC,IAAI,SACJ,CAAC,OACA,GAAG,gBAAgB,GAAG,IAAI;AAAA,EAC5B,WACC,IAAI,SACJ,CAAC,OACA,GAAG,UAAU,GAAG,IAAI;AAAA,EACtB,cACC,IAAI,SACJ,CAAC,OACA,GAAG,aAAa,GAAG,IAAI;AAC1B;",
+  "names": []
+}

package/dist/cjs/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 {};