@msafe/sui3-sdk 0.0.2-pre-9f39791.0 → 0.0.2

package/dist/index.d.cts

@@ -0,0 +1,454 @@
+import * as _mysten_sui_js_src_cryptography from '@mysten/sui.js/src/cryptography';
+import { PublicKey } from '@mysten/sui.js/src/cryptography';
+import { SuiClient, ExecuteTransactionRequestType, SuiTransactionBlockResponseOptions, SuiTransactionBlockResponse, CoinStruct, CoinMetadata, SuiObjectData } from '@mysten/sui.js/client';
+import { SerializedSignature, PublicKey as PublicKey$1, SignatureScheme } from '@mysten/sui.js/cryptography';
+import * as _mysten_sui_js_dist_cjs_builder from '@mysten/sui.js/dist/cjs/builder';
+import { ModelConfig } from '@msafe/sui3-model/common';
+import { SignatureWithBytes } from '@mysten/sui.js/src/cryptography/keypair';
+import { TransactionBlock } from '@mysten/sui.js/transactions';
+import * as _mysten_sui_js_dist_cjs_client from '@mysten/sui.js/dist/cjs/client';
+import { Ed25519PublicKey } from '@mysten/sui.js/keypairs/ed25519';
+import { MultiSigPublicKey } from '@mysten/sui.js/multisig';
+
+interface IntentionCoinTransfer {
+    txType: 'CoinTransfer';
+    recipient: string;
+    coinType: string;
+    amount: string;
+}
+
+interface IntentionObjectTransfer {
+    txType: 'ObjectTransfer';
+    receiver: string;
+    objectId: string;
+    objectType: string;
+}
+
+type TxIntention = IntentionObjectTransfer | IntentionCoinTransfer;
+declare class IntentionHelper {
+    static ser(intention: TxIntention): string;
+    static de(val: string): TxIntention;
+    static buildTxb(input: {
+        suiClient: SuiClient;
+        intention: TxIntention;
+        sender: string;
+    }): Promise<_mysten_sui_js_dist_cjs_builder.TransactionBlock>;
+    static getTxType(intention: TxIntention): {
+        txType: string;
+        txSubType: string;
+    };
+    static buildRejectTransaction(input: {
+        msafeAddress: string;
+        payloadToReject: string;
+    }): Promise<_mysten_sui_js_dist_cjs_builder.TransactionBlock>;
+}
+
+interface MSafeAccountInfo {
+    address: string;
+    ownersWithWeightPK: OwnerWithWeightPK[];
+    threshold: number;
+    name: string;
+    description?: string;
+    creationNonce: number;
+}
+type OwnerWithWeightPK = OwnerWithWeight & {
+    publicKey: PublicKey;
+};
+interface OwnerWithWeight {
+    address: string;
+    weight: number;
+}
+interface PendingTx {
+    digest: string;
+    payload: string;
+    msafeAddress: string;
+    isRejectTx: boolean;
+    intention?: TxIntention;
+    creator: string;
+    createdAt: Date;
+    sequenceNumber: number;
+    votes: PendingVote[];
+}
+interface PendingVote {
+    userAddress: string;
+    signature: string;
+    timestamp: Date;
+}
+interface HistorySendTx {
+    digest: string;
+    payload: string;
+    msafeAddress: string;
+    sequenceNumber: number;
+    isRejectTx: boolean;
+    status: string;
+    creator: string;
+    createdAt: Date;
+    votes: HistoryVote[];
+}
+interface ReceiveTransaction {
+    digest: string;
+    payload: string;
+    txType: string;
+    txSubType: string;
+    timestamp: Date;
+}
+interface HistoryVote {
+    userAddress: string;
+    timestamp: Date;
+}
+interface FutureIntention {
+    intention: TxIntention;
+    sequenceNumber: number;
+    msafeAddress: string;
+    creator: string;
+    txType: string;
+    txSubType: string;
+    rawData: string;
+    status: string;
+    statusRemark?: string;
+    createdAt: Date;
+}
+
+type JWTToken = string;
+interface CreateMSafeParams {
+    ownerWithWeight: OwnerWithWeightPK[];
+    threshold: number;
+    name: string;
+    description?: string;
+    creationNonce: number;
+    signature: SerializedSignature;
+}
+interface UserWithOwnedMSafe {
+    address: string;
+    publicKey: string;
+    schema: string;
+    creationNonce: number;
+    ownedMSafe: MSafeAccountInfo[];
+}
+
+interface IBackend {
+    isJWTTokenValid(jwt: JWTToken): Promise<boolean>;
+    authSign(input: {
+        address: string;
+        message: string;
+        signature: SerializedSignature;
+        walletType: string;
+    }): Promise<JWTToken>;
+    setJWTToken(token: JWTToken): void;
+    getPublicKey(address: string): Promise<PublicKey$1 | undefined>;
+    getPublicKeyBatch(addresses: string[]): Promise<(PublicKey$1 | undefined)[]>;
+    getMSafeAccountInfo(msafeAddress: string): Promise<MSafeAccountInfo>;
+    getUserInfo(userAddress: string): Promise<UserWithOwnedMSafe>;
+    getPendingTransactions(msafeAddress: string): Promise<PendingTx[]>;
+    getHistoryTransactions(msafeAddress: string): Promise<HistorySendTx[]>;
+    getFutureIntentions(msafeAddress: string): Promise<FutureIntention[]>;
+    getCurrentSequenceNumber(msafeAddress: string): Promise<number>;
+    getNextSequenceNumber(msafeAddress: string): Promise<number>;
+    createMSafeAccount(input: CreateMSafeParams): Promise<void>;
+    proposeIntention(input: {
+        intention: TxIntention;
+        sequenceNumber: number;
+        userAddress: string;
+        msafeAddress: string;
+        signature: SerializedSignature;
+    }): Promise<void>;
+    proposePendingTransaction(input: {
+        intention: TxIntention;
+        userAddress: string;
+        msafeAddress: string;
+        digest: string;
+        signature: SerializedSignature;
+    }): Promise<void>;
+    rejectCurrentTx(input: {
+        userAddress: string;
+        msafeAddress: string;
+        digest: string;
+        signature: SerializedSignature;
+    }): Promise<void>;
+    voteForTransaction(input: {
+        txDigest: string;
+        msafeAddress: string;
+        userAddress: string;
+        signature: SerializedSignature;
+    }): Promise<void>;
+    buildNextIntentionAndAddToPending(input: {
+        msafeAddress: string;
+    }): Promise<void>;
+    skipNextFailedIntention(input: {
+        msafeAddress: string;
+        userAddress: string;
+    }): Promise<void>;
+    processExecutedTransaction(digest: string): Promise<void>;
+}
+
+declare enum MSafeEnv {
+    local = "local",
+    unit = "unit",
+    dev = "dev",
+    prev = "prev",
+    prod = "prod"
+}
+interface MSafeConfig {
+    suiClient: {
+        url: string;
+    };
+    backend: DBConfig;
+}
+interface MSafeConfigOptions {
+    suiClient?: {
+        url?: string;
+    };
+    backend?: DBConfig;
+}
+type DBConfig = ModelConfig;
+declare const LOCAL_DATABASE_CONFIG: DBConfig;
+declare const DEV_DATABASE_CONFIG: DBConfig;
+declare const TESTNET_RPC_URL = "https://sui-testnet.blockvision.org/v1/2Sgk89ivT64MnKdcGzjmyjY2ndD";
+declare const MAINNET_RPC_URL = "https://sui-mainnet.blockvision.org/v1/2Sgk7NPvqkd7mESYkxF01yX15l7";
+declare const ENV_CONFIGS: Map<MSafeEnv, MSafeConfig>;
+declare function getMSafeConfig(env: MSafeEnv, options?: MSafeConfigOptions): MSafeConfig;
+declare const AUTH_SIGN_MESSAGE = "Welcome to MSafe";
+
+interface IWallet {
+    walletType: string;
+    address(): Promise<string>;
+    signPersonalMessage(input: {
+        messageStr: string;
+    }): Promise<SignatureWithBytes>;
+    signTransactionBlock(input: {
+        transactionBlock: TransactionBlock | Uint8Array;
+    }): Promise<SignatureWithBytes>;
+    signAndExecuteTransactionBlock(input: {
+        transactionBlock: TransactionBlock;
+        requestType?: ExecuteTransactionRequestType;
+        options?: SuiTransactionBlockResponseOptions;
+    }): Promise<SuiTransactionBlockResponse>;
+}
+
+declare class MSafeGlobals {
+    readonly backend: IBackend;
+    readonly suiClient: SuiClient;
+    readonly config: MSafeConfig;
+    _wallet: IWallet | undefined;
+    constructor(input: {
+        backend: IBackend;
+        suiClient: SuiClient;
+        config: MSafeConfig;
+    });
+    static New(env: MSafeEnv, options?: MSafeConfigOptions): Promise<MSafeGlobals>;
+    connectWallet(wallet: IWallet): void;
+    get wallet(): IWallet;
+    set wallet(val: IWallet);
+}
+
+/**
+ * PublicKeyHelper is the helper to query for public keys from
+ * backend and blockchain.
+ */
+declare class PublicKeyHelper {
+    readonly globals: MSafeGlobals;
+    private knownPublicKeys;
+    constructor(globals: MSafeGlobals);
+    getPublicKey(address: string): Promise<PublicKey | undefined>;
+    getPublicKeyBatch(addresses: string[]): Promise<(PublicKey | undefined)[]>;
+    private _getPublicKey;
+    private getPublicKeyFromBackend;
+    private getPublicKeyFromChain;
+}
+
+interface CreateMSafeAccountInfo {
+    ownerWithWeight: {
+        address: string;
+        weight: number;
+    }[];
+    threshold: number;
+    name: string;
+    description?: string;
+    creationNonce: number;
+}
+interface CreatePermissionInfo {
+    ownerWithWeight: {
+        address: string;
+        weight: number;
+    }[];
+    threshold: number;
+    creationNonce: number;
+}
+
+declare class CreateHelper {
+    readonly globals: MSafeGlobals;
+    readonly pkHelper: PublicKeyHelper;
+    constructor(globals: MSafeGlobals, pkHelper: PublicKeyHelper);
+    getPublicKeyBatch(addresses: string[]): Promise<(_mysten_sui_js_src_cryptography.PublicKey | undefined)[]>;
+    calculateMSafeAddress(info: CreatePermissionInfo): Promise<string>;
+    validateCreateInfo(createInfo: CreateMSafeAccountInfo): Promise<string>;
+    submitMSafeCreation(creationInfo: CreateMSafeAccountInfo): Promise<string>;
+    private reduceCreationInfoToRawConfig;
+    private submitToBackend;
+}
+
+declare class MessageHelper {
+    static createMSafeMessage(msafeAddress: string): string;
+    static deCreateMSafeMessage(msg: string): string | undefined;
+    static welcomeMessage(timestamp: string): string;
+    static deWelcomeMessage(msg: string): string | undefined;
+    static proposeIntentionMessage(data: ProposeIntentionData): string;
+    static deProposeIntentionMessage(s: string): ProposeIntentionData;
+}
+interface ProposeIntentionData {
+    intention: TxIntention;
+    sn: number;
+}
+
+interface PublicKeyWithWeight {
+    publicKey: PublicKey$1;
+    weight: number;
+}
+interface MultiSigConfig {
+    threshold: number;
+    ownerWithWeight: PublicKeyWithWeight[];
+    creationNonce: number | undefined;
+}
+declare const NONCE_PK_PREFIX = "maven";
+declare const NONCE_PREFIX_MAX_SIZE = 16;
+declare const NONCE_PK_WEIGHT = 1;
+declare const MAX_WEIGHT = 255;
+declare const MIN_WEIGHT = 1;
+declare const MAX_OWNER_WITH_NONCE = 9;
+declare const MAX_OWNER_WITHOUT_NONCE = 10;
+declare const MIN_THRESHOLD = 1;
+declare class RawMultiSig {
+    readonly config: MultiSigConfig;
+    rawMsPK: MultiSigPublicKey;
+    constructor(config: MultiSigConfig);
+    static fromMSafeAccountInfo(info: MSafeAccountInfo): RawMultiSig;
+    get suiAddress(): string;
+    get publicKeys(): PublicKeyWithWeight[];
+    get threshold(): number;
+    combinePartialSignatures(signatures: SerializedSignature[]): SerializedSignature;
+    verifyPersonalMessage(messageStr: string, multiSigSignature: SerializedSignature): Promise<boolean>;
+}
+declare function getMultiSigPublicKey(config: MultiSigConfig): MultiSigPublicKey;
+declare function makeNoncePublicKey(nonce: number): Ed25519PublicKey;
+declare function validateMultiSigConfig(config: MultiSigConfig): void;
+
+declare class MSafeAccount {
+    readonly globals: MSafeGlobals;
+    readonly info: MSafeAccountInfo;
+    rawMultiSig: RawMultiSig;
+    constructor(globals: MSafeGlobals, info: MSafeAccountInfo);
+    static new(globals: MSafeGlobals, address: string): Promise<MSafeAccount>;
+    pendingTransactions(): Promise<PendingTx[]>;
+    historyTransaction(): Promise<HistorySendTx[]>;
+    futureIntentions(): Promise<FutureIntention[]>;
+    currentSequenceNumber(): Promise<number>;
+    nextSequenceNumber(): Promise<number>;
+    proposeIntention(intention: TxIntention, sequenceNumber: number): Promise<void>;
+    voteForTransaction(digest: string, payload: string): Promise<void>;
+    proposePendingTransaction(intention: TxIntention): Promise<void>;
+    rejectCurrentTx(pending?: PendingTx): Promise<void>;
+    buildNextIntentionAndAddToPending(): Promise<void>;
+    skipNextFailedIntention(): Promise<void>;
+    executePendingTx(pending: PendingTx): Promise<_mysten_sui_js_dist_cjs_client.SuiTransactionBlockResponse>;
+    get address(): string;
+    private get backend();
+    private get wallet();
+    private userAddress;
+    private get suiClient();
+}
+
+declare class MSafeClient {
+    readonly globals: MSafeGlobals;
+    private _creationHelper;
+    private _publicKeyHelper;
+    constructor(globals: MSafeGlobals);
+    static New(env: MSafeEnv, options?: MSafeConfigOptions): Promise<MSafeClient>;
+    connectWallet(input: {
+        wallet: IWallet;
+        jwtToken?: JWTToken;
+    }): Promise<JWTToken>;
+    userInfo(): Promise<UserWithOwnedMSafe>;
+    createAccount(info: CreateMSafeAccountInfo): Promise<string>;
+    getMSafeAccount(info: MSafeAccountInfo): MSafeAccount;
+    getMSafeAccountFromAddress(msafeAddress: string): Promise<MSafeAccount>;
+    get creationHelper(): CreateHelper;
+    get publicKeyHelper(): PublicKeyHelper;
+    get config(): MSafeConfig;
+    get backend(): IBackend;
+    get wallet(): IWallet;
+    private walletAddress;
+}
+
+declare function stringToBuffer(s: string): Buffer;
+declare function Uint8ArrayToHex(b: Uint8Array): string;
+declare function HexToUint8Array(hex: string): Uint8Array;
+
+declare class SignatureVerifier {
+    static getPublicKeyFromSignature(input: {
+        message: Uint8Array;
+        messageType: 'TransactionBlock' | 'Personal';
+        signature: SerializedSignature;
+    }): Promise<PublicKey$1>;
+    static getPublicKeyFromPersonalSignature(input: {
+        messageStr: string;
+        signature: SerializedSignature;
+    }): Promise<PublicKey$1>;
+    static verifySignature(input: {
+        message: Uint8Array;
+        messageType: 'TransactionBlock' | 'Personal';
+        signature: SerializedSignature;
+        targetAddress: string;
+    }): Promise<boolean>;
+    static verifyPersonalSignature(input: {
+        messageStr: string;
+        signature: SerializedSignature;
+        targetAddress: string;
+    }): Promise<boolean>;
+    static verifyTransactionSignature(input: {
+        payload: Uint8Array;
+        signature: SerializedSignature;
+        targetAddress: string;
+    }): Promise<boolean>;
+}
+declare class PublicKeySerde {
+    static ser(publicKey: PublicKey$1): {
+        publicKey: string;
+        scheme: "ED25519" | "Secp256r1" | "Secp256k1" | "MultiSig" | "ZkLogin";
+    };
+    static de(input: {
+        publicKey: string | Uint8Array;
+        scheme: SignatureScheme;
+    }): PublicKey$1;
+}
+
+declare class Formatter {
+    static normalizeSuiAddress(addr: string): string;
+    static normalizeStructTag(struct: string): string;
+    static isSuiAddressEqual(addr1: string, addr2: string): boolean;
+    static isSuiStructEqual(struct1: string, struct2: string): boolean;
+    static isCoinObjectType(struct: string): boolean;
+}
+
+declare const SUI_COIN = "0x2::sui::SUI";
+declare function getPublicKeyFromChain(suiClient: SuiClient, address: string): Promise<PublicKey$1 | undefined>;
+declare function getAllCoins(input: {
+    suiClient: SuiClient;
+    owner: string;
+    coinType: string | undefined;
+}): Promise<CoinStruct[]>;
+
+declare class CoinHelper {
+    private _client;
+    private _coinMetaReg;
+    constructor(client: SuiClient);
+    getCoinMeta(coinType: string): Promise<CoinMetadata | undefined>;
+    private queryCoinMeta;
+}
+declare const COIN_TYPE_ARG_REGEX: RegExp;
+declare class Coin {
+    static isCoin(type: string | undefined | null): boolean;
+    static getCoinType(type: string): string | null;
+    static getBalance(data: SuiObjectData): bigint | undefined;
+}
+
+export { AUTH_SIGN_MESSAGE, COIN_TYPE_ARG_REGEX, Coin, CoinHelper, CreateHelper, type CreateMSafeAccountInfo, type CreatePermissionInfo, type DBConfig, DEV_DATABASE_CONFIG, ENV_CONFIGS, Formatter, type FutureIntention, HexToUint8Array, type HistorySendTx, type HistoryVote, type IWallet, IntentionHelper, LOCAL_DATABASE_CONFIG, MAINNET_RPC_URL, MAX_OWNER_WITHOUT_NONCE, MAX_OWNER_WITH_NONCE, MAX_WEIGHT, MIN_THRESHOLD, MIN_WEIGHT, MSafeAccount, type MSafeAccountInfo, MSafeClient, type MSafeConfig, type MSafeConfigOptions, MSafeEnv, MSafeGlobals, MessageHelper, type MultiSigConfig, NONCE_PK_PREFIX, NONCE_PK_WEIGHT, NONCE_PREFIX_MAX_SIZE, type OwnerWithWeight, type OwnerWithWeightPK, type PendingTx, type PendingVote, PublicKeySerde, type PublicKeyWithWeight, RawMultiSig, type ReceiveTransaction, SUI_COIN, SignatureVerifier, TESTNET_RPC_URL, type TxIntention, Uint8ArrayToHex, getAllCoins, getMSafeConfig, getMultiSigPublicKey, getPublicKeyFromChain, makeNoncePublicKey, stringToBuffer, validateMultiSigConfig };