suidouble 0.0.51 → 1.0.4-2

package/lib/SuiObject.js

@@ -1,6 +1,6 @@
 const SuiCommonMethods = require('./SuiCommonMethods.js');
 const SuiPaginatedResponse = require('./SuiPaginatedResponse.js');
-const { normalizeSuiAddress } = require('@mysten/sui.js/utils');
+const { normalizeSuiAddress } = require('@mysten/sui/utils');
 
 class SuiObject extends SuiCommonMethods {
     constructor(params = {}) {
@@ -137,7 +137,7 @@ class SuiObject extends SuiCommonMethods {
         }
         v = Number(v);
 
-        const result = await this._suiMaster._provider.tryGetPastObject({
+        const result = await this._suiMaster._client.tryGetPastObject({
             version: (v),
             id: this.address,
             options: {
@@ -221,7 +221,7 @@ class SuiObject extends SuiCommonMethods {
     }
 
     async fetchFields() {
-        const result = await this._suiMaster._provider.getObject({
+        const result = await this._suiMaster._client.getObject({
             id: this.address, // normalized id
             options: {
               showType: true,

package/lib/SuiPackage.js

@@ -4,8 +4,9 @@ const SuiPackageModule = require('./SuiPackageModule.js');
 const SuiPaginatedResponse = require('./SuiPaginatedResponse.js');
 
 // fromB64, toB64
-const { TransactionBlock } = require('@mysten/sui.js/transactions');
-const { normalizeSuiAddress } = require('@mysten/sui.js/utils');
+const { Transaction } = require('@mysten/sui/transactions');
+const { normalizeSuiAddress } = require('@mysten/sui/utils');
+const { bcs } = require('@mysten/sui/bcs');
 
 class SuiPackage extends SuiObject {
     constructor(params = {}) {
@@ -70,9 +71,13 @@ class SuiPackage extends SuiObject {
         return false;
     }
 
-    async moveCall(moduleName, methodName, params) {
+    arg(type, value) {
+        return this._suiMaster.utils.pureInput(type, value);
+    }
+
+    async moveCall(moduleName, methodName, params, typeArguments) {
         await this.checkOnChainIfNeeded();
-        return await this.modules[moduleName].moveCall(methodName, params);
+        return await this.modules[moduleName].moveCall(methodName, params, typeArguments);
     }
 
     async fetchEvents(moduleName, params = {}) {
@@ -167,7 +172,7 @@ class SuiPackage extends SuiObject {
 
         // queriing packages out of the loop, as not sure if pagination cursor works ok with mixed calls, @todo: check
         // @todo: what is the max count of ids here?
-        const packagesResult = await this._suiMaster._provider.multiGetObjects({
+        const packagesResult = await this._suiMaster._client.multiGetObjects({
             ids: packagesOnChainIds,
             // only fetch the object type
             options: { showType: true, showContent: true, },
@@ -215,9 +220,9 @@ class SuiPackage extends SuiObject {
     async getVersionOnChain() {
         this.log('geting package version previously published on chain...');
 
-        const provider = await this._suiMaster.getProvider();
+        const client = await this._suiMaster.getClient();
 
-        const result = await provider.getObject({
+        const result = await client.getObject({
             id: this.address, // normalized id
             options: {
               showType: true,
@@ -237,6 +242,7 @@ class SuiPackage extends SuiObject {
 
         if (result?.data?.content?.disassembled) {
             for (const key in result?.data?.content?.disassembled) {
+                // console.log(result?.data?.content?.disassembled[key]);
                 this.attachModule(key);
                 // if (!this._modules[key]) {
                 //     this._modules[key] = new SuiPackageModule({
@@ -311,7 +317,7 @@ class SuiPackage extends SuiObject {
                 queryParams.cursor = nextCursor;
             }
 
-            const result = await this._suiMaster._provider.getOwnedObjects(queryParams);
+            const result = await this._suiMaster._client.getOwnedObjects(queryParams);
 
             if (result.hasNextPage && result.nextCursor) {
                 hasNextPage = true;
@@ -398,16 +404,16 @@ class SuiPackage extends SuiObject {
 
         this.log('publishing package...');
 
-        const tx = new TransactionBlock();
+        const tx = new Transaction();
         const [upgradeCap] = tx.publish({
             modules: this._builtModules,
             dependencies: this._builtDependencies,
         });
 
-        tx.transferObjects([upgradeCap], tx.pure(this._suiMaster.address));
+        tx.transferObjects([upgradeCap], this._suiMaster.address);
 
-        const result = await this._suiMaster.signAndExecuteTransactionBlock({
-            transactionBlock: tx,
+        const result = await this._suiMaster.signAndExecuteTransaction({
+            transaction: tx,
             requestType: 'WaitForLocalExecution',
             options: {
                 "showEffects": true, // @todo: remove?
@@ -434,7 +440,7 @@ class SuiPackage extends SuiObject {
 
         this.log('upgrading package...');
 
-        const tx = new TransactionBlock();
+        const tx = new Transaction();
 
         const cap = tx.object(await this.getUpgradeCapId());
         // export enum UpgradePolicy {
@@ -444,15 +450,21 @@ class SuiPackage extends SuiObject {
         //   }
         const UpgradePolicyCOMPATIBLE = 0;
 
+        const authorizeUpgradeArguments = [
+            cap,
+            tx.pure(this.arg('u8', UpgradePolicyCOMPATIBLE)), 
+            tx.pure(this.arg('vector<u8>', this._builtDigest)),
+        ];
+
         const ticket = tx.moveCall({
             target: '0x2::package::authorize_upgrade',
-            arguments: [cap, tx.pure(UpgradePolicyCOMPATIBLE), tx.pure(this._builtDigest)],
+            arguments: authorizeUpgradeArguments,
         });
 
         const receipt = tx.upgrade({
             modules: this._builtModules,
             dependencies: this._builtDependencies,
-            packageId: this.address, // normalized id
+            package: this.address, // packageId -> package in sdk v1.0
             ticket,
         });
 
@@ -461,8 +473,10 @@ class SuiPackage extends SuiObject {
             arguments: [cap, receipt],
         });
 
-        const result = await this._suiMaster.signAndExecuteTransactionBlock({
-            transactionBlock: tx,
+        console.log(tx);
+
+        const result = await this._suiMaster.signAndExecuteTransaction({
+            transaction: tx,
             options: {
                 showEffects: true,
                 showObjectChanges: true,
@@ -519,6 +533,7 @@ class SuiPackage extends SuiObject {
             throw new Error('can not get modules names from local package path');
         }
     }
+
 }
 
 module.exports = SuiPackage;

package/lib/SuiPackageModule.js

@@ -5,8 +5,8 @@ const SuiPaginatedResponse = require('./SuiPaginatedResponse.js');
 const SuiEvent = require('./SuiEvent.js');
 // fromB64, toB64
 
-const { TransactionBlock } = require('@mysten/sui.js/transactions');
-const { normalizeSuiAddress } = require('@mysten/sui.js/utils');
+const { Transaction } = require('@mysten/sui/transactions');
+const { normalizeSuiAddress } = require('@mysten/sui/utils');
 
 class SuiPackageModule extends SuiCommonMethods {
     constructor(params = {}) {
@@ -35,6 +35,23 @@ class SuiPackageModule extends SuiCommonMethods {
         this._unsubscribeFunction = null;
     }
 
+    arg(type, value) {
+        return this._suiMaster.utils.pureInput(type, value);
+    }
+
+    async getNormalizedMoveFunction(methodName) {
+        const normalizedPackageAddress = await this.getNormalizedPackageAddress();
+
+        const ret = await this._suiMaster._client.getMoveFunctionArgTypes({
+            package: normalizedPackageAddress,
+            module: this._moduleName,
+            function: methodName,
+        });
+
+        // console.log(ret);
+        return ret;
+    }
+
     async subscribeEvents() {
         this.log('subscribing to events of module', this._moduleName);
 
@@ -55,7 +72,7 @@ class SuiPackageModule extends SuiCommonMethods {
             this.emit('event', suiEvent, true); // emit to common events flow
         };
 
-        this._unsubscribeFunction = await this._suiMaster._provider.subscribeEvent({
+        this._unsubscribeFunction = await this._suiMaster._client.subscribeEvent({
             filter: {"MoveModule": {"package": normalizedPackageAddress, "module": this._moduleName} },
             onMessage: onMessage,
         });
@@ -114,14 +131,14 @@ class SuiPackageModule extends SuiCommonMethods {
         return null;
     }
 
-    async moveCall(methodName, params) {
+    async moveCall(methodName, params, typeArguments) {
         await this._package.checkOnChainIfNeeded();
 
         let tx = null;
         if (params.tx) {
             tx = params.tx;
         } else {
-            tx = new TransactionBlock();
+            tx = new Transaction();
 
             const callArgs = [];
     
@@ -149,11 +166,12 @@ class SuiPackageModule extends SuiCommonMethods {
             tx.moveCall({
                 target: `${this._package.address}::${this._moduleName}::${methodName}`,
                 arguments: callArgs,
+                typeArguments: typeArguments,
             });
         }
 
-        const result = await this._suiMaster.signAndExecuteTransactionBlock({
-            transactionBlock: tx,
+        const result = await this._suiMaster.signAndExecuteTransaction({
+            transaction: tx,
             requestType: 'WaitForLocalExecution',
             options: {
                 "showEffects": true, // @todo: remove?
@@ -311,7 +329,7 @@ class SuiPackageModule extends SuiCommonMethods {
             return true;
         } 
 
-        const normalized = await this._suiMaster._provider.getNormalizedMoveModule({
+        const normalized = await this._suiMaster._client.getNormalizedMoveModule({
             package: this._package.address,
             module: this._moduleName,
         });

package/lib/SuiPaginatedResponse.js

@@ -64,7 +64,7 @@ class SuiPaginatedResponse extends SuiCommonMethods {
         }
         paramsCopy.order = this._order;
 
-        const response = await this._suiMaster.provider[this._method](paramsCopy);
+        const response = await this._suiMaster.client[this._method](paramsCopy);
         let responseCount = 0;
         if (response.data && response.data.length) {
             responseCount = response.data.length;

package/lib/SuiPseudoRandomAddress.js

@@ -1,6 +1,6 @@
 const { entropyToMnemonic } = require('@scure/bip39');
 const { wordlist } = require('@scure/bip39/wordlists/english');
-const { Ed25519Keypair } = require('@mysten/sui.js/keypairs/ed25519');
+const { Ed25519Keypair } = require('@mysten/sui/keypairs/ed25519');
 
 class SuiPseudoRandomAddress {
     static stringToKeyPair(as) {

package/lib/SuiTestScenario.js

@@ -1,13 +1,14 @@
 const SuiCommonMethods = require('./SuiCommonMethods.js');
 const SuiLocalTestValidator = require('./SuiLocalTestValidator.js');
 const SuiMaster = require('./SuiMaster.js');
+const SuiUtils = require('./SuiUtils.js');
 
 class SuiTestScenario extends SuiCommonMethods {
     constructor(params = {}) {
         super(params);
 
         this._path = params.path; // path to Move package's root
-        this._provider = null;
+        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)
@@ -25,13 +26,17 @@ class SuiTestScenario extends SuiCommonMethods {
         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._provider = await SuiLocalTestValidator.launch({debug: true});
+        this._client = await SuiLocalTestValidator.launch({debug: true});
         this._defaultAs = as;
         this._currentAs = as;
     }
@@ -123,7 +128,7 @@ class SuiTestScenario extends SuiCommonMethods {
             return true;
         }
 
-        const suiMaster =  new SuiMaster({debug: this._debug, as: as, provider: this._provider, });
+        const suiMaster =  new SuiMaster({debug: this._debug, as: as, client: this._client, });
 
         await suiMaster.initialize();
         await suiMaster.requestSuiFromFaucet();

package/lib/SuiUtils.js

@@ -0,0 +1,182 @@
+const SuiCommonMethods = require('./SuiCommonMethods.js');
+const { Inputs } = require('@mysten/sui/transactions');
+const { bcs } = require('@mysten/sui/bcs');
+const { SuiClient, getFullnodeUrl, SuiHTTPTransport } = require('@mysten/sui/client');
+const { normalizeSuiAddress } = require('@mysten/sui/utils');
+
+const WebSocketClient = require('websocket').w3cwebsocket;
+
+class SuiUtils extends SuiCommonMethods {
+
+    /**
+     * 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')
+     *     ]);
+     * 
+     *  or:
+     *   wrapped in tx.pure if you are going to construct tx yourself:
+     *    const tx = new Transaction();
+     *    tx.moveCall({ target: `x.x.x`, arguments: [
+     *         tx.pure(SuiUtils.pureInput('u8',22)),
+     *         tx.pure(SuiUtils.pureInput('string','test')),
+     *      ] });
+     * 
+     * @param {string} type 
+     * @param {value} value 
+     * @returns Inputs.Pure
+     */
+    static pureInput(type, value) {
+        let typeNormalized = type;
+        if (typeNormalized.toLowerCase() == 'address') {
+            typeNormalized = 'Address';
+        }
+
+        if (bcs[typeNormalized]) {
+            //
+            if (typeof(bcs[typeNormalized]) == 'object') {
+                // sui/bcs
+                return Inputs.Pure(bcs[typeNormalized].serialize(value));
+            } else {
+                // bcs
+                return Inputs.Pure(bcs[typeNormalized]().serialize(value));
+            }
+        } else {
+            // may it be a "vector<x>" ?
+            const splet = (''+typeNormalized).split('<');
+            if (splet[0] == 'vector' && splet[1]) {
+                const second = splet[1].split('>');
+                if (second[0] && bcs[second[0]]) {
+                    return Inputs.Pure(bcs.vector(bcs[second[0]]()).serialize(value));
+                }
+            }
+        }
+    }
+
+    /**
+     * Wrapper for sui's utils normalizeSuiAddress
+     * Perform the following operations:
+     * 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`
+     *
+     * @param {string} address 
+     * @returns string
+     */
+    normalizeSuiAddress(address) {
+        return normalizeSuiAddress(address);
+    }
+
+    /**
+     * As SUI removed websocket dependency for a node, we'll have it here as constructor wrapper
+     *   returning native WebSocket in browser and websocket's w3cwebsocket in node
+     * @returns 
+     */
+    static WebSocketConstructor() {
+        return WebSocketClient;
+    }
+
+    /**
+     * Makes an instance for SuiClient for a specific chain, eg: 'mainnet'
+     * @param {string} chainname 
+     * @returns SuiClient
+     */
+    static suiClientFor(chainname) {
+        return new SuiClient({
+            transport: new SuiHTTPTransport({
+                url: getFullnodeUrl(chainname),
+                WebSocketConstructor: SuiUtils.WebSocketConstructor(),
+            }),
+        });
+    }
+
+    /**
+     * Normalize SuiClient parameter, accepting:
+     *   - different previous versions of sui.js library, 
+     *   - object of SuiClient class
+     *   - object of SuiLocalTestValidator class
+     *   - string of the chain name to connect to
+     * 
+     * @param {SuiClient} client 
+     */
+    static normalizeClient(clientParam) {
+        let client = null;
+        let providerName = null;
+        
+        if (clientParam) {
+            if (clientParam == 'local' || (clientParam.constructor && clientParam.constructor.name && clientParam.constructor.name == 'SuiLocalTestValidator')) {
+                if (clientParam == 'local') {
+                    client = SuiUtils.suiClientFor('localnet');
+                    providerName = 'sui:localnet'; 
+                } else {
+                    // SuiLocalTestValidator
+                    providerName = clientParam.providerName;
+                    client = clientParam.client;
+                }
+            } else if (clientParam == 'test' || clientParam == 'testnet') {
+                client = SuiUtils.suiClientFor('testnet');
+                providerName = 'sui:testnet';
+            } else if (clientParam == 'dev' || clientParam == 'devnet') {
+                client = SuiUtils.suiClientFor('devnet');
+                providerName = 'sui:devnet';
+            } else if (clientParam == 'main' || clientParam == 'mainnet') {
+                client = SuiUtils.suiClientFor('mainnet');
+                providerName = 'sui:mainnet';
+            } else {
+                if (clientParam && clientParam.constructor && clientParam.constructor.name && clientParam.constructor.name == 'SuiClient') {
+                    client = clientParam;
+                    let url = '';
+                    if (clientParam.endpoint) {
+                        // workaround set in SuiInBrowserAdapter
+                        url = clientParam.endpoint;
+                    } else if (clientParam.transport && clientParam.transport.websocketClient && clientParam.transport.websocketClient.endpoint) {
+                        url = clientParam.transport.websocketClient.endpoint;
+                    }
+
+                    if (url.indexOf('devnet') !== -1) {
+                        providerName = 'sui:devnet';
+                    } else if (url.indexOf('testnet') !== -1) {
+                        providerName = 'sui:testnet';
+                    } else if (url.indexOf('mainnet') !== -1) {
+                        providerName = 'sui:mainnet';
+                    } else if (url.indexOf('127.0.0.1') !== -1) {
+                        providerName = 'sui:localnet';
+                    } else {
+                        // just keep provider name as unique to fullnode URL to keep separate ObjectStorage instances
+                        providerName = url.split('//')[1];
+                    }
+                } else if (clientParam && clientParam.connection && clientParam.connection.fullnode) {
+                    client = clientParam;
+
+                    if (clientParam.connection.fullnode.indexOf('devnet') !== -1) {
+                        providerName = 'sui:devnet';
+                    } else if (clientParam.connection.fullnode.indexOf('testnet') !== -1) {
+                        providerName = 'sui:testnet';
+                    } else if (clientParam.connection.fullnode.indexOf('mainnet') !== -1) {
+                        providerName = 'sui:mainnet';
+                    } else if (clientParam.connection.fullnode.indexOf('127.0.0.1') !== -1) {
+                        providerName = 'sui:localnet';
+                    } else {
+                        // just keep provider name as unique to fullnode URL to keep separate ObjectStorage instances
+                        providerName = clientParam.connection.fullnode;
+                    }
+                }
+            }
+        }
+
+        if (client) {
+            client.providerName = providerName;
+            return client;
+        }
+
+        return null;
+    }
+
+};
+
+module.exports = SuiUtils;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "suidouble",
-  "version": "0.0.51",
+  "version": "1.0.4-2",
   "description": "Set of provider, package and object classes for javascript representation of Sui Move smart contracts. Use same code for publishing, upgrading, integration testing, interaction with smart contracts and integration in browser web3 dapps",
   "main": "index.js",
   "scripts": {
@@ -21,8 +21,9 @@
   "author": "Jeka Kiselyov <jeka911@gmail.com> (https://github.com/jeka-kiselyov)",
   "license": "Apache-2.0",
   "dependencies": {
-    "@mysten/sui.js": "^0.43.3",
-    "@wallet-standard/core": "^1.0.3"
+    "@mysten/sui": "^1.0.4",
+    "@wallet-standard/core": "^1.0.3",
+    "websocket": "^1.0.35"
   },
   "devDependencies": {
     "tap": "^16.3.4"

package/test/coins.test.js

@@ -3,7 +3,7 @@
 const t = require('tap');
 const { test } = t;
 
-const { SuiMaster, SuiLocalTestValidator, TransactionBlock } = require('..');
+const { SuiMaster, SuiLocalTestValidator, Transaction } = require('..');
 
 let suiLocalTestValidator = null;
 let suiMaster = null;
@@ -18,7 +18,7 @@ test('spawn local test node', async t => {
 });
 
 test('init suiMaster and connect it to local test validator', async t => {
-    suiMaster = new SuiMaster({provider: 'local', as: 'somebody', debug: true});
+    suiMaster = new SuiMaster({client: 'local', as: 'somebody', debug: true});
     await suiMaster.initialize();
 
     t.ok(suiMaster.address); // there should be some address
@@ -56,16 +56,16 @@ test('string representation works ok', async t => {
     await suiCoin.getMetadata();
 
     const toDisplay1 = suiCoin.amountToString(suiMaster.MIST_PER_SUI);
-    t.equals(toDisplay1, '1.0');
+    t.equal(toDisplay1, '1.0');
 
     const toDisplay2 = suiCoin.amountToString(1); // 1 mist
-    t.equals(toDisplay2, '0.000000001');
+    t.equal(toDisplay2, '0.000000001');
 
     const toDisplay3 = suiCoin.amountToString(suiMaster.MIST_PER_SUI * BigInt(1000) + BigInt(1)); // 1000 SUI + 1 mist
-    t.equals(toDisplay3, '1000.000000001');
+    t.equal(toDisplay3, '1000.000000001');
 
     const toDisplay4 = suiCoin.amountToString(suiMaster.MIST_PER_SUI * BigInt(1000) - BigInt(1)); // 1000 SUI - 1 mist
-    t.equals(toDisplay4, '999.999999999');
+    t.equal(toDisplay4, '999.999999999');
 });
 
 test('you have no SUI on the fresh node', async t => {
@@ -87,12 +87,12 @@ test('getting coin objects for a transaction', async t => {
 
     const wasBalance = await suiCoin.getBalance(suiMaster.address);
 
-    const txb = new TransactionBlock();
-    const coinInput = await suiCoin.coinOfAmountToTxCoin(txb, suiMaster.address, suiMaster.MIST_PER_SUI); // pick 1 SUI
-    txb.transferObjects([coinInput], txb.pure('0x1d20dcdb2bca4f508ea9613994683eb4e76e9c4ed371169677c1be02aaf0b12a')); // send it anywhere
+    const tx = new Transaction();
+    const coinInput = await suiCoin.coinOfAmountToTxCoin(tx, suiMaster.address, suiMaster.MIST_PER_SUI); // pick 1 SUI
+    tx.transferObjects([coinInput], tx.pure('0x1d20dcdb2bca4f508ea9613994683eb4e76e9c4ed371169677c1be02aaf0b12a')); // send it anywhere
 
-    const result = await suiMaster.signAndExecuteTransactionBlock({
-        transactionBlock: txb,
+    const result = await suiMaster.signAndExecuteTransaction({
+        transaction: tx,
         requestType: 'WaitForLocalExecution',
         options: {
         },