@wowok/wowok 2.2.11

package/dist/esm/jsonRpc/types/generated.js

@@ -0,0 +1 @@
+export{};

package/dist/esm/jsonRpc/types/index.d.ts

@@ -0,0 +1,6 @@
+export type * from "./chain.js";
+export type * from "./coins.js";
+export type * from "./common.js";
+export type * from "./changes.js";
+export type * from "./generated.js";
+export type * from "./params.js";

package/dist/esm/jsonRpc/types/index.js

@@ -0,0 +1 @@
+export{};

package/dist/esm/jsonRpc/types/params.d.ts

@@ -0,0 +1,303 @@
+import type * as RpcTypes from "./generated.js";
+import type { Transaction } from "../../transactions/index.js";
+export interface DevInspectTransactionBlockParams {
+    sender: string;
+    transactionBlock: Transaction | Uint8Array | string;
+    gasPrice?: bigint | number | null | undefined;
+    epoch?: string | null | undefined;
+    additionalArgs?: RpcTypes.DevInspectArgs | null | undefined;
+    signal?: AbortSignal;
+}
+export interface DryRunTransactionBlockParams {
+    transactionBlock: Uint8Array | string;
+    signal?: AbortSignal;
+}
+export interface ExecuteTransactionBlockParams {
+    transactionBlock: Uint8Array | string;
+    signature: string | string[];
+    options?: RpcTypes.WowTransactionBlockResponseOptions | null | undefined;
+    requestType?: RpcTypes.ExecuteTransactionRequestType | null | undefined;
+    signal?: AbortSignal;
+}
+export interface GetChainIdentifierParams {
+    signal?: AbortSignal;
+}
+export interface GetCheckpointParams {
+    id: RpcTypes.CheckpointId;
+    signal?: AbortSignal;
+}
+export interface GetCheckpointsParams {
+    cursor?: string | null | undefined;
+    limit?: number | null | undefined;
+    descendingOrder: boolean;
+    signal?: AbortSignal;
+}
+export interface GetEventsParams {
+    transactionDigest: string;
+    signal?: AbortSignal;
+}
+export interface GetLatestCheckpointSequenceNumberParams {
+    signal?: AbortSignal;
+}
+export interface GetMoveFunctionArgTypesParams {
+    package: string;
+    module: string;
+    function: string;
+    signal?: AbortSignal;
+}
+export interface GetNormalizedMoveFunctionParams {
+    package: string;
+    module: string;
+    function: string;
+    signal?: AbortSignal;
+}
+export interface GetNormalizedMoveModuleParams {
+    package: string;
+    module: string;
+    signal?: AbortSignal;
+}
+export interface GetNormalizedMoveModulesByPackageParams {
+    package: string;
+    signal?: AbortSignal;
+}
+export interface GetNormalizedMoveStructParams {
+    package: string;
+    module: string;
+    struct: string;
+    signal?: AbortSignal;
+}
+export interface GetObjectParams {
+    id: string;
+    options?: RpcTypes.WowObjectDataOptions | null | undefined;
+    signal?: AbortSignal;
+}
+export interface GetProtocolConfigParams {
+    version?: string | null | undefined;
+    signal?: AbortSignal;
+}
+export interface GetTotalTransactionBlocksParams {
+    signal?: AbortSignal;
+}
+export interface GetTransactionBlockParams {
+    digest: string;
+    options?: RpcTypes.WowTransactionBlockResponseOptions | null | undefined;
+    signal?: AbortSignal;
+}
+export interface MultiGetObjectsParams {
+    ids: string[];
+    options?: RpcTypes.WowObjectDataOptions | null | undefined;
+    signal?: AbortSignal;
+}
+export interface MultiGetTransactionBlocksParams {
+    digests: string[];
+    options?: RpcTypes.WowTransactionBlockResponseOptions | null | undefined;
+    signal?: AbortSignal;
+}
+export interface TryGetPastObjectParams {
+    id: string;
+    version: number;
+    options?: RpcTypes.WowObjectDataOptions | null | undefined;
+    signal?: AbortSignal;
+}
+export interface TryMultiGetPastObjectsParams {
+    pastObjects: RpcTypes.GetPastObjectRequest[];
+    options?: RpcTypes.WowObjectDataOptions | null | undefined;
+    signal?: AbortSignal;
+}
+export interface GetAllBalancesParams {
+    owner: string;
+    signal?: AbortSignal;
+}
+export interface GetAllCoinsParams {
+    owner: string;
+    cursor?: string | null | undefined;
+    limit?: number | null | undefined;
+    signal?: AbortSignal;
+}
+export interface GetBalanceParams {
+    owner: string;
+    coinType?: string | null | undefined;
+    signal?: AbortSignal;
+}
+export interface GetCoinMetadataParams {
+    coinType: string;
+    signal?: AbortSignal;
+}
+export interface GetCoinsParams {
+    owner: string;
+    coinType?: string | null | undefined;
+    cursor?: string | null | undefined;
+    limit?: number | null | undefined;
+    signal?: AbortSignal;
+}
+export interface GetCommitteeInfoParams {
+    epoch?: string | null | undefined;
+    signal?: AbortSignal;
+}
+export interface GetDynamicFieldObjectParams {
+    parentId: string;
+    name: RpcTypes.DynamicFieldName;
+    signal?: AbortSignal;
+}
+export interface GetDynamicFieldsParams {
+    parentId: string;
+    cursor?: string | null | undefined;
+    limit?: number | null | undefined;
+    signal?: AbortSignal;
+}
+export interface GetLatestWowSystemStateParams {
+    signal?: AbortSignal;
+}
+export type GetOwnedObjectsParams = {
+    owner: string;
+    cursor?: string | null | undefined;
+    limit?: number | null | undefined;
+    signal?: AbortSignal;
+} & RpcTypes.WowObjectResponseQuery;
+export interface GetReferenceGasPriceParams {
+    signal?: AbortSignal;
+}
+export interface GetStakesParams {
+    owner: string;
+    signal?: AbortSignal;
+}
+export interface GetStakesByIdsParams {
+    stakedWowIds: string[];
+    signal?: AbortSignal;
+}
+export interface GetTotalSupplyParams {
+    coinType: string;
+    signal?: AbortSignal;
+}
+export interface GetValidatorsApyParams {
+    signal?: AbortSignal;
+}
+export interface QueryEventsParams {
+    query: RpcTypes.WowEventFilter;
+    cursor?: RpcTypes.EventId | null | undefined;
+    limit?: number | null | undefined;
+    order?: "ascending" | "descending" | null | undefined;
+    signal?: AbortSignal;
+}
+export type QueryTransactionBlocksParams = {
+    cursor?: string | null | undefined;
+    limit?: number | null | undefined;
+    order?: "ascending" | "descending" | null | undefined;
+    signal?: AbortSignal;
+} & RpcTypes.WowTransactionBlockResponseQuery;
+export interface SubscribeEventParams {
+    filter: RpcTypes.WowEventFilter;
+    signal?: AbortSignal;
+}
+export interface SubscribeTransactionParams {
+    filter: RpcTypes.TransactionFilter;
+    signal?: AbortSignal;
+}
+export interface UnsafeBatchTransactionParams {
+    signer: string;
+    singleTransactionParams: RpcTypes.RPCTransactionRequestParams[];
+    gas?: string | null | undefined;
+    gasBudget: string;
+    txnBuilderMode?: RpcTypes.SuiTransactionBlockBuilderMode | null | undefined;
+    signal?: AbortSignal;
+}
+export interface UnsafeMergeCoinsParams {
+    signer: string;
+    primaryCoin: string;
+    coinToMerge: string;
+    gas?: string | null | undefined;
+    gasBudget: string;
+    signal?: AbortSignal;
+}
+export interface UnsafeMoveCallParams {
+    signer: string;
+    packageObjectId: string;
+    module: string;
+    function: string;
+    typeArguments: string[];
+    arguments: unknown[];
+    gas?: string | null | undefined;
+    gasBudget: string;
+    executionMode?: RpcTypes.SuiTransactionBlockBuilderMode | null | undefined;
+    signal?: AbortSignal;
+}
+export interface UnsafePayParams {
+    signer: string;
+    inputCoins: string[];
+    recipients: string[];
+    amounts: string[];
+    gas?: string | null | undefined;
+    gasBudget: string;
+    signal?: AbortSignal;
+}
+export interface UnsafePayAllSuiParams {
+    signer: string;
+    inputCoins: string[];
+    recipient: string;
+    gasBudget: string;
+    signal?: AbortSignal;
+}
+export interface UnsafePaySuiParams {
+    signer: string;
+    inputCoins: string[];
+    recipients: string[];
+    amounts: string[];
+    gasBudget: string;
+    signal?: AbortSignal;
+}
+export interface UnsafePublishParams {
+    sender: string;
+    compiledModules: string[];
+    dependencies: string[];
+    gas?: string | null | undefined;
+    gasBudget: string;
+    signal?: AbortSignal;
+}
+export interface UnsafeRequestAddStakeParams {
+    signer: string;
+    coins: string[];
+    amount?: string | null | undefined;
+    validator: string;
+    gas?: string | null | undefined;
+    gasBudget: string;
+    signal?: AbortSignal;
+}
+export interface UnsafeRequestWithdrawStakeParams {
+    signer: string;
+    stakedSui: string;
+    gas?: string | null | undefined;
+    gasBudget: string;
+    signal?: AbortSignal;
+}
+export interface UnsafeSplitCoinParams {
+    signer: string;
+    coinObjectId: string;
+    splitAmounts: string[];
+    gas?: string | null | undefined;
+    gasBudget: string;
+    signal?: AbortSignal;
+}
+export interface UnsafeSplitCoinEqualParams {
+    signer: string;
+    coinObjectId: string;
+    splitCount: string;
+    gas?: string | null | undefined;
+    gasBudget: string;
+    signal?: AbortSignal;
+}
+export interface UnsafeTransferObjectParams {
+    signer: string;
+    objectId: string;
+    gas?: string | null | undefined;
+    gasBudget: string;
+    recipient: string;
+    signal?: AbortSignal;
+}
+export interface UnsafeTransferSuiParams {
+    signer: string;
+    suiObjectId: string;
+    gasBudget: string;
+    recipient: string;
+    amount?: string | null | undefined;
+    signal?: AbortSignal;
+}

package/dist/esm/jsonRpc/types/params.js

@@ -0,0 +1 @@
+export{};

package/dist/esm/keypairs/falcon512/index.d.ts

@@ -0,0 +1,2 @@
+export { Falcon512PublicKey } from "./publickey.js";
+export { Falcon512Keypair, DEFAULT_FALCON512_DERIVATION_PATH, type Falcon512KeypairData, } from "./keypair.js";

package/dist/esm/keypairs/falcon512/index.js

@@ -0,0 +1 @@
+export{Falcon512PublicKey}from'./publickey.js';export{Falcon512Keypair,DEFAULT_FALCON512_DERIVATION_PATH}from'./keypair.js';

package/dist/esm/keypairs/falcon512/keypair.d.ts

@@ -0,0 +1,19 @@
+import { Keypair } from "../../cryptography/keypair.js";
+import type { SignatureScheme } from "../../cryptography/signature-scheme.js";
+import { Falcon512PublicKey } from "./publickey.js";
+export declare const DEFAULT_FALCON512_DERIVATION_PATH = "m/44'/784'/0'/0'/0'";
+export interface Falcon512KeypairData {
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+}
+export declare class Falcon512Keypair extends Keypair {
+    private keypair;
+    constructor(keypair?: Falcon512KeypairData);
+    getKeyScheme(): SignatureScheme;
+    static generate(): Falcon512Keypair;
+    static fromSecretKey(secretKey: Uint8Array | string): Falcon512Keypair;
+    getPublicKey(): Falcon512PublicKey;
+    getSecretKey(): string;
+    getRawSecretKey(): Uint8Array;
+    sign(data: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
+}

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

@@ -0,0 +1 @@
+import{falcon512padded}from'@noble/post-quantum/falcon.js';import{decodeWowPrivateKey,encodeWowPrivateKey,Keypair}from'../../cryptography/keypair.js';import{Falcon512PublicKey}from'./publickey.js';export const DEFAULT_FALCON512_DERIVATION_PATH='m/44\x27/784\x27/0\x27/0\x27/0\x27';export class Falcon512Keypair extends Keypair{['keypair'];constructor(a){super();if(a)this['keypair']=a;else{const b=falcon512padded['keygen']();this['keypair']={'publicKey':b['publicKey'],'secretKey':b['secretKey']};}}['getKeyScheme'](){return'Falcon512';}static['generate'](){const a=falcon512padded['keygen']();return new Falcon512Keypair({'publicKey':a['publicKey'],'secretKey':a['secretKey']});}static['fromSecretKey'](a){if(typeof a==='string'){const b=decodeWowPrivateKey(a);if(b['scheme']!=='Falcon512')throw new Error('Expected\x20a\x20Falcon512\x20keypair,\x20got\x20'+b['scheme']);return new Falcon512Keypair({'publicKey':falcon512padded['getPublicKey'](b['secretKey']),'secretKey':b['secretKey']});}return new Falcon512Keypair({'publicKey':falcon512padded['getPublicKey'](a),'secretKey':a});}['getPublicKey'](){return new Falcon512PublicKey(this['keypair']['publicKey']);}['getSecretKey'](){return encodeWowPrivateKey(this['keypair']['secretKey'],this['getKeyScheme']());}['getRawSecretKey'](){return this['keypair']['secretKey'];}async['sign'](a){return falcon512padded['sign'](a,this['keypair']['secretKey']);}}

package/dist/esm/keypairs/falcon512/publickey.d.ts

@@ -0,0 +1,11 @@
+import { PublicKey } from "../../cryptography/publickey.js";
+import type { PublicKeyInitData } from "../../cryptography/publickey.js";
+export declare class Falcon512PublicKey extends PublicKey {
+    static SIZE: number;
+    private data;
+    constructor(value: PublicKeyInitData);
+    equals(publicKey: Falcon512PublicKey): boolean;
+    toRawBytes(): Uint8Array<ArrayBuffer>;
+    flag(): number;
+    verify(message: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
+}

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

@@ -0,0 +1 @@
+import{fromBase64}from'../../_deps/bcs/index.js';import{falcon512padded}from'@noble/post-quantum/falcon.js';import{bytesEqual,parseSerializedKeypairSignature,PublicKey}from'../../cryptography/publickey.js';import{SIGNATURE_SCHEME_TO_FLAG}from'../../cryptography/signature-scheme.js';const PUBLIC_KEY_SIZE=0x381;export class Falcon512PublicKey extends PublicKey{static ['SIZE']=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']!==PUBLIC_KEY_SIZE)throw new Error('Invalid\x20public\x20key\x20input.\x20Expected\x20'+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['Falcon512'];}async['verify'](a,b){let c;if(typeof b==='string'){const d=parseSerializedKeypairSignature(b);if(d['signatureScheme']!=='Falcon512')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 falcon512padded['verify'](c,a,this['toRawBytes']());}}

package/dist/esm/keypairs/index.d.ts

@@ -0,0 +1 @@
+export * from "./falcon512/index.js";

package/dist/esm/keypairs/index.js

@@ -0,0 +1 @@
+export*from'./falcon512/index.js';

package/dist/esm/multisig/index.d.ts

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

package/dist/esm/multisig/index.js

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

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

@@ -0,0 +1,44 @@
+import { bcs } from "../bcs/index.js";
+import type { Signer } from "../cryptography/keypair.js";
+import { PublicKey } from "../cryptography/publickey.js";
+import type { SignatureScheme } from "../cryptography/signature-scheme.js";
+import { MultiSigSigner } from "./signer.js";
+type ParsedPartialMultiSigSignature = {
+    signatureScheme: SignatureScheme;
+    signature: Uint8Array;
+    publicKey: PublicKey;
+    weight: number;
+};
+export declare const MAX_SIGNER_IN_MULTISIG = 10;
+export declare const MIN_SIGNER_IN_MULTISIG = 1;
+export type MultiSigPublicKeyStruct = ReturnType<typeof bcs.MultiSigPublicKey.parse>;
+export type MultiSigStruct = ReturnType<typeof bcs.MultiSig.parse>;
+export type CompressedSignature = ReturnType<typeof bcs.CompressedSignature.parse>;
+export type PublicKeyEnum = ReturnType<typeof bcs.PublicKey.parse>;
+export declare class MultiSigPublicKey extends PublicKey {
+    private rawBytes;
+    private multisigPublicKey;
+    private publicKeys;
+    constructor(value: string | Uint8Array | MultiSigPublicKeyStruct);
+    static fromPublicKeys({ threshold, publicKeys, }: {
+        threshold: number;
+        publicKeys: {
+            publicKey: PublicKey;
+            weight: number;
+        }[];
+    }): MultiSigPublicKey;
+    equals(publicKey: MultiSigPublicKey): boolean;
+    toRawBytes(): Uint8Array<ArrayBuffer>;
+    getPublicKeys(): {
+        weight: number;
+        publicKey: PublicKey;
+    }[];
+    getThreshold(): any;
+    getSigner(...signers: [signer: Signer]): MultiSigSigner;
+    toWAddress(): string;
+    flag(): number;
+    verify(message: Uint8Array, multisigSignature: string): Promise<boolean>;
+    combinePartialSignatures(signatures: string[]): string;
+}
+export declare function parsePartialSignatures(multisig: MultiSigStruct): ParsedPartialMultiSigSignature[];
+export {};

package/dist/esm/multisig/publickey.js

@@ -0,0 +1 @@
+import{fromBase64,toBase64}from'../_deps/bcs/index.js';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/wow-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.d.ts

@@ -0,0 +1,19 @@
+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;
+    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 @@
+import{toBase64}from'../_deps/bcs/index.js';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.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;
+        }): TransactionObjectArgument;
+        clock(): TransactionObjectArgument;
+        random(): TransactionObjectArgument;
+        denyList(options?: {
+            mutable?: boolean;
+        }): TransactionObjectArgument;
+        registrar(options?: {
+            mutable?: boolean;
+        }): TransactionObjectArgument;
+        mutRegistrar(): TransactionObjectArgument;
+        entity(options?: {
+            mutable?: boolean;
+        }): 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 @@
+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.d.ts

@@ -0,0 +1,54 @@
+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];
+};
+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 @@
+import{toBase64}from'../_deps/bcs/index.js';import{parse}from'valibot';import{normalizeWowObjectId}from'../utils/wow-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.d.ts

@@ -0,0 +1,22 @@
+import type { SerializedBcs } from "../_deps/bcs/index.js";
+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 {};

package/dist/esm/transactions/Inputs.js

@@ -0,0 +1 @@
+import{toBase64}from'../_deps/bcs/index.js';import{normalizeWowAddress}from'../utils/wow-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)}}};}};