suidouble 2.5.0 → 2.17.0

package/types/lib/SuiUtils.d.ts

@@ -0,0 +1,152 @@
+export { normalizeSuiAddress };
+/** Helpful methods using in different places of suidouble */
+export default class SuiUtils extends SuiCommonMethods {
+    /**
+     * Attach the parameter input into transaction, to be used for moveCall
+     * accepts an Inputs.Pure (result of .pureInput) or type + value directly
+     *
+     * @param {Transaction} tx
+     * @param {string | PureInput} typeOrInput - string type name, or already-serialised Pure input `{ Pure: { bytes } }`
+     * @param {*} [value]
+     * @returns {Argument}
+     */
+    static txInput(tx: Transaction, typeOrInput: string | PureInput, value?: any): Argument;
+    /**
+     * Returns and Inputs.Pure for a given type
+     *   to be used as moveCall parameters
+     *   type is 'u8', 'u16', 'u32', 'u64', 'u128', 'u256', 'address', 'bool', 'string', 'vector<u8>' ... 'vector<u256>'
+     *
+     * result may be passed as arguments to SuiPackage or SuiPackageModule moveCall functions params array:
+     *     contract.moveCall('suidouble_chat', 'reply', [
+     *         SuiUtils.pureInput('string', 'metadata')
+     *         SuiUtils.pureInput('string', 'metadata')
+     *     ]);
+     *
+     * if you are going to construct tx yourself, you'd better use SuiUtils.txInput static method
+     *
+     * @param {string} type
+     * @param {*} value
+     * @returns {CallArg}
+     */
+    static pureInput(type: string, value: any): CallArg;
+    /**
+     * Convert sui's PureInput into bcs serialized bytes
+     * @param {PureInput} pureInput
+     */
+    static pureInputToBytes(pureInput: PureInput): Uint8Array<ArrayBuffer>;
+    /**
+     * Decode a Move `vector<u8>` field into a UTF-8 string.
+     *
+     * Accepts the shapes SUI returns across representations:
+     *   - base64 string (v2 gRPC/GraphQL JSON representation for byte vectors)
+     *   - Uint8Array
+     *   - array of numbers (legacy JSON-RPC shape)
+     *
+     * @param {string | Uint8Array | number[]} value
+     * @returns {string}
+     */
+    static bytesFieldToString(value: string | Uint8Array | number[]): string;
+    /**
+     * Wrapper for sui's utils normalizeSuiAddress
+     * Perform the following operations:
+     * <pre>
+     * 1. Make the address lower case
+     * 2. Prepend `0x` if the string does not start with `0x`.
+     * 3. Add more zeros if the length of the address(excluding `0x`) is less than `SUI_ADDRESS_LENGTH`
+     * </pre>
+     *
+     * @param {string} address
+     * @returns string
+     */
+    static normalizeSuiAddress(address: string): string;
+    /**
+     * Makes an instance of SuiGrpcClient pointed at a custom gRPC-web endpoint.
+     *
+     * `transportOptions` is passed through to GrpcWebFetchTransport — the same shape
+     * as `@protobuf-ts/grpcweb-transport`'s GrpcWebOptions:
+     *   - baseUrl   : string   — required, the gRPC-web endpoint
+     *   - format    : 'text' | 'binary' — wire format, defaults to 'text'
+     *   - fetchInit : RequestInit-ish — extra fetch options (credentials, cache, ...); `body`/`headers`/`method`/`signal` are reserved
+     *   - fetch     : typeof fetch — custom fetch implementation (useful for proxies, auth, logging)
+     *
+     * @example
+     * const client = SuiUtils.suiClientForRPC('mainnet', {
+     *     baseUrl: 'https://fullnode.mainnet.sui.io:443',
+     *     format: 'binary',
+     *     fetchInit: { credentials: 'include' },
+     *     fetch: (url, init) => fetch(url, { ...init, headers: { ...init.headers, 'x-api-key': 'xxx' } }),
+     * });
+     *
+     * @param {SuiClientTypes.Network} network
+     * @param {GrpcWebOptions} transportOptions
+     * @returns {SuiGrpcClient}
+     */
+    static suiClientForRPC(network: SuiClientTypes.Network, transportOptions: GrpcWebOptions): SuiGrpcClient;
+    /**
+     * Build a SuiGraphQLClient reusing the network of an existing SuiGrpcClient.
+     *
+     * Picks the default Sui GraphQL endpoint for the network unless `overrides.url` is set.
+     * `overrides` is forwarded to SuiGraphQLClient (fetch, headers, queries, mvr, url).
+     *
+     * @param {SuiGrpcClient} grpcClient
+     * @param {Object} [overrides]
+     * @param {?string} [overrides.url]
+     * @param {?typeof fetch} [overrides.fetch]
+     * @param {?Object.<string, string>} [overrides.headers]
+     * @returns {SuiGraphQLClient}
+     */
+    static suiGraphQLClientFromGrpc(grpcClient: SuiGrpcClient, overrides?: {
+        url?: string | null;
+        fetch?: typeof fetch | null;
+        headers?: {
+            [x: string]: string;
+        } | null;
+    }): SuiGraphQLClient;
+    /**
+     * Makes an instance for SuiGrpcClient for a specific chain, eg: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
+     * @param {SuiClientTypes.Network} network
+     * @returns {SuiGrpcClient}
+     */
+    static suiClientFor(network: SuiClientTypes.Network): SuiGrpcClient;
+    /**
+     * Normalize client parameter into a SuiGrpcClient, accepting:
+     *   - an existing SuiGrpcClient instance
+     *   - a SuiLocalTestValidator instance
+     *   - a string chain name: 'local' | 'localnet' | 'dev' | 'devnet' | 'test' | 'testnet' | 'main' | 'mainnet'
+     *   - a legacy client object (sniffs network from endpoint / connection.fullnode / providerName)
+     *
+     * @param {SuiGrpcClient | string | Object} clientParam
+     * @returns {SuiGrpcClient | null}
+     */
+    static normalizeClient(clientParam: SuiGrpcClient | string | any): SuiGrpcClient | null;
+    /**
+     * Strip an optional "sui:" prefix and map short aliases ('local', 'dev', 'test', 'main')
+     * to full network names. Returns null if the string doesn't match a known network.
+     *
+     * @param {string} s
+     * @returns {SuiClientTypes.Network | null}
+     */
+    static normalizeNetworkString(s: string): SuiClientTypes.Network | null;
+    /**
+     * Extracts a SuiClientTypes.Network string from various inputs used historically by suidouble.
+     *
+     * @param {string | Object} clientParam
+     * @returns {SuiClientTypes.Network | null}
+     */
+    static _sniffNetwork(clientParam: string | any): SuiClientTypes.Network | null;
+}
+export type Argument = import("@mysten/sui/transactions").Argument;
+export type CallArg = import("@mysten/sui/transactions").CallArg;
+export type PureInput = {
+    Pure: {
+        bytes: string;
+    };
+};
+export type SuiGrpcClientOptions = import("@mysten/sui/grpc").SuiGrpcClientOptions;
+export type GrpcWebOptions = import("@mysten/sui/grpc").GrpcWebOptions;
+import { normalizeSuiAddress } from '@mysten/sui/utils';
+import SuiCommonMethods from './SuiCommonMethods.js';
+import { Transaction } from '@mysten/sui/transactions';
+import type { SuiClientTypes } from "@mysten/sui/client";
+import { SuiGrpcClient } from '@mysten/sui/grpc';
+import { SuiGraphQLClient } from '@mysten/sui/graphql';

package/types/lib/data/icons.d.ts

@@ -0,0 +1,12 @@
+export default icons;
+declare namespace icons {
+    let SLUSH: string;
+    let OKX: string;
+    let PHANTOM: string;
+    let SUI: string;
+    let SUIET: string;
+    let GLASS: string;
+    let ETHOS: string;
+    let SURF: string;
+    let NIGHTLY: string;
+}

package/lib/SuiTestScenario.js

@@ -1,169 +0,0 @@
-import SuiCommonMethods from './SuiCommonMethods.js';
-import SuiLocalTestValidator from './SuiLocalTestValidator.js';
-import SuiMaster from './SuiMaster.js';
-import SuiUtils from './SuiUtils.js';
-
-
-export default class SuiTestScenario extends SuiCommonMethods {
-    constructor(params = {}) {
-        super(params);
-
-        this._path = params.path; // path to Move package's root
-        this._client = null;
-
-        this._defaultAs = null; // 'as'(string for pseudo-random keypair generator) for default user and package's owner 
-                                // (we will publish and init from this user)
-        this._currentAs = null; // 'as' for current wrapped transaction
-
-        this._masters = {       // suiMaster and package for each 'as'
-        };
-        this._packages = {
-        };
-
-        this._publishedPackageId = null;
-    }
-
-    get currentAs() {
-        return this._currentAs;
-    }
-
-    arg(type, value) {
-        return SuiUtils.pureInput(type, value);
-    }
-
-    /**
-     * Start local test validator and set up `as` as owner of package deploy transaction.
-     * Package will be deployed with method `init`, as we try to mimic Sui Move's test_scenario
-     * @param {String} as 
-     */
-    async begin(as) {
-        this._client = await SuiLocalTestValidator.launch({debug: true});
-        this._defaultAs = as;
-        this._currentAs = as;
-    }
-
-    /**
-     * Shut down test validator and finish test scenario
-     */
-    async end() {
-        await SuiLocalTestValidator.stop();
-    }
-
-    /**
-     * Deploy the package. Move will execute it's init function.
-     */
-    async init() {
-        if (!this._defaultAs) {
-            throw new Error('please call .begin(as) first');
-        }
-
-        this._currentAs = this._defaultAs;
-        await this.initMaster(this._defaultAs);
-    }
-
-
-    /**
-     * Temorary assign user to `as`
-     * @param {String} as 
-     * @param {Function} func 
-     */
-    async next_tx(as, func) {
-        if (!this._defaultAs) {
-            throw new Error('please call .begin(as) first');
-        }
-
-        try {
-            await this.initMaster(as);
-            this._currentAs = as;
-            await func(this);
-            this._currentAs = this._defaultAs;
-        } catch (e) {
-            throw e;
-        }
-    }
-    async nextTx(as, func) {
-        return this.next_tx(as, func);
-    }
-
-    take_from_sender(typeName) {
-        const asAsAddress = this._masters[this._currentAs].address;
-        const objectStorage = this._masters[this._currentAs].objectStorage; // it's same object for different 'as' connected to the same provider, but we don't care here
-        return objectStorage.findMostRecent((object)=>{
-                return (object.typeName == typeName && object.isOwnedBy(asAsAddress));
-            });
-    }
-    takeFromSender(typeName) {
-        return this.take_from_sender(typeName);
-    }
-
-    take_shared(typeName) {
-        const objectStorage = this._masters[this._currentAs].objectStorage; // it's same object for different 'as' connected to the same provider, but we don't care here
-        return objectStorage.findMostRecent((object)=>{
-                return (object.isShared && object.typeName == typeName);
-            });
-    }
-    takeShared(typeName) {
-        return this.take_shared(typeName);
-    }
-
-    take_immutable(typeName) {
-        const objectStorage = this._masters[this._currentAs].objectStorage; // it's same object for different 'as' connected to the same provider, but we don't care here
-        return objectStorage.findMostRecent((object)=>{
-                return (object.isImmutable && object.typeName == typeName);
-            });
-    }
-    takeImmutable(typeName) {
-        return this.take_immutable(typeName);
-    }
-
-    async moveCall(moduleName, methodName, params) {
-        if (!this._currentAs) {
-            throw new Error('please call moveCall inside .next_tx(as, ()=>{}) wrapper');
-        }
-
-        await this._packages[this._currentAs].modules[moduleName].moveCall(methodName, params);
-    }
-
-    async initMaster(as) {
-        if (this._masters[as]) {
-            return true;
-        }
-
-        const suiMaster =  new SuiMaster({debug: this._debug, as: as, client: this._client, });
-
-        await suiMaster.initialize();
-        await suiMaster.requestSuiFromFaucet();
-
-        const addPackageParams = {};
-        if (this._publishedPackageId) {
-            // already pulished
-            addPackageParams.id = this._publishedPackageId;
-        } else {
-            // to be build and published
-            addPackageParams.path = this._path;
-        }
-        const addedPackage = suiMaster.addPackage(addPackageParams);
-        // addedPackage.addEventListener('added', (data)=>{
-        //     const object = data.detail;
-        //     if (object && !this._objects[object.address]) { // there may be few same object instances in different suiMaster's.
-        //         this._objects[object.address] = object;
-        //     }
-        // });
-
-        if (!this._publishedPackageId) {
-            await addedPackage.publish();
-            this._publishedPackageId = addedPackage.id;
-
-            if (!this._publishedPackageId) {
-                this.log('can not publish a package');
-            }
-        } else {
-            await addedPackage.isOnChain(); // check modules etc for other user
-        }
-
-
-        this._masters[as] = suiMaster;
-        this._packages[as] = addedPackage;
-    }
-
-};

package/test/sui_test_scenario.test.js

@@ -1,61 +0,0 @@
-'use strict'
-
-import t from 'tap';
-import { SuiTestScenario } from '../index.js';
-
-import { fileURLToPath } from 'url';
-import path from 'path';
-
-const { test } = t;
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-let testScenario = null;
-
-test('initialization', async t => {
-    testScenario = new SuiTestScenario({
-        path: path.join(__dirname, './test_move_contracts/suidouble_chat/'),
-        debug: false,
-    });
-
-    await testScenario.begin('admin');
-    await testScenario.init();
-
-    t.equal(testScenario.currentAs, 'admin');
-});
-
-test('checking takeShared', async t => {
-	t.plan(4);
-
-    await testScenario.nextTx('admin', async()=>{
-        const chatShop = testScenario.takeShared('ChatShop');
-
-        t.ok(chatShop.address); // there should be some address
-        t.ok(`${chatShop.address}`.indexOf('0x') === 0); // adress is string starting with '0x'
-
-        await testScenario.moveCall('suidouble_chat', 'post', [chatShop.address, testScenario.arg('string', 'posting a message'),  testScenario.arg('string', 'metadata')]);
-        const chatTopMessage = testScenario.takeShared('ChatTopMessage');
-
-        t.ok(chatTopMessage.address); // there should be some address
-        t.ok(`${chatTopMessage.address}`.indexOf('0x') === 0); // adress is string starting with '0x'
-    });
-});
-
-test('checking takeOwned', async t => {
-	t.plan(3);
-
-    await testScenario.nextTx('somebody', async()=>{
-        const chatTopMessage = testScenario.takeShared('ChatTopMessage');
-        t.ok(chatTopMessage.address); // there should be some address
-
-        await testScenario.moveCall('suidouble_chat', 'reply', [chatTopMessage.address, testScenario.arg('string', 'posting a response'), testScenario.arg('string', 'metadata')]);
-        const chatResponse = testScenario.takeFromSender('ChatResponse');
-
-        t.ok(chatResponse.address); // there should be some address
-        t.ok(`${chatResponse.address}`.indexOf('0x') === 0); // adress is string starting with '0x'
-    });
-})
-
-test('finishing the test scenario', async t => {
-    await testScenario.end();
-});