@0xobelisk/sui-client 1.2.0-pre.12 → 1.2.0-pre.120

package/README.md

@@ -25,10 +25,10 @@ export const dubheConfig = {
   schemas: {
     counter: {
       structure: {
-        value: 'StorageValue<u32>',
-      },
-    },
-  },
+        value: 'StorageValue<u32>'
+      }
+    }
+  }
 } as DubheConfig;
 ```
 
@@ -55,7 +55,7 @@ const dubhe = new Dubhe({
   networkType: network,
   packageId: packageId,
   metadata: metadata,
-  secretKey: privkey,
+  secretKey: privkey
 });
 ```
 
@@ -68,7 +68,7 @@ const dubhe = new Dubhe({
   networkType: network,
   packageId: packageId,
   metadata: metadata,
-  secretKey: privkey,
+  secretKey: privkey
 });
 ```
 
@@ -166,8 +166,7 @@ const numberKey = await dubhe.entity_key_from_u256(123);
 To query objects owned by a specific address:
 
 ```typescript
-const owner =
-  '0xfa99b5b0463fcfb7d0203c701a76da5eda21a96190eb1368ab36a437cc89195e';
+const owner = '0xfa99b5b0463fcfb7d0203c701a76da5eda21a96190eb1368ab36a437cc89195e';
 const ownedObjects = await dubhe.getOwnedObjects(owner);
 ```
 

package/dist/dubhe.d.ts

@@ -7,9 +7,8 @@ import { MapObjectStruct } from './types';
 import { SuiContractFactory } from './libs/suiContractFactory';
 import { SuiMoveMoudleFuncType } from './libs/suiContractFactory/types';
 import { NetworkConfig } from './libs/suiInteractor';
-import { DerivePathParams, FaucetNetworkType, MapMoudleFuncQuery, MapMoudleFuncTx, DubheParams, SuiTxArg, SuiObjectArg, SuiVecTxArg, SubscribableType, IndexerTransactionResult } from './types';
-import { ConnectionResponse, IndexerTransaction, IndexerEvent, IndexerSchema, SuiIndexerClient, StorageResponse, StorageItemResponse, JsonPathOrder } from './libs/suiIndexerClient';
-import { Http } from './libs/http';
+import { DerivePathParams, FaucetNetworkType, MapMoudleFuncQuery, MapMoudleFuncTx, DubheParams, SuiTxArg, SuiObjectArg, SuiVecTxArg, NetworkType } from './types';
+import { DubheChannelClient } from './libs/dubheChannel';
 export declare function isUndefined(value?: unknown): value is undefined;
 export declare function withMeta<T extends {
     meta: SuiMoveMoudleFuncType;
@@ -20,14 +19,18 @@ export declare function withMeta<T extends {
  */
 export declare class Dubhe {
     #private;
-    http: Http;
     accountManager: SuiAccountManager;
     suiInteractor: SuiInteractor;
-    suiIndexerClient: SuiIndexerClient;
     contractFactory: SuiContractFactory;
+    dubheChannelClient: DubheChannelClient;
     packageId: string | undefined;
+    /** Fully-qualified Move type string for this DApp's DappKey, e.g. `<64-hex>::dapp_key::DappKey`. */
+    dappKey: string | undefined;
     metadata: SuiMoveNormalizedModules | undefined;
     projectName: string | undefined;
+    frameworkPackageId: string | undefined;
+    dappStorageId: string | undefined;
+    dappHubId: string | undefined;
     /**
      * Support the following ways to init the DubheClient:
      * 1. mnemonics
@@ -39,91 +42,28 @@ export declare class Dubhe {
      * @param networkType, 'testnet' | 'mainnet' | 'devnet' | 'localnet', default is 'devnet'
      * @param fullnodeUrl, the fullnode url, default is the preconfig fullnode url for the given network type
      * @param packageId
+     * @param metadata
+     * @param channelUrl, the base URL for Dubhe Channel API, optional
+     * @param frameworkPackageId, the published package ID of the dubhe framework, required for proxy operations
      */
-    constructor({ mnemonics, secretKey, networkType, fullnodeUrls, packageId, metadata, customFetch, defaultOptions, indexerUrl, indexerWsUrl, }?: DubheParams);
+    constructor({ mnemonics, secretKey, networkType, fullnodeUrls, packageId, dappKey: dappKeyParam, metadata, channelUrl, frameworkPackageId, dappStorageId, dappHubId }?: DubheParams);
     get query(): MapMoudleFuncQuery;
     get tx(): MapMoudleFuncTx;
     get object(): MapObjectStruct;
     view(dryResult: DevInspectResults): any[];
-    state({ tx, schema, params, customModuleName, }: {
+    state({ tx, schema, params, customModuleName }: {
         tx: Transaction;
         schema: string;
         params: any[];
         customModuleName?: string;
     }): Promise<any[] | undefined>;
-    parseState({ schema, objectId, storageType, params, customModuleName, }: {
+    parseState({ schema, objectId, storageType, params, customModuleName }: {
         schema: string;
         objectId: string;
         storageType: string;
         params: any[];
         customModuleName?: string;
     }): Promise<any[] | undefined>;
-    getTransactions({ first, after, sender, digest, checkpoint, orderBy, }: {
-        first?: number;
-        after?: string;
-        sender?: string;
-        digest?: string;
-        checkpoint?: number;
-        orderBy?: string[];
-    }): Promise<ConnectionResponse<IndexerTransaction>>;
-    getTransaction(digest: string): Promise<IndexerTransaction | undefined>;
-    /**
-     * Wait for the transaction to be processed by the indexer and return all transaction-related data
-     * @param digest transaction digest
-     * @param options option parameters
-     * @returns result object containing transaction, events and schema data
-     */
-    waitForIndexerTransaction(digest: string, options?: {
-        checkInterval?: number;
-        timeout?: number;
-        maxRetries?: number;
-        pageSize?: number;
-    }): Promise<IndexerTransactionResult>;
-    getEvents({ first, after, names, sender, digest, checkpoint, orderBy, }: {
-        first?: number;
-        after?: string;
-        names?: string[];
-        sender?: string;
-        digest?: string;
-        checkpoint?: string;
-        orderBy?: string[];
-    }): Promise<ConnectionResponse<IndexerEvent>>;
-    getSchemas({ name, key1, key2, is_removed, last_update_checkpoint, last_update_digest, value, first, after, orderBy, jsonOrderBy, }: {
-        name?: string;
-        key1?: any;
-        key2?: any;
-        is_removed?: boolean;
-        last_update_checkpoint?: string;
-        last_update_digest?: string;
-        value?: any;
-        first?: number;
-        after?: string;
-        orderBy?: string[];
-        jsonOrderBy?: JsonPathOrder[];
-    }): Promise<ConnectionResponse<IndexerSchema>>;
-    getStorage({ name, key1, key2, is_removed, last_update_checkpoint, last_update_digest, value, first, after, orderBy, jsonOrderBy, }: {
-        name?: string;
-        key1?: any;
-        key2?: any;
-        is_removed?: boolean;
-        last_update_checkpoint?: string;
-        last_update_digest?: string;
-        value?: any;
-        first?: number;
-        after?: string;
-        orderBy?: string[];
-        jsonOrderBy?: JsonPathOrder[];
-    }): Promise<StorageResponse<IndexerSchema>>;
-    getStorageItem({ name, key1, key2, is_removed, last_update_checkpoint, last_update_digest, value, }: {
-        name: string;
-        key1?: any;
-        key2?: any;
-        is_removed?: boolean;
-        last_update_checkpoint?: string;
-        last_update_digest?: string;
-        value?: any;
-    }): Promise<StorageItemResponse<IndexerSchema> | undefined>;
-    subscribe(types: SubscribableType[], handleData: (data: any) => void): Promise<WebSocket>;
     /**
      * else:
      * it will generate signer from the mnemonic with the given derivePathParams.
@@ -142,12 +82,36 @@ export declare class Dubhe {
     getAddress(derivePathParams?: DerivePathParams): string;
     currentAddress(): string;
     getPackageId(): string;
+    /**
+     * Return the fully-qualified Move type string for this DApp's `DappKey`.
+     *
+     * The format matches what `std::type_name::get<DappKey>()` returns on-chain:
+     * `<64-char-zero-padded-address>::dapp_key::DappKey`
+     *
+     * Use this whenever you need to pass a type argument or build a `target`
+     * string that references the DApp's DappKey type.
+     *
+     * @example
+     * ```typescript
+     * tx.moveCall({
+     *   target: `${frameworkPackageId}::dapp_system::settle_writes`,
+     *   typeArguments: [contract.getDappKey()],
+     *   arguments: [...],
+     * });
+     * ```
+     */
+    getDappKey(): string | undefined;
     getMetadata(): SuiMoveNormalizedModules | undefined;
-    getNetwork(): import("./types").NetworkType | undefined;
+    getNetwork(): NetworkType | undefined;
     getNetworkConfig(): NetworkConfig;
     getTxExplorerUrl(txHash: string): string;
     getAccountExplorerUrl(address: string): string;
     getExplorerUrl(): string;
+    /**
+     * Update configuration dynamically without recreating the entire instance
+     * @param config - Partial configuration to update (same type as constructor)
+     */
+    updateConfig(config: Partial<DubheParams>): void;
     /**
      * Request some SUI from faucet
      * @Returns {Promise<boolean>}, true if the request is successful, false otherwise.
@@ -156,11 +120,10 @@ export declare class Dubhe {
     getBalance(coinType?: string, derivePathParams?: DerivePathParams): Promise<import("@mysten/sui/client").CoinBalance>;
     balanceOf(accountAddress?: string, coinType?: string, derivePathParams?: DerivePathParams): Promise<import("@mysten/sui/client").CoinBalance>;
     client(): import("@mysten/sui/client").SuiClient;
-    indexerClient(): SuiIndexerClient;
     getObject(objectId: string): Promise<SuiObjectData>;
     getObjects(objectIds: string[]): Promise<SuiObjectData[]>;
     signTxn(tx: Uint8Array | Transaction | SuiTx, derivePathParams?: DerivePathParams): Promise<import("@mysten/sui/dist/cjs/cryptography").SignatureWithBytes>;
-    signAndSendTxn({ tx, derivePathParams, onSuccess, onError, }: {
+    signAndSendTxn({ tx, derivePathParams, onSuccess, onError }: {
         tx: Uint8Array | Transaction | SuiTx;
         derivePathParams?: DerivePathParams;
         onSuccess?: (result: SuiTransactionBlockResponse) => void | Promise<void>;
@@ -168,6 +131,62 @@ export declare class Dubhe {
     }): Promise<SuiTransactionBlockResponse>;
     sendTx(transaction: Uint8Array | string, signature: string | string[]): Promise<SuiTransactionBlockResponse>;
     waitForTransaction(digest: string): Promise<SuiTransactionBlockResponse>;
+    submitToChannel({ tx, nonce, chainType }: {
+        tx: Transaction;
+        nonce: number;
+        chainType?: string;
+    }): Promise<any>;
+    queryChannelTable({ packageId, account, table, key }: {
+        packageId?: string;
+        account?: string;
+        table: string;
+        key: any[];
+    }): Promise<any>;
+    /**
+     * Subscribe to channel table updates via Server-Sent Events
+     * @param params - Subscription parameters
+     * @param options - Event handlers for the subscription
+     * @returns Unsubscribe function
+     *
+     * @example
+     * // Subscribe to all tables and accounts (only dapp_key)
+     * const unsubscribe = await dubhe.subscribeChannelTable(
+     *   {},
+     *   { onMessage: (data) => console.log(data) }
+     * );
+     *
+     * // Subscribe to all tables for a specific account
+     * const unsubscribe = await dubhe.subscribeChannelTable(
+     *   { account: '0xabc...' },
+     *   { onMessage: (data) => console.log(data) }
+     * );
+     *
+     * // Subscribe to a specific table for a specific account
+     * const unsubscribe = await dubhe.subscribeChannelTable(
+     *   { account: '0xabc...', table: 'position' },
+     *   { onMessage: (data) => console.log(data) }
+     * );
+     *
+     * // Subscribe to a specific table, account, and key
+     * const unsubscribe = await dubhe.subscribeChannelTable(
+     *   { account: '0xabc...', table: 'position', key: [] },
+     *   { onMessage: (data) => console.log(data) }
+     * );
+     */
+    subscribeChannelTable({ packageId: _packageId, account, table, key }?: {
+        packageId?: string;
+        account?: string;
+        table?: string;
+        key?: any[];
+    }, options?: {
+        onMessage?: (data: any) => void;
+        onError?: (error: Error) => void;
+        onOpen?: () => void;
+        onClose?: () => void;
+    }): Promise<() => void>;
+    latestNonce({ account }?: {
+        account?: string;
+    }): Promise<number>;
     /**
      * Transfer the given amount of SUI to the recipient
      * @param recipient
@@ -227,4 +246,157 @@ export declare class Dubhe {
     entity_key_from_address_with_seed(objectId: string, seed: string): Promise<string | undefined>;
     entity_key_from_address_with_u256(objectId: string, x: number): Promise<string | undefined>;
     entity_key_from_u256(x: number): Promise<string>;
+    /**
+     * Call the DApp's generated `user_storage_init::init_user_storage` entry function,
+     * which creates and shares a `UserStorage` object for the signer.
+     *
+     * Each DApp exposes this entry point under its own package ID.
+     * On Sui, the `UserStorage` object is shared immediately so all transactions
+     * can reference it without knowing the object ID in advance.
+     *
+     * @param dappHubId      Object ID of the DappHub shared object
+     * @param dappStorageId  Object ID of the DApp's DappStorage shared object
+     */
+    initUserStorage({ dappHubId, dappStorageId: dappStorageIdParam, derivePathParams, onSuccess, onError }: {
+        dappHubId: string;
+        dappStorageId?: string;
+        derivePathParams?: DerivePathParams;
+        onSuccess?: (result: SuiTransactionBlockResponse) => void | Promise<void>;
+        onError?: (error: Error) => void | Promise<void>;
+    }): Promise<SuiTransactionBlockResponse>;
+    /**
+     * Activate a session key for the signer's `UserStorage`.
+     *
+     * The signer must be the `canonical_owner` of the `UserStorage` object.
+     * Calls `<frameworkPackageId>::dapp_system::activate_session<DappKey>`.
+     *
+     * @param userStorageId  Object ID of the UserStorage to activate a session for
+     * @param sessionWallet  Sui address of the session wallet
+     * @param durationMs     Session duration in milliseconds ([60_000, 604_800_000])
+     * @param clockObjectId  Object ID of the Sui Clock (default: 0x6)
+     */
+    activateSession({ userStorageId, sessionWallet, durationMs, dappHubId: dappHubIdParam, clockObjectId, derivePathParams, onSuccess, onError }: {
+        userStorageId: string;
+        sessionWallet: string;
+        durationMs: number;
+        dappHubId?: string;
+        clockObjectId?: string;
+        derivePathParams?: DerivePathParams;
+        onSuccess?: (result: SuiTransactionBlockResponse) => void | Promise<void>;
+        onError?: (error: Error) => void | Promise<void>;
+    }): Promise<SuiTransactionBlockResponse>;
+    /**
+     * Deactivate the current session key on a `UserStorage`.
+     *
+     * Allowed callers:
+     *   - The `canonical_owner` (revoke at any time).
+     *   - The session key itself (voluntary sign-out).
+     *   - Anyone, once the session has expired.
+     *
+     * Calls `<frameworkPackageId>::dapp_system::deactivate_session<DappKey>`.
+     *
+     * @param userStorageId  Object ID of the UserStorage to deactivate the session on
+     */
+    deactivateSession({ userStorageId, dappHubId: dappHubIdParam, derivePathParams, onSuccess, onError }: {
+        userStorageId: string;
+        dappHubId?: string;
+        derivePathParams?: DerivePathParams;
+        onSuccess?: (result: SuiTransactionBlockResponse) => void | Promise<void>;
+        onError?: (error: Error) => void | Promise<void>;
+    }): Promise<SuiTransactionBlockResponse>;
+    /**
+     * Look up the `UserStorage` object ID for the given address in this DApp.
+     *
+     * Scans the transaction history for `user_storage_init::init_user_storage`
+     * calls from the given address and extracts the created `UserStorage` object
+     * ID from the transaction's object changes.
+     *
+     * Returns the object ID on success, or `null` when:
+     *   - `packageId` or `frameworkPackageId` is not set.
+     *   - The user has not yet called `initUserStorage`.
+     *
+     * @param userAddress  Sui address to look up (with or without 0x prefix).
+     */
+    getUserStorageId(userAddress: string): Promise<string | null>;
+    /**
+     * Fetch and return the on-chain fields of a `UserStorage` shared object.
+     *
+     * The returned object mirrors Move's `UserStorage` struct plus two
+     * convenience fields computed from the raw counters:
+     *   - `unsettled_count`  = write_count  − settled_count
+     *   - `unsettled_bytes`  = write_bytes  − settled_bytes
+     *
+     * @param userStorageId  Object ID of the UserStorage to inspect.
+     */
+    getUserStorageFields(userStorageId: string): Promise<{
+        objectId: string;
+        dapp_key: string;
+        canonical_owner: string;
+        session_key: string;
+        session_expires_at: bigint;
+        write_count: bigint;
+        settled_count: bigint;
+        write_bytes: bigint;
+        settled_bytes: bigint;
+        unsettled_count: bigint;
+        unsettled_bytes: bigint;
+    }>;
+    /**
+     * Fetch and return the on-chain fields of a `DappStorage` shared object.
+     *
+     * Covers the full metadata + fee/credit subset of the Move struct.
+     *
+     * @param dappStorageId  Object ID of the DappStorage to inspect.
+     */
+    getDappStorageFields(dappStorageId: string): Promise<{
+        objectId: string;
+        dapp_key: string;
+        name: string;
+        description: string;
+        website_url: string;
+        admin: string;
+        version: number;
+        paused: boolean;
+        free_credit: bigint;
+        free_credit_expires_at: bigint;
+        credit_pool: bigint;
+        min_credit_to_unsuspend: bigint;
+        suspended: boolean;
+        total_settled: bigint;
+        base_fee_per_write: bigint;
+        bytes_fee_per_byte: bigint;
+    }>;
+    /**
+     * Settle accumulated write debt for a user.
+     *
+     * Calls `<frameworkPackageId>::dapp_system::settle_writes<DappKey>` with the
+     * given DappHub, DappStorage, and UserStorage objects.
+     *
+     * This is safe to prepend to any PTB — the framework function never aborts
+     * due to insufficient credit; it silently skips or partially settles.
+     *
+     * @param dappHubId      Object ID of the DappHub shared object.
+     * @param dappStorageId  Object ID of the DApp's DappStorage shared object.
+     * @param userStorageId  Object ID of the user's UserStorage shared object.
+     */
+    settleWrites({ dappHubId, dappStorageId: dappStorageIdParam, userStorageId, derivePathParams, onSuccess, onError }: {
+        dappHubId: string;
+        dappStorageId?: string;
+        userStorageId: string;
+        derivePathParams?: DerivePathParams;
+        onSuccess?: (result: SuiTransactionBlockResponse) => void | Promise<void>;
+        onError?: (error: Error) => void | Promise<void>;
+    }): Promise<SuiTransactionBlockResponse>;
+    /**
+     * Return the default network configuration for the given network type.
+     *
+     * Useful for reading `frameworkPackageId` without instantiating a full client:
+     *
+     * ```ts
+     * const { frameworkPackageId } = Dubhe.getDefaultConfig('testnet');
+     * // → '0x8817b...' (known constant for testnet/mainnet)
+     * // → undefined   (for localnet/devnet — supply after local deployment)
+     * ```
+     */
+    static getDefaultConfig(networkType: NetworkType): NetworkConfig;
 }

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export * from '@mysten/sui/client';
 export * from '@mysten/sui/utils';
 export * from '@mysten/sui/transactions';
 export * from '@mysten/sui/bcs';
+export * from '@mysten/sui/keypairs/passkey';
 export * from '@mysten/sui/keypairs/ed25519';
 export * from '@mysten/sui/keypairs/secp256k1';
 export * from '@mysten/sui/keypairs/secp256r1';
@@ -11,7 +12,7 @@ export { SuiAccountManager } from './libs/suiAccountManager';
 export { SuiTx } from './libs/suiTxBuilder';
 export { MultiSigClient } from './libs/multiSig';
 export { SuiContractFactory } from './libs/suiContractFactory';
-export { SubscriptionKind } from './libs/suiIndexerClient';
 export { loadMetadata } from './metadata';
 export type * from './types';
-export type { IndexerEvent, IndexerSchema, IndexerTransaction, ConnectionResponse, StorageResponse, StorageItemResponse, PageInfo, JsonPathOrder, JsonValueType, } from './libs/suiIndexerClient';
+export { getDefaultConfig, getDefaultURL, TESTNET_DUBHE_FRAMEWORK_PACKAGE_ID, TESTNET_DUBHE_HUB_OBJECT_ID, MAINNET_DUBHE_FRAMEWORK_PACKAGE_ID, MAINNET_DUBHE_HUB_OBJECT_ID } from './libs/suiInteractor/defaultConfig';
+export type { NetworkConfig } from './libs/suiInteractor/defaultConfig';