@0xobelisk/client 0.3.4 → 0.3.6

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from '@mysten/sui.js';
+export { Ed25519Keypair } from '@mysten/sui.js/keypairs/ed25519';
+export * from '@mysten/bcs';
+export { Obelisk } from './obelisk';
+export { SuiAccountManager } from './libs/suiAccountManager';
+export { SuiTxBlock } from './libs/suiTxBuilder';
+export { SuiContractFactory } from './libs/suiContractFactory';
+export { getMetadata } from './metadata';
+export type * from './types';

package/dist/libs/suiAccountManager/crypto.d.ts

@@ -0,0 +1 @@
+export declare const generateMnemonic: (numberOfWords?: 12 | 24) => string;

package/dist/libs/suiAccountManager/index.d.ts

@@ -0,0 +1,35 @@
+import { Ed25519Keypair } from '@mysten/sui.js';
+import type { AccountMangerParams, DerivePathParams } from 'src/types';
+export declare class SuiAccountManager {
+    private mnemonics;
+    private secretKey;
+    currentKeyPair: Ed25519Keypair;
+    currentAddress: string;
+    /**
+     * Support the following ways to init the SuiToolkit:
+     * 1. mnemonics
+     * 2. secretKey (base64 or hex)
+     * If none of them is provided, will generate a random mnemonics with 24 words.
+     *
+     * @param mnemonics, 12 or 24 mnemonics words, separated by space
+     * @param secretKey, base64 or hex string, when mnemonics is provided, secretKey will be ignored
+     */
+    constructor({ mnemonics, secretKey }?: AccountMangerParams);
+    /**
+     * if derivePathParams is not provided or mnemonics is empty, it will return the currentKeyPair.
+     * else:
+     * it will generate keyPair from the mnemonic with the given derivePathParams.
+     */
+    getKeyPair(derivePathParams?: DerivePathParams): Ed25519Keypair;
+    /**
+     * if derivePathParams is not provided or mnemonics is empty, it will return the currentAddress.
+     * else:
+     * it will generate address from the mnemonic with the given derivePathParams.
+     */
+    getAddress(derivePathParams?: DerivePathParams): string;
+    /**
+     * Switch the current account with the given derivePathParams.
+     * This is only useful when the mnemonics is provided. For secretKey mode, it will always use the same account.
+     */
+    switchAccount(derivePathParams: DerivePathParams): void;
+}

package/dist/libs/suiAccountManager/keypair.d.ts

@@ -0,0 +1,21 @@
+import { Ed25519Keypair } from '@mysten/sui.js';
+import type { DerivePathParams } from 'src/types';
+/**
+ * @description Get ed25519 derive path for SUI
+ * @param derivePathParams
+ */
+export declare const getDerivePathForSUI: (derivePathParams?: DerivePathParams) => string;
+/**
+ * the format is m/44'/784'/accountIndex'/${isExternal ? 1 : 0}'/addressIndex'
+ *
+ * accountIndex is the index of the account, default is 0.
+ *
+ * isExternal is the type of the address, default is false. Usually, the external address is used to receive coins. The internal address is used to change coins.
+ *
+ * addressIndex is the index of the address, default is 0. It's used to generate multiple addresses for one account.
+ *
+ * @description Get keypair from mnemonics and derive path
+ * @param mnemonics
+ * @param derivePathParams
+ */
+export declare const getKeyPair: (mnemonics: string, derivePathParams?: DerivePathParams) => Ed25519Keypair;

package/dist/libs/suiAccountManager/util.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @description This regular expression matches any string that contains only hexadecimal digits (0-9, A-F, a-f).
+ * @param str
+ */
+export declare const isHex: (str: string) => boolean;
+/**
+ * @description This regular expression matches any string that contains only base64 digits (0-9, A-Z, a-z, +, /, =).
+ * Note that the "=" signs at the end are optional padding characters that may be present in some base64 encoded strings.
+ * @param str
+ */
+export declare const isBase64: (str: string) => boolean;
+/**
+ * Convert a hex string to Uint8Array
+ * @param hexStr
+ */
+export declare const fromHEX: (hexStr: string) => Uint8Array;
+/**
+ * @description Convert a hex or base64 string to Uint8Array
+ */
+export declare const hexOrBase64ToUint8Array: (str: string) => Uint8Array;
+/**
+ * normalize a private key
+ * A private key is a 32-byte array.
+ * But there are two different formats for private keys:
+ * 1. A 32-byte array
+ * 2. A 64-byte array with the first 32 bytes being the private key and the last 32 bytes being the public key
+ * 3. A 33-byte array with the first byte being 0x00 (sui.keystore key is a Base64 string with scheme flag 0x00 at the beginning)
+ */
+export declare const normalizePrivateKey: (key: Uint8Array) => Uint8Array;

package/dist/libs/suiContractFactory/index.d.ts

@@ -0,0 +1,20 @@
+import { SuiMoveNormalizedModules } from '@mysten/sui.js';
+import type { ContractFactoryParams } from './types';
+export type ApiTypes = 'promise' | 'rxjs';
+export declare class SuiContractFactory {
+    packageId: string;
+    metadata: SuiMoveNormalizedModules | undefined;
+    /**
+     * Support the following ways to init the SuiToolkit:
+     * 1. mnemonics
+     * 2. secretKey (base64 or hex)
+     * If none of them is provided, will generate a random mnemonics with 24 words.
+     *
+     * @param mnemonics, 12 or 24 mnemonics words, separated by space
+     * @param secretKey, base64 or hex string, when mnemonics is provided, secretKey will be ignored
+     */
+    constructor({ packageId, metadata }?: ContractFactoryParams);
+    getFuncByModuleName(moduleName: string): void;
+    getAllFunc(): void;
+    getAllModule(): void;
+}

package/dist/libs/suiContractFactory/types.d.ts

@@ -0,0 +1,49 @@
+import { SuiMoveNormalizedModules, SuiMoveNormalizedType } from "@mysten/sui.js";
+export type ContractFactoryParams = {
+    packageId?: string;
+    metadata?: SuiMoveNormalizedModules;
+};
+export type SuiMoveMoudleValueType = {
+    address: string;
+    name: string;
+    fileFormatVersion: number;
+    friends: {
+        address: string;
+        name: string;
+    }[];
+    structs: Record<string, {
+        fields: {
+            type: SuiMoveNormalizedType;
+            name: string;
+        }[];
+        abilities: {
+            abilities: string[];
+        };
+        typeParameters: {
+            constraints: {
+                abilities: string[];
+            };
+            isPhantom: boolean;
+        }[];
+    }>;
+    exposedFunctions: Record<string, {
+        visibility: "Private" | "Public" | "Friend";
+        isEntry: boolean;
+        typeParameters: {
+            abilities: string[];
+        }[];
+        parameters: SuiMoveNormalizedType[];
+        return: SuiMoveNormalizedType[];
+    }>;
+};
+export type SuiMoveMoudleFuncType = {
+    moudleName: string;
+    funcName: string;
+    visibility: "Private" | "Public" | "Friend";
+    isEntry: boolean;
+    typeParameters: {
+        abilities: string[];
+    }[];
+    parameters: SuiMoveNormalizedType[];
+    return: SuiMoveNormalizedType[];
+};

package/dist/libs/suiInteractor/defaultConfig.d.ts

@@ -0,0 +1,10 @@
+import type { Connection } from '@mysten/sui.js';
+import type { NetworkType } from 'src/types';
+export declare const defaultGasBudget: number;
+export declare const defaultGasPrice = 1000;
+/**
+ * @description Get the default fullnode url and faucet url for the given network type
+ * @param networkType, 'testnet' | 'mainnet' | 'devnet' | 'localnet', default is 'devnet'
+ * @returns { fullNode: string, websocket: string, faucet?: string }
+ */
+export declare const getDefaultConnection: (networkType?: NetworkType) => Connection;

package/dist/libs/suiInteractor/index.d.ts

@@ -0,0 +1,2 @@
+export { SuiInteractor } from './suiInteractor';
+export { getDefaultConnection } from './defaultConfig';

package/dist/libs/suiInteractor/suiInteractor.d.ts

@@ -0,0 +1,205 @@
+import { SuiTransactionBlockResponse, JsonRpcProvider, DynamicFieldName, SuiAddress } from '@mysten/sui.js';
+import { FaucetNetworkType, NetworkType, ObjectData, EntityData } from 'src/types';
+import { SuiOwnedObject, SuiSharedObject } from '../suiModel';
+/**
+ * `SuiTransactionSender` is used to send transaction with a given gas coin.
+ * It always uses the gas coin to pay for the gas,
+ * and update the gas coin after the transaction.
+ */
+export declare class SuiInteractor {
+    readonly providers: JsonRpcProvider[];
+    currentProvider: JsonRpcProvider;
+    network?: NetworkType;
+    constructor(fullNodeUrls: string[], network?: NetworkType);
+    switchToNextProvider(): void;
+    sendTx(transactionBlock: Uint8Array | string, signature: string | string[]): Promise<SuiTransactionBlockResponse>;
+    getObjects(ids: string[]): Promise<ObjectData[]>;
+    getObject(id: string): Promise<ObjectData>;
+    getEntitiesObjects(ids: string[]): Promise<EntityData[]>;
+    getDynamicFieldObject(parentId: string, name: string | DynamicFieldName): Promise<{
+        data?: {
+            objectId: string;
+            version: string;
+            digest: string;
+            type?: string | null | undefined;
+            bcs?: {
+                type: string;
+                version: string;
+                hasPublicTransfer: boolean;
+                dataType: "moveObject";
+                bcsBytes: string;
+            } | {
+                id: string;
+                dataType: "package";
+                moduleMap: Record<string, string>;
+            } | null | undefined;
+            owner?: {
+                AddressOwner: string;
+            } | {
+                ObjectOwner: string;
+            } | {
+                Shared: {
+                    initial_shared_version: string | null;
+                };
+            } | "Immutable" | null | undefined;
+            storageRebate?: string | null | undefined;
+            previousTransaction?: string | null | undefined;
+            content?: {
+                type: string;
+                fields: Record<string, any>;
+                hasPublicTransfer: boolean;
+                dataType: "moveObject";
+            } | {
+                disassembled: Record<string, unknown>;
+                dataType: "package";
+            } | null | undefined;
+            display?: Record<string, string> | {
+                data?: Record<string, string> | null | undefined;
+                error?: {
+                    code: string;
+                    version?: string | undefined;
+                    digest?: string | undefined;
+                    error?: string | undefined;
+                    object_id?: string | undefined;
+                    parent_object_id?: string | undefined;
+                } | null | undefined;
+            } | null | undefined;
+        } | null | undefined;
+        error?: {
+            code: string;
+            version?: string | undefined;
+            digest?: string | undefined;
+            error?: string | undefined;
+            object_id?: string | undefined;
+            parent_object_id?: string | undefined;
+        } | null | undefined;
+    }>;
+    getDynamicFields(parentId: string, cursor?: string, limit?: number): Promise<{
+        data: {
+            type: "DynamicField" | "DynamicObject";
+            objectType: string;
+            objectId: string;
+            version: number;
+            digest: string;
+            name: {
+                type: string;
+                value?: any;
+            };
+            bcsName: string;
+        }[];
+        nextCursor: string | null;
+        hasNextPage: boolean;
+    }>;
+    getOwnedObjects(owner: SuiAddress, cursor?: string, limit?: number): Promise<{
+        data: {
+            data?: {
+                objectId: string;
+                version: string;
+                digest: string;
+                type?: string | null | undefined;
+                bcs?: {
+                    type: string;
+                    version: string;
+                    hasPublicTransfer: boolean;
+                    dataType: "moveObject";
+                    bcsBytes: string;
+                } | {
+                    id: string;
+                    dataType: "package";
+                    moduleMap: Record<string, string>;
+                } | null | undefined;
+                owner?: "Immutable" | {
+                    AddressOwner: string;
+                } | {
+                    ObjectOwner: string;
+                } | {
+                    Shared: {
+                        initial_shared_version: string | null;
+                    };
+                } | null | undefined;
+                storageRebate?: string | null | undefined;
+                previousTransaction?: string | null | undefined;
+                content?: {
+                    type: string;
+                    fields: Record<string, any>;
+                    hasPublicTransfer: boolean;
+                    dataType: "moveObject";
+                } | {
+                    disassembled: Record<string, unknown>;
+                    dataType: "package";
+                } | null | undefined;
+                display?: Record<string, string> | {
+                    data?: Record<string, string> | null | undefined;
+                    error?: {
+                        code: string;
+                        version?: string | undefined;
+                        digest?: string | undefined;
+                        error?: string | undefined;
+                        object_id?: string | undefined;
+                        parent_object_id?: string | undefined;
+                    } | null | undefined;
+                } | null | undefined;
+            } | null | undefined;
+            error?: {
+                code: string;
+                version?: string | undefined;
+                digest?: string | undefined;
+                error?: string | undefined;
+                object_id?: string | undefined;
+                parent_object_id?: string | undefined;
+            } | null | undefined;
+        }[];
+        hasNextPage: boolean;
+        nextCursor?: string | null | undefined;
+    }>;
+    getNormalizedMoveModulesByPackage(packageId: string): Promise<Record<string, {
+        address: string;
+        name: string;
+        fileFormatVersion: number;
+        friends: {
+            address: string;
+            name: string;
+        }[];
+        structs: Record<string, {
+            fields: {
+                type: import("@mysten/sui.js").SuiMoveNormalizedType;
+                name: string;
+            }[];
+            abilities: {
+                abilities: string[];
+            };
+            typeParameters: {
+                constraints: {
+                    abilities: string[];
+                };
+                isPhantom: boolean;
+            }[];
+        }>;
+        exposedFunctions: Record<string, {
+            visibility: "Private" | "Public" | "Friend";
+            isEntry: boolean;
+            typeParameters: {
+                abilities: string[];
+            }[];
+            parameters: import("@mysten/sui.js").SuiMoveNormalizedType[];
+            return: import("@mysten/sui.js").SuiMoveNormalizedType[];
+        }>;
+    }>>;
+    /**
+     * @description Update objects in a batch
+     * @param suiObjects
+     */
+    updateObjects(suiObjects: (SuiOwnedObject | SuiSharedObject)[]): Promise<void>;
+    /**
+     * @description Select coins that add up to the given amount.
+     * @param addr the address of the owner
+     * @param amount the amount that is needed for the coin
+     * @param coinType the coin type, default is '0x2::SUI::SUI'
+     */
+    selectCoins(addr: string, amount: number, coinType?: string): Promise<{
+        objectId: string;
+        digest: string;
+        version: string;
+    }[]>;
+    requestFaucet(address: SuiAddress, network: FaucetNetworkType): Promise<void>;
+}

package/dist/libs/suiInteractor/util.d.ts

@@ -0,0 +1 @@
+export declare const delay: (ms: number) => Promise<unknown>;

package/dist/libs/suiModel/index.d.ts

@@ -0,0 +1,2 @@
+export { SuiOwnedObject } from './suiOwnedObject';
+export { SuiSharedObject } from './suiSharedObject';

package/dist/libs/suiModel/suiOwnedObject.d.ts

@@ -0,0 +1,24 @@
+import { Infer } from 'superstruct';
+import { SuiTransactionBlockResponse, ObjectCallArg, ObjectId } from '@mysten/sui.js';
+export declare class SuiOwnedObject {
+    readonly objectId: string;
+    version?: number | string;
+    digest?: string;
+    constructor(param: {
+        objectId: string;
+        version?: string;
+        digest?: string;
+    });
+    /**
+     * Check if the object is fully initialized.
+     * So that when it's used as an input, it won't be necessary to fetch from fullnode again.
+     * Which can save time when sending transactions.
+     */
+    isFullObject(): boolean;
+    asCallArg(): Infer<typeof ObjectCallArg> | Infer<typeof ObjectId>;
+    /**
+     * Update object version & digest based on the transaction response.
+     * @param txResponse
+     */
+    updateFromTxResponse(txResponse: SuiTransactionBlockResponse): void;
+}

package/dist/libs/suiModel/suiSharedObject.d.ts

@@ -0,0 +1,12 @@
+import { Infer } from 'superstruct';
+import { ObjectCallArg, ObjectId } from '@mysten/sui.js';
+export declare class SuiSharedObject {
+    readonly objectId: string;
+    initialSharedVersion?: number | string;
+    constructor(param: {
+        objectId: string;
+        initialSharedVersion?: number;
+        mutable?: boolean;
+    });
+    asCallArg(mutable?: boolean): Infer<typeof ObjectCallArg> | Infer<typeof ObjectId>;
+}