@0xobelisk/sui-client 0.5.18 → 0.5.19

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 type { SuiMoveNormalizedModules } from '@mysten/sui/client';
+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 type { SuiMoveNormalizedModules, SuiMoveNormalizedType } from '@mysten/sui/client';
+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 = {
+    moduleName: string;
+    funcName: string;
+    visibility: 'Private' | 'Public' | 'Friend';
+    isEntry: boolean;
+    typeParameters: {
+        abilities: string[];
+    }[];
+    parameters: SuiMoveNormalizedType[];
+    return: SuiMoveNormalizedType[];
+};

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

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

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

@@ -0,0 +1,50 @@
+import { SuiClient } from '@mysten/sui/client';
+import type { SuiTransactionBlockResponse, SuiObjectDataOptions, SuiObjectData } from '@mysten/sui/client';
+import type * as RpcTypes from '@mysten/sui/dist/cjs/client/types/generated';
+import { FaucetNetworkType, NetworkType } from '../../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 clients: SuiClient[];
+    currentClient: SuiClient;
+    readonly fullNodes: string[];
+    currentFullNode: string;
+    network?: NetworkType;
+    constructor(fullNodeUrls: string[], network?: NetworkType);
+    switchToNextClient(): void;
+    sendTx(transactionBlock: Uint8Array | string, signature: string | string[]): Promise<SuiTransactionBlockResponse>;
+    getObjects(ids: string[], options?: SuiObjectDataOptions): Promise<SuiObjectData[]>;
+    getObject(id: string): Promise<SuiObjectData>;
+    getDynamicFieldObject(parentId: string, name: RpcTypes.DynamicFieldName): Promise<RpcTypes.SuiObjectResponse>;
+    getDynamicFields(parentId: string, cursor?: string, limit?: number): Promise<import("@mysten/sui/client").DynamicFieldPage>;
+    getTxDetails(digest: string): Promise<SuiTransactionBlockResponse>;
+    getOwnedObjects(owner: string, cursor?: string, limit?: number): Promise<RpcTypes.PaginatedObjectsResponse>;
+    getNormalizedMoveModulesByPackage(packageId: string): Promise<import("@mysten/sui/client").SuiMoveNormalizedModules>;
+    /**
+     * @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;
+    }[]>;
+    /**
+     * @description Select owned objects with objectType.
+     * @param addr the address of the owner
+     * @param objectType the coin type, default is '0x2::SUI::SUI'
+     */
+    selectObjects(addr: string, objectType: string): Promise<SuiObjectData[]>;
+    requestFaucet(address: string, 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 type { SuiTransactionBlockResponse } from '@mysten/sui/client';
+import type { CallArg } from '@mysten/sui/transactions';
+export declare class SuiOwnedObject {
+    readonly objectId: string;
+    version?: 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(): CallArg | string;
+    /**
+     * 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,11 @@
+import type { CallArg } from '@mysten/sui/transactions';
+export declare class SuiSharedObject {
+    readonly objectId: string;
+    initialSharedVersion?: string;
+    constructor(param: {
+        objectId: string;
+        initialSharedVersion?: string;
+        mutable?: boolean;
+    });
+    asCallArg(mutable?: boolean): CallArg | string;
+}