wowok 2.1.40 → 2.1.41

package/dist/esm/keypairs/secp256r1/keypair.js

@@ -1,78 +1 @@
-import { secp256r1 } from "@noble/curves/p256";
-import { blake2b } from "@noble/hashes/blake2b";
-import { sha256 } from "@noble/hashes/sha256";
-import { bytesToHex } from "@noble/hashes/utils";
-import { HDKey } from "@scure/bip32";
-import { decodeWowPrivateKey, encodeWowPrivateKey, Keypair, } from "../../cryptography/keypair.js";
-import { isValidBIP32Path, mnemonicToSeed, } from "../../cryptography/mnemonics.js";
-import { Secp256r1PublicKey } from "./publickey.js";
-export const DEFAULT_SECP256R1_DERIVATION_PATH = "m/74'/784'/0'/0/0";
-export class Secp256r1Keypair extends Keypair {
-    keypair;
-    constructor(keypair) {
-        super();
-        if (keypair) {
-            this.keypair = keypair;
-        }
-        else {
-            const secretKey = secp256r1.utils.randomPrivateKey();
-            const publicKey = secp256r1.getPublicKey(secretKey, true);
-            this.keypair = { publicKey, secretKey };
-        }
-    }
-    getKeyScheme() {
-        return "Secp256r1";
-    }
-    static generate() {
-        return new Secp256r1Keypair();
-    }
-    static fromSecretKey(secretKey, options) {
-        if (typeof secretKey === "string") {
-            const decoded = decodeWowPrivateKey(secretKey);
-            if (decoded.scheme !== "Secp256r1") {
-                throw new Error(`Expected a Secp256r1 keypair, got ${decoded.scheme}`);
-            }
-            return this.fromSecretKey(decoded.secretKey, options);
-        }
-        const publicKey = secp256r1.getPublicKey(secretKey, true);
-        if (!options || !options.skipValidation) {
-            const encoder = new TextEncoder();
-            const signData = encoder.encode("sui validation");
-            const msgHash = bytesToHex(blake2b(signData, { dkLen: 32 }));
-            const signature = secp256r1.sign(msgHash, secretKey, {
-                lowS: true,
-            });
-            if (!secp256r1.verify(signature, msgHash, publicKey, { lowS: true })) {
-                throw new Error("Provided secretKey is invalid");
-            }
-        }
-        return new Secp256r1Keypair({ publicKey, secretKey });
-    }
-    static fromSeed(seed) {
-        const publicKey = secp256r1.getPublicKey(seed, true);
-        return new Secp256r1Keypair({ publicKey, secretKey: seed });
-    }
-    getPublicKey() {
-        return new Secp256r1PublicKey(this.keypair.publicKey);
-    }
-    getSecretKey() {
-        return encodeWowPrivateKey(this.keypair.secretKey, this.getKeyScheme());
-    }
-    async sign(data) {
-        const msgHash = sha256(data);
-        const sig = secp256r1.sign(msgHash, this.keypair.secretKey, {
-            lowS: true,
-        });
-        return sig.toCompactRawBytes();
-    }
-    static deriveKeypair(mnemonics, path) {
-        if (path == null) {
-            path = DEFAULT_SECP256R1_DERIVATION_PATH;
-        }
-        if (!isValidBIP32Path(path)) {
-            throw new Error("Invalid derivation path");
-        }
-        const privateKey = HDKey.fromMasterSeed(mnemonicToSeed(mnemonics)).derive(path).privateKey;
-        return Secp256r1Keypair.fromSecretKey(privateKey);
-    }
-}
+import{secp256r1}from'@noble/curves/p256';import{blake2b}from'@noble/hashes/blake2b';import{sha256}from'@noble/hashes/sha256';import{bytesToHex}from'@noble/hashes/utils';import{HDKey}from'@scure/bip32';import{decodeWowPrivateKey,encodeWowPrivateKey,Keypair}from'../../cryptography/keypair.js';import{isValidBIP32Path,mnemonicToSeed}from'../../cryptography/mnemonics.js';import{Secp256r1PublicKey}from'./publickey.js';export const DEFAULT_SECP256R1_DERIVATION_PATH='m/74\x27/784\x27/0\x27/0/0';export class Secp256r1Keypair extends Keypair{['keypair'];constructor(a){super();if(a)this['keypair']=a;else{const b=secp256r1['utils']['randomPrivateKey'](),c=secp256r1['getPublicKey'](b,!![]);this['keypair']={'publicKey':c,'secretKey':b};}}['getKeyScheme'](){return'Secp256r1';}static['generate'](){return new Secp256r1Keypair();}static['fromSecretKey'](a,b){if(typeof a==='string'){const d=decodeWowPrivateKey(a);if(d['scheme']!=='Secp256r1')throw new Error('Expected\x20a\x20Secp256r1\x20keypair,\x20got\x20'+d['scheme']);return this['fromSecretKey'](d['secretKey'],b);}const c=secp256r1['getPublicKey'](a,!![]);if(!b||!b['skipValidation']){const e=new TextEncoder(),f=e['encode']('sui\x20validation'),g=bytesToHex(blake2b(f,{'dkLen':0x20})),h=secp256r1['sign'](g,a,{'lowS':!![]});if(!secp256r1['verify'](h,g,c,{'lowS':!![]}))throw new Error('Provided\x20secretKey\x20is\x20invalid');}return new Secp256r1Keypair({'publicKey':c,'secretKey':a});}static['fromSeed'](a){const b=secp256r1['getPublicKey'](a,!![]);return new Secp256r1Keypair({'publicKey':b,'secretKey':a});}['getPublicKey'](){return new Secp256r1PublicKey(this['keypair']['publicKey']);}['getSecretKey'](){return encodeWowPrivateKey(this['keypair']['secretKey'],this['getKeyScheme']());}async['sign'](a){const b=sha256(a),c=secp256r1['sign'](b,this['keypair']['secretKey'],{'lowS':!![]});return c['toCompactRawBytes']();}static['deriveKeypair'](a,b){b==null&&(b=DEFAULT_SECP256R1_DERIVATION_PATH);if(!isValidBIP32Path(b))throw new Error('Invalid\x20derivation\x20path');const c=HDKey['fromMasterSeed'](mnemonicToSeed(a))['derive'](b)['privateKey'];return Secp256r1Keypair['fromSecretKey'](c);}}

package/dist/esm/keypairs/secp256r1/publickey.js

@@ -1,52 +1 @@
-import { fromBase64 } from "@mysten/bcs";
-import { secp256r1 } from "@noble/curves/p256";
-import { sha256 } from "@noble/hashes/sha256";
-import { bytesEqual, PublicKey } from "../../cryptography/publickey.js";
-import { SIGNATURE_SCHEME_TO_FLAG } from "../../cryptography/signature-scheme.js";
-import { parseSerializedSignature } from "../../cryptography/signature.js";
-const SECP256R1_PUBLIC_KEY_SIZE = 33;
-export class Secp256r1PublicKey extends PublicKey {
-    static SIZE = SECP256R1_PUBLIC_KEY_SIZE;
-    data;
-    constructor(value) {
-        super();
-        if (typeof value === "string") {
-            this.data = fromBase64(value);
-        }
-        else if (value instanceof Uint8Array) {
-            this.data = value;
-        }
-        else {
-            this.data = Uint8Array.from(value);
-        }
-        if (this.data.length !== SECP256R1_PUBLIC_KEY_SIZE) {
-            throw new Error(`Invalid public key input. Expected ${SECP256R1_PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`);
-        }
-    }
-    equals(publicKey) {
-        return super.equals(publicKey);
-    }
-    toRawBytes() {
-        return this.data;
-    }
-    flag() {
-        return SIGNATURE_SCHEME_TO_FLAG["Secp256r1"];
-    }
-    async verify(message, signature) {
-        let bytes;
-        if (typeof signature === "string") {
-            const parsed = parseSerializedSignature(signature);
-            if (parsed.signatureScheme !== "Secp256r1") {
-                throw new Error("Invalid signature scheme");
-            }
-            if (!bytesEqual(this.toRawBytes(), parsed.publicKey)) {
-                throw new Error("Signature does not match public key");
-            }
-            bytes = parsed.signature;
-        }
-        else {
-            bytes = signature;
-        }
-        return secp256r1.verify(secp256r1.Signature.fromCompact(bytes), sha256(message), this.toRawBytes());
-    }
-}
+import{fromBase64}from'@mysten/bcs';import{secp256r1}from'@noble/curves/p256';import{sha256}from'@noble/hashes/sha256';import{bytesEqual,PublicKey}from'../../cryptography/publickey.js';import{SIGNATURE_SCHEME_TO_FLAG}from'../../cryptography/signature-scheme.js';import{parseSerializedSignature}from'../../cryptography/signature.js';const SECP256R1_PUBLIC_KEY_SIZE=0x21;export class Secp256r1PublicKey extends PublicKey{static ['SIZE']=SECP256R1_PUBLIC_KEY_SIZE;['data'];constructor(a){super();if(typeof a==='string')this['data']=fromBase64(a);else a instanceof Uint8Array?this['data']=a:this['data']=Uint8Array['from'](a);if(this['data']['length']!==SECP256R1_PUBLIC_KEY_SIZE)throw new Error('Invalid\x20public\x20key\x20input.\x20Expected\x20'+SECP256R1_PUBLIC_KEY_SIZE+'\x20bytes,\x20got\x20'+this['data']['length']);}['equals'](a){return super['equals'](a);}['toRawBytes'](){return this['data'];}['flag'](){return SIGNATURE_SCHEME_TO_FLAG['Secp256r1'];}async['verify'](a,b){let c;if(typeof b==='string'){const d=parseSerializedSignature(b);if(d['signatureScheme']!=='Secp256r1')throw new Error('Invalid\x20signature\x20scheme');if(!bytesEqual(this['toRawBytes'](),d['publicKey']))throw new Error('Signature\x20does\x20not\x20match\x20public\x20key');c=d['signature'];}else c=b;return secp256r1['verify'](secp256r1['Signature']['fromCompact'](c),sha256(a),this['toRawBytes']());}}

package/dist/esm/multisig/index.js

@@ -1,2 +1 @@
-export { MultiSigSigner } from "./signer.js";
-export { MultiSigPublicKey, parsePartialSignatures, } from "./publickey.js";
+export{MultiSigSigner}from'./signer.js';export{MultiSigPublicKey,parsePartialSignatures}from'./publickey.js';

package/dist/esm/multisig/publickey.js

@@ -1,201 +1 @@
-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";
-export const MAX_SIGNER_IN_MULTISIG = 10;
-export const MIN_SIGNER_IN_MULTISIG = 1;
-export class MultiSigPublicKey extends PublicKey {
-    rawBytes;
-    multisigPublicKey;
-    publicKeys;
-    constructor(value) {
-        super();
-        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 = 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}`);
-        }
-    }
-    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,
-        });
-    }
-    equals(publicKey) {
-        return super.equals(publicKey);
-    }
-    toRawBytes() {
-        return this.rawBytes;
-    }
-    getPublicKeys() {
-        return this.publicKeys;
-    }
-    getThreshold() {
-        return this.multisigPublicKey.threshold;
-    }
-    getSigner(...signers) {
-        return new MultiSigSigner(this, signers);
-    }
-    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 })));
-    }
-    flag() {
-        return SIGNATURE_SCHEME_TO_FLAG["MultiSig"];
-    }
-    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;
-    }
-    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 === undefined) {
-                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);
-    }
-}
-export 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: 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);
-}
+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';export const MAX_SIGNER_IN_MULTISIG=0xa;export const MIN_SIGNER_IN_MULTISIG=0x1;export class MultiSigPublicKey extends PublicKey{['rawBytes'];['multisigPublicKey'];['publicKeys'];constructor(a){super();if(typeof a==='string')this['rawBytes']=fromBase64(a),this['multisigPublicKey']=bcs['MultiSigPublicKey']['parse'](this['rawBytes']);else a instanceof Uint8Array?(this['rawBytes']=a,this['multisigPublicKey']=bcs['MultiSigPublicKey']['parse'](this['rawBytes'])):(this['multisigPublicKey']=a,this['rawBytes']=bcs['MultiSigPublicKey']['serialize'](a)['toBytes']());if(this['multisigPublicKey']['threshold']<0x1)throw new Error('Invalid\x20threshold');const b=new Set();this['publicKeys']=this['multisigPublicKey']['pk_map']['map'](({pubKey:d,weight:e})=>{const [f,g]=Object['entries'](d)['filter'](([i])=>i!=='$kind')[0x0],h=Uint8Array['from'](g)['toString']();if(b['has'](h))throw new Error('Multisig\x20does\x20not\x20support\x20duplicate\x20public\x20keys');b['add'](h);if(e<0x1)throw new Error('Invalid\x20weight');return{'publicKey':publicKeyFromRawBytes(f,Uint8Array['from'](g)),'weight':e};});const c=this['publicKeys']['reduce']((d,{weight:e})=>d+e,0x0);if(this['multisigPublicKey']['threshold']>c)throw new Error('Unreachable\x20threshold');if(this['publicKeys']['length']>MAX_SIGNER_IN_MULTISIG)throw new Error('Max\x20number\x20of\x20signers\x20in\x20a\x20multisig\x20is\x20'+MAX_SIGNER_IN_MULTISIG);if(this['publicKeys']['length']<MIN_SIGNER_IN_MULTISIG)throw new Error('Min\x20number\x20of\x20signers\x20in\x20a\x20multisig\x20is\x20'+MIN_SIGNER_IN_MULTISIG);}static['fromPublicKeys']({threshold:a,publicKeys:b}){return new MultiSigPublicKey({'pk_map':b['map'](({publicKey:c,weight:d})=>{const e=SIGNATURE_FLAG_TO_SCHEME[c['flag']()];return{'pubKey':{[e]:c['toRawBytes']()},'weight':d};}),'threshold':a});}['equals'](a){return super['equals'](a);}['toRawBytes'](){return this['rawBytes'];}['getPublicKeys'](){return this['publicKeys'];}['getThreshold'](){return this['multisigPublicKey']['threshold'];}['getSigner'](...a){return new MultiSigSigner(this,a);}['toWAddress'](){const a=0x1+(0x40+0x1)*MAX_SIGNER_IN_MULTISIG+0x2,b=new Uint8Array(a);b['set']([SIGNATURE_SCHEME_TO_FLAG['MultiSig']]),b['set'](bcs['u16']()['serialize'](this['multisigPublicKey']['threshold'])['toBytes'](),0x1);let c=0x3;for(const {publicKey:d,weight:e}of this['publicKeys']){const f=d['toWBytes']();b['set'](f,c),c+=f['length'],b['set']([e],c++);}return normalizeWowAddress(bytesToHex(blake2b(b['slice'](0x0,c),{'dkLen':0x20})));}['flag'](){return SIGNATURE_SCHEME_TO_FLAG['MultiSig'];}async['verify'](a,b){const c=parseSerializedSignature(b);if(c['signatureScheme']!=='MultiSig')throw new Error('Invalid\x20signature\x20scheme');const {multisig:d}=c;let e=0x0;if(!bytesEqual(bcs['MultiSigPublicKey']['serialize'](this['multisigPublicKey'])['toBytes'](),bcs['MultiSigPublicKey']['serialize'](d['multisig_pk'])['toBytes']()))return![];for(const {publicKey:f,weight:g,signature:h}of parsePartialSignatures(d)){if(!await f['verify'](a,h))return![];e+=g;}return e>=this['multisigPublicKey']['threshold'];}['combinePartialSignatures'](a){if(a['length']>MAX_SIGNER_IN_MULTISIG)throw new Error('Max\x20number\x20of\x20signatures\x20in\x20a\x20multisig\x20is\x20'+MAX_SIGNER_IN_MULTISIG);let b=0x0;const c=new Array(a['length']);for(let g=0x0;g<a['length'];g++){const h=parseSerializedSignature(a[g]);if(h['signatureScheme']==='MultiSig')throw new Error('MultiSig\x20is\x20not\x20supported\x20inside\x20MultiSig');const k=h['publicKey'];c[g]={[h['signatureScheme']]:h['signature']};let l;for(let m=0x0;m<this['publicKeys']['length'];m++){if(bytesEqual(k,this['publicKeys'][m]['publicKey']['toRawBytes']())){if(b&0x1<<m)throw new Error('Received\x20multiple\x20signatures\x20from\x20the\x20same\x20public\x20key');l=m;break;}}if(l===undefined)throw new Error('Received\x20signature\x20from\x20unknown\x20public\x20key');b|=0x1<<l;}const d={'sigs':c,'bitmap':b,'multisig_pk':this['multisigPublicKey']},e=bcs['MultiSig']['serialize'](d,{'maxSize':0x2000})['toBytes'](),f=new Uint8Array(e['length']+0x1);return f['set']([SIGNATURE_SCHEME_TO_FLAG['MultiSig']]),f['set'](e,0x1),toBase64(f);}}export function parsePartialSignatures(a){const b=new Array(a['sigs']['length']);for(let c=0x0;c<a['sigs']['length'];c++){const [d,e]=Object['entries'](a['sigs'][c])['filter'](([l])=>l!=='$kind')[0x0],f=asIndices(a['bitmap']),g=f[c],h=a['multisig_pk']['pk_map'][g],j=Uint8Array['from'](Object['values'](h['pubKey'])[0x0]);if(d==='MultiSig')throw new Error('MultiSig\x20is\x20not\x20supported\x20inside\x20MultiSig');const k=publicKeyFromRawBytes(d,j);b[c]={'signatureScheme':d,'signature':Uint8Array['from'](e),'publicKey':k,'weight':h['weight']};}return b;}function asIndices(a){if(a<0x0||a>0x400)throw new Error('Invalid\x20bitmap');const b=[];for(let c=0x0;c<0xa;c++){(a&0x1<<c)!==0x0&&b['push'](c);}return Uint8Array['from'](b);}

package/dist/esm/multisig/signer.js

@@ -1,58 +1 @@
-import { toBase64 } from "@mysten/bcs";
-import { Signer } from "../cryptography/index.js";
-export class MultiSigSigner extends Signer {
-    #pubkey;
-    #signers;
-    constructor(pubkey, signers = []) {
-        super();
-        this.#pubkey = pubkey;
-        this.#signers = signers;
-        const uniqueKeys = 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 this.#pubkey;
-    }
-    sign(_data) {
-        throw new Error("MultiSigSigner does not support signing directly. Use signTransaction or signPersonalMessage instead");
-    }
-    signData(_data) {
-        throw new Error("MultiSigSigner does not support signing directly. Use signTransaction or signPersonalMessage instead");
-    }
-    async signTransaction(bytes) {
-        const signature = this.#pubkey.combinePartialSignatures(await Promise.all(this.#signers.map(async (signer) => (await signer.signTransaction(bytes)).signature)));
-        return {
-            signature,
-            bytes: toBase64(bytes),
-        };
-    }
-    async signPersonalMessage(bytes) {
-        const signature = this.#pubkey.combinePartialSignatures(await Promise.all(this.#signers.map(async (signer) => (await signer.signPersonalMessage(bytes)).signature)));
-        return {
-            signature,
-            bytes: toBase64(bytes),
-        };
-    }
-}
+import{toBase64}from'@mysten/bcs';import{Signer}from'../cryptography/index.js';export class MultiSigSigner extends Signer{#pubkey;#signers;constructor(a,b=[]){super(),this.#pubkey=a,this.#signers=b;const c=new Set();let d=0x0;const e=a['getPublicKeys']()['map'](({weight:f,publicKey:g})=>({'weight':f,'address':g['toWAddress']()}));for(const f of b){const g=f['toWAddress']();if(c['has'](g))throw new Error('Can\x27t\x20create\x20MultiSigSigner\x20with\x20duplicate\x20signers');c['add'](g);const h=e['find'](i=>i['address']===g)?.['weight'];if(!h)throw new Error('Signer\x20'+g+'\x20is\x20not\x20part\x20of\x20the\x20MultiSig\x20public\x20key');d+=h;}if(d<a['getThreshold']())throw new Error('Combined\x20weight\x20of\x20signers\x20is\x20less\x20than\x20threshold');}['getKeyScheme'](){return'MultiSig';}['getPublicKey'](){return this.#pubkey;}['sign'](a){throw new Error('MultiSigSigner\x20does\x20not\x20support\x20signing\x20directly.\x20Use\x20signTransaction\x20or\x20signPersonalMessage\x20instead');}['signData'](a){throw new Error('MultiSigSigner\x20does\x20not\x20support\x20signing\x20directly.\x20Use\x20signTransaction\x20or\x20signPersonalMessage\x20instead');}async['signTransaction'](a){const b=this.#pubkey['combinePartialSignatures'](await Promise['all'](this.#signers['map'](async c=>(await c['signTransaction'](a))['signature'])));return{'signature':b,'bytes':toBase64(a)};}async['signPersonalMessage'](a){const b=this.#pubkey['combinePartialSignatures'](await Promise['all'](this.#signers['map'](async c=>(await c['signPersonalMessage'](a))['signature'])));return{'signature':b,'bytes':toBase64(a)};}}

package/dist/esm/transactions/Arguments.js

@@ -1,9 +1 @@
-import { createObjectMethods } from "./object.js";
-import { createPure } from "./pure.js";
-export 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),
-};
+import{createObjectMethods}from'./object.js';import{createPure}from'./pure.js';export const Arguments={'pure':createPure(a=>b=>b['pure'](a)),'object':createObjectMethods(a=>b=>b['object'](a)),'sharedObjectRef':(...a)=>b=>b['sharedObjectRef'](...a),'objectRef':(...a)=>b=>b['objectRef'](...a),'receivingRef':(...a)=>b=>b['receivingRef'](...a)};

package/dist/esm/transactions/Commands.js

@@ -1,102 +1 @@
-import { toBase64 } from "@mysten/bcs";
-import { parse } from "valibot";
-import { normalizeWowObjectId } from "../utils/sui-types.js";
-import { ArgumentSchema } from "./data/internal.js";
-export var UpgradePolicy;
-(function (UpgradePolicy) {
-    UpgradePolicy[UpgradePolicy["COMPATIBLE"] = 0] = "COMPATIBLE";
-    UpgradePolicy[UpgradePolicy["ADDITIVE"] = 128] = "ADDITIVE";
-    UpgradePolicy[UpgradePolicy["DEP_ONLY"] = 192] = "DEP_ONLY";
-})(UpgradePolicy || (UpgradePolicy = {}));
-export 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,
-            },
-        };
-    },
-};
+import{toBase64}from'@mysten/bcs';import{parse}from'valibot';import{normalizeWowObjectId}from'../utils/sui-types.js';import{ArgumentSchema}from'./data/internal.js';export var UpgradePolicy;(function(a){a[a['COMPATIBLE']=0x0]='COMPATIBLE',a[a['ADDITIVE']=0x80]='ADDITIVE',a[a['DEP_ONLY']=0xc0]='DEP_ONLY';}(UpgradePolicy||(UpgradePolicy={})));export const Commands={'MoveCall'(a){const [b,c='',d='']='target'in a?a['target']['split']('::'):[a['package'],a['module'],a['function']];return{'$kind':'MoveCall','MoveCall':{'package':b,'module':c,'function':d,'typeArguments':a['typeArguments']??[],'arguments':a['arguments']??[]}};},'TransferObjects'(a,b){return{'$kind':'TransferObjects','TransferObjects':{'objects':a['map'](c=>parse(ArgumentSchema,c)),'address':parse(ArgumentSchema,b)}};},'SplitCoins'(a,b){return{'$kind':'SplitCoins','SplitCoins':{'coin':parse(ArgumentSchema,a),'amounts':b['map'](c=>parse(ArgumentSchema,c))}};},'MergeCoins'(a,b){return{'$kind':'MergeCoins','MergeCoins':{'destination':parse(ArgumentSchema,a),'sources':b['map'](c=>parse(ArgumentSchema,c))}};},'Publish'({modules:a,dependencies:b}){return{'$kind':'Publish','Publish':{'modules':a['map'](c=>typeof c==='string'?c:toBase64(new Uint8Array(c))),'dependencies':b['map'](c=>normalizeWowObjectId(c))}};},'Upgrade'({modules:a,dependencies:b,package:c,ticket:d}){return{'$kind':'Upgrade','Upgrade':{'modules':a['map'](e=>typeof e==='string'?e:toBase64(new Uint8Array(e))),'dependencies':b['map'](e=>normalizeWowObjectId(e)),'package':c,'ticket':parse(ArgumentSchema,d)}};},'MakeMoveVec'({type:a,elements:b}){return{'$kind':'MakeMoveVec','MakeMoveVec':{'type':a??null,'elements':b['map'](c=>parse(ArgumentSchema,c))}};},'Intent'({name:a,inputs:inputs={},data:data={}}){return{'$kind':'$Intent','$Intent':{'name':a,'inputs':Object['fromEntries'](Object['entries'](inputs)['map'](([b,c])=>[b,Array['isArray'](c)?c['map'](d=>parse(ArgumentSchema,d)):parse(ArgumentSchema,c)])),'data':data}};}};

package/dist/esm/transactions/Inputs.js

@@ -1,52 +1 @@
-import { toBase64 } from "@mysten/bcs";
-import { normalizeWowAddress } from "../utils/sui-types.js";
-function Pure(data) {
-    return {
-        $kind: "Pure",
-        Pure: {
-            bytes: data instanceof Uint8Array ? toBase64(data) : data.toBase64(),
-        },
-    };
-}
-export const Inputs = {
-    Pure,
-    ObjectRef({ objectId, digest, version, }) {
-        return {
-            $kind: "Object",
-            Object: {
-                $kind: "ImmOrOwnedObject",
-                ImmOrOwnedObject: {
-                    digest,
-                    version,
-                    objectId: normalizeWowAddress(objectId),
-                },
-            },
-        };
-    },
-    SharedObjectRef({ objectId, mutable, initialSharedVersion, }) {
-        return {
-            $kind: "Object",
-            Object: {
-                $kind: "SharedObject",
-                SharedObject: {
-                    mutable,
-                    initialSharedVersion,
-                    objectId: normalizeWowAddress(objectId),
-                },
-            },
-        };
-    },
-    ReceivingRef({ objectId, digest, version, }) {
-        return {
-            $kind: "Object",
-            Object: {
-                $kind: "Receiving",
-                Receiving: {
-                    digest,
-                    version,
-                    objectId: normalizeWowAddress(objectId),
-                },
-            },
-        };
-    },
-};
+import{toBase64}from'@mysten/bcs';import{normalizeWowAddress}from'../utils/sui-types.js';function Pure(a){return{'$kind':'Pure','Pure':{'bytes':a instanceof Uint8Array?toBase64(a):a['toBase64']()}};}export const Inputs={'Pure':Pure,'ObjectRef'({objectId:a,digest:b,version:c}){return{'$kind':'Object','Object':{'$kind':'ImmOrOwnedObject','ImmOrOwnedObject':{'digest':b,'version':c,'objectId':normalizeWowAddress(a)}}};},'SharedObjectRef'({objectId:a,mutable:b,initialSharedVersion:c}){return{'$kind':'Object','Object':{'$kind':'SharedObject','SharedObject':{'mutable':b,'initialSharedVersion':c,'objectId':normalizeWowAddress(a)}}};},'ReceivingRef'({objectId:a,digest:b,version:c}){return{'$kind':'Object','Object':{'$kind':'Receiving','Receiving':{'digest':b,'version':c,'objectId':normalizeWowAddress(a)}}};}};