suidouble 1.13.0 → 1.14.2-1

package/README.md

@@ -43,7 +43,7 @@ npm install suidouble --save
 Main class to interact with blockchain is SuiMaster:
 
 ```javascript
-const { SuiMaster } = require('suidouble');
+import { SuiMaster } from 'suidouble';
 ```
 
 You can initialize it directly, if you have keypair, secret phrase, or privateKey and can use it in code (so on node.js side - server side or CLI apps):
@@ -85,7 +85,7 @@ const suiMasterAsUser = new SuiMaster({ as: 'user', client: 'dev', });
 
 On browser side, you'd probably want to use Sui wallets extensions adapters to sign message and don't store any keypairs or secret phrases in your code. So there's SuiInBrowser class for this, which can setup suiMaster instance for you. See 'Sui Move Connect in browser' section or sample UI application's code for more details.
 ```javascript
-const { SuiInBrowser } = require('suidouble');
+import { SuiInBrowser } from 'suidouble';
 const suiInBrowser = SuiInBrowser.getSingleton(); // you probably don't want to keep few connections, so there's singleton
 /// ...
 suiInBrowser.addEventListener('connected', async()=>{
@@ -175,32 +175,6 @@ while (events.hasNextPage) {
 
 *** Subscribe to Events is deprecated in Sui SDK *** You should plan to use different architecture in your application.
 
-You can subscribe to Sui's contract events on package's module level. 
-
-```javascript
-const module = await contract.getModule('suidouble_chat');
-await module.subscribeEvents();
-module.addEventListener('ChatResponseCreated', (suiEvent)=>{
-    // received message emited by 
-    // emit(ChatResponseCreated { id: object::uid_to_inner(&chat_response_id), top_message_id: object::uid_to_inner(&id), seq_n: 0 });
-    // in suidouble_chat 's smart contract
-    console.log(suiEvent.typeName); // == 'ChatResponseCreated'
-    console.log(suiEvent.parsedJson);
-});
-module.addEventListener('ChatTopMessageCreated', (suiEvent)=>{
-    // received message emited by 
-    // emit(ChatTopMessageCreated { id: object::uid_to_inner(&id), top_response_id: object::uid_to_inner(&chat_response_id),  });
-    // in suidouble_chat 's smart contract
-    console.log(suiEvent.typeName); // == 'ChatTopMessageCreated'
-    console.log(suiEvent.parsedJson);
-});
-```
-
-Don't forget to unsubscribe from events when you don't need them anymore:
-
-```javascript
-await module.unsubscribeEvents();
-```
 
 ##### executing smart contract method
 
@@ -302,7 +276,7 @@ Don't forget to test transactions sending real money on devnet/testnet first!
 If you need more flexebility, there's always an option to construct the transaction yourself:
 
 ```javascript
-const { Transaction, txInput } = require('suidobule'); // this exposes classes from the "@mysten/sui.js", so you don't have to import them separately
+import { Transaction, txInput } from 'suidouble'; 
 
 const tx = new Transaction();
 tx.moveCall({
@@ -348,7 +322,8 @@ await paginatedResponse.forEach(async(suiObject)=>{
 Builds a package and publish it to blockchain. CLI thing, as it needs `execSync` to run `sui move build`. Tested on Ubuntu, works good. If you have some issues with other platforms - please feel free to let me know or post Pull Request.
 
 ```javascript
-const { SuiMaster } = require('suidouble');
+import { SuiMaster } from 'suidouble'; 
+
 
 const client = 'dev';
 const suiMaster = new SuiMaster({ debug: true, as: 'admin', client: client, });
@@ -369,7 +344,7 @@ console.log('published as', package.address);
 Same, it's for CLI as it re-builds the package.
 
 ```javascript
-const { SuiMaster } = require('suidouble');
+import { SuiMaster } from 'suidouble'; 
 
 const client = 'local';// or await SuiLocalTestValidator.launch({debug: true, epochDuration: 30000});
 
@@ -394,7 +369,7 @@ CLI integration tests, it runs local testing node (has to be installed), build a
 suidouble try to mimic Sui Move's testing framework:
 
 ```javascript
-const SuiTestScenario = require('./lib/SuiTestScenario.js');
+import { SuiTestScenario } from 'suidouble'; 
 
 const testScenario = new SuiTestScenario({
     path: '../path_to_move_project_root/',
@@ -432,7 +407,7 @@ Check out [suidouble Vue component](https://www.npmjs.com/package/vue-sui) to co
 Or write the one manually, code is framework independed:
 
 ```javascript
-const { SuiInBrowser } = require('suidouble');
+import { SuiInBrowser } from 'suidouble'; 
 
 const suiInBrowser = SuiInBrowser.getSingleton();
 const suiMaster = await suiInBrowser.getSuiMaster(); // not yet connected, works in read-only mode (no signing-posting txs).

package/index.js

@@ -1,22 +1,31 @@
-const SuiMaster = require('./lib/SuiMaster.js');
-const SuiInBrowser = require('./lib/SuiInBrowser.js');
-const SuiTestScenario = require('./lib/SuiTestScenario.js');
-const SuiObject = require('./lib/SuiObject.js');
-const SuiUtils = require('./lib/SuiUtils.js');
-const SuiLocalTestValidator = require('./lib/SuiLocalTestValidator.js');
-const { Transaction, Commands } = require('@mysten/sui/transactions');
-const { bcs } = require('@mysten/sui/bcs');
+import SuiMaster from './lib/SuiMaster.js';
+import SuiInBrowser from './lib/SuiInBrowser.js';
+import SuiTestScenario from './lib/SuiTestScenario.js';
+import SuiObject from './lib/SuiObject.js';
+import SuiUtils from './lib/SuiUtils.js';
+import SuiLocalTestValidator from './lib/SuiLocalTestValidator.js';
+import SuiMemoryObjectStorage from './lib/SuiMemoryObjectStorage.js';
+import SuiCoin from './lib/SuiCoin.js';
+import SuiCoins from './lib/SuiCoins.js';
+import { Transaction, Commands } from '@mysten/sui/transactions';
+import { bcs } from '@mysten/sui/bcs';
 
-module.exports = {
+const txInput = SuiUtils.txInput;
+const MIST_PER_SUI = SuiMaster.MIST_PER_SUI;
+
+export {
     SuiMaster,
     SuiObject,
     SuiInBrowser,
     SuiTestScenario,
     SuiLocalTestValidator,
-    MIST_PER_SUI: SuiMaster.MIST_PER_SUI,
-    Transaction: Transaction,
-    Commands: Commands,
-    SuiUtils: SuiUtils,
-    txInput: SuiUtils.txInput,
+    MIST_PER_SUI,
+    Transaction,
+    Commands,
+    SuiUtils,
+    txInput,
     bcs,
+    SuiMemoryObjectStorage,
+    SuiCoin,
+    SuiCoins,
 };

package/lib/SuiCliCommands.js

@@ -1,23 +1,80 @@
-let doExecSync = null;
-let doSpawn = null;
-let doFs = null;
-let doPath = null;
-try {
-    let { execSync, spawn } = require('child_process');
-    doExecSync = execSync;
-    doSpawn = spawn;
-
-    const fs = require('fs');
-    const path = require('path');
-
-    doFs = fs;
-    doPath = path;
-} catch (e) {
-    console.log('looks we are in browser');
+class ImportError extends Error {}
+
+const loadModule = async (modulePath) => {
+    try {
+        return await import(modulePath)
+    } catch (e) {
+        throw new ImportError(`Unable to import module ${modulePath}`)
+    }
 }
 
-class SuiCliCommands {
+/**
+ * Wrapper to get system function available on node.js side only, returning null on the browser side
+ * @param {string} name - execSync, spawn, fs, path, net
+ * @returns {(function | null)}
+ */
+const getSystemFunction = async (name) => {
+    try {
+        if (name == 'execSync' || name == 'spawn') {
+            const { default: myDefault } = await loadModule('child_process');
+            return myDefault[name];
+        }
+        if (name == 'fs') {
+            const { default: myDefault } = await loadModule('fs');
+            return myDefault;
+        }
+        if (name == 'path') {
+            const { default: myDefault } = await loadModule('path');
+            return myDefault;
+        }
+        if (name == 'net') {
+            const { default: myDefault } = await loadModule('net');
+            return myDefault;
+        }
+    } catch (e) {
+        return null;
+    }
+}
+
+export default class SuiCliCommands {
+    static async isPortThere(port) {
+        const net = await getSystemFunction('net');
+        if (!net) {
+            return false;
+        }
+
+        const Socket = net.Socket;
+        const socket = new Socket();
+
+        let __waitPortPromiseResolver = null;
+        const __waitPortPromise = new Promise((res)=>{ __waitPortPromiseResolver = res; });
+
+        setTimeout(()=>{
+            socket.destroy();
+            __waitPortPromiseResolver(false);
+        }, 3000);
+        socket.on("connect", () => {
+            __waitPortPromiseResolver(true);
+        });
+        socket.on("error", () =>
+        {
+            __waitPortPromiseResolver(false);
+        });
+        socket.on("timeout", () => {
+            __waitPortPromiseResolver(false);
+        });
+
+        socket.connect(port, "0.0.0.0");
+
+        const portIsThere = await __waitPortPromise;
+        socket.destroy();
+
+        return portIsThere;
+    }
+
     static async spawn(command, params = [], envVars = {}) {
+        const doSpawn = await getSystemFunction('spawn');
+
         if (!doSpawn) {
             throw new Error('can not spawn a proccess in this env');
         }
@@ -59,6 +116,8 @@ class SuiCliCommands {
     }
 
     static async exec(command) {
+        const doExecSync = await getSystemFunction('execSync');
+
         if (!doExecSync) {
             throw new Error('can not exec a proccess in this env');
         }
@@ -70,6 +129,9 @@ class SuiCliCommands {
     }
 
     static async getModulesNamesFromPackagePath(path) {
+        const doPath = await getSystemFunction('path');
+        const doFs = await getSystemFunction('fs');
+
         if (!doPath || !doFs) {
             throw new Error('can not access path in this env');
         }
@@ -90,6 +152,4 @@ class SuiCliCommands {
             throw new Error('can not get modules names from local package path');
         }
     }
-}
-
-module.exports = SuiCliCommands;
+};

package/lib/SuiCoin.js

@@ -1,31 +1,33 @@
-const { Commands, Transaction, TransactionObjectArgument } = require('@mysten/sui/transactions');
-const { bcs } = require('@mysten/sui/bcs');
-
-
-const safeList = {
-    'sui:mainnet': {
-        '0xa198f3be41cda8c07b3bf3fee02263526e535d682499806979a111e88a5a8d0f::coin::COIN': 'CELO',
-        '0x027792d9fed7f9844eb4839566001bb6f6cb4804f66aa2da6fe1ee242d896881::coin::COIN': 'tBTC',
-        '0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN': 'USDCeth',
-        '0xe32d3ebafa42e6011b87ef1087bbc6053b499bf6f095807b9013aff5a6ecd7bb::coin::COIN': 'USDCarb',
-        '0x909cba62ce96d54de25bec9502de5ca7b4f28901747bbf96b76c2e63ec5f1cba::coin::COIN': 'USDCbnb',
-        '0xcf72ec52c0f8ddead746252481fb44ff6e8485a39b803825bde6b00d77cdb0bb::coin::COIN': 'USDCpol',
-        '0xb231fcda8bbddb31f2ef02e6161444aec64a514e2c89279584ac9806ce9cf037::coin::COIN': 'USDCsol',
-        '0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c::coin::COIN': 'USDT',
-        '0x1e8b532cca6569cab9f9b9ebc73f8c13885012ade714729aa3b450e0339ac766::coin::COIN': 'WAVAX',
-        '0xb848cce11ef3a8f62eccea6eb5b35a12c4c2b1ee1af7755d02d7bd6218e8226f::coin::COIN': 'WBNB',
-        '0x027792d9fed7f9844eb4839566001bb6f6cb4804f66aa2da6fe1ee242d896881::coin::COIN': 'WBTC',
-        '0xaf8cd5edc19c4512f4259f0bee101a40d41ebed738ade5874359610ef8eeced5::coin::COIN': 'WETH',
-        '0x6081300950a4f1e2081580e919c210436a1bed49080502834950d31ee55a2396::coin::COIN': 'WFTM',
-        '0x66f87084e49c38f76502d17f87d17f943f183bb94117561eb573e075fdc5ff75::coin::COIN': 'WGLMR',
-        '0xdbe380b13a6d0f5cdedd58de8f04625263f113b3f9db32b3e1983f49e2841676::coin::COIN': 'WMATIC',
-        '0xb7844e289a8410e50fb3ca48d69eb9cf29e27d223ef90353fe1bd8e27ff8f3f8::coin::COIN': 'WSOL',
-        '0x2::sui::SUI': 'SUI',
-    },
-};
+import { Commands, Transaction } from '@mysten/sui/transactions';
+
+/**
+ * @typedef {import("@mysten/sui/transactions").TransactionObjectArgument} TransactionObjectArgument
+ * 
+ * 
+ * @typedef CoinMeta
+ * @type {object}
+ * @property {number} decimals - Number of decimal places the coin uses.
+ * @property {string} description - Description of the token
+ * @property {string} iconUrl - URL for the token logo
+ * @property {string} name - Name for the token
+ * @property {string} symbol - Symbol for the token
+ * @property {string} [id] - Meta id
+ * @property {string} [type] - Coin type string
+ * 
+ * 
+ * @typedef SuidoubleCoinBalance
+ * @type {object}
+ * @property {SuiCoin} coin
+ * @property {string} coinType
+ * @property {number} coinObjectCount
+ * @property {bigint} totalBalance
+ * @property {Object.<string,string>} lockedBalance
+ * 
+ */
+
 
 /** Coin metadata object */
-class SuiCoin {
+export default class SuiCoin {
 
     /**
      * SuiCoin constructor
@@ -97,10 +99,6 @@ class SuiCoin {
         return this._suiCoins.suiMaster;
     }
 
-    static safeList(connectedChain) {
-        return safeList[connectedChain];
-    }
-
     get coinType() {
         if (this._coinType.indexOf('0x') === 0) {
             return this._coinType;
@@ -129,29 +127,7 @@ class SuiCoin {
         return this._metadata;
     }
 
-    get safeList() {
-        if (this.suiMaster && this.suiMaster.connectedChain) {
-            if (safeList[this.suiMaster.connectedChain]) {
-                return safeList[this.suiMaster.connectedChain];
-            }
-        }
-
-        return {};
-    }
-
-    get isSafe() {
-        if (this.safeList[this.coinType]) {
-            return true;
-        }
-
-        return false;
-    }
-
     get symbol() {
-        if (this.safeList[this.coinType]) {
-            return this.safeList[this.coinType];
-        }
-
         if (this.metadata) {
             return this.metadata.symbol;
         }
@@ -165,9 +141,24 @@ class SuiCoin {
 
     isSUI() {
         const lc = this._coinType.toLowerCase();
-        if (lc == 'sui' || lc.indexOf(':sui:') !== -1) {
+        if (lc == '0x0000000000000000000000000000000000000000000000000000000000000002::sui::sui') { // as it's normalized
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * set predefined coin metadata so it will not be fetched from RPC
+     * @param {CoinMeta} meta
+     * @returns {boolean} if processed ok
+     */
+    setMetadata(meta) {
+        if (meta && meta.decimals && meta.decimals > 0 && meta.name && meta.symbol) {
+            this._metadata = meta;
+            this._exists = true;
             return true;
         }
+
         return false;
     }
 
@@ -189,6 +180,7 @@ class SuiCoin {
             this._exists = false;
         } else {
             this._metadata = result;
+            this._exists = true;
         }
 
         return this._metadata;
@@ -218,6 +210,7 @@ class SuiCoin {
         return totalAmount;
     }
 
+
     /**
      * Returns TransactionObjectArgument with Coin of amount to be used in tranasctions
      * 
@@ -300,6 +293,4 @@ class SuiCoin {
 
         return null;
     }
-}
-
-module.exports = SuiCoin;
+};

package/lib/SuiCoins.js

@@ -1,17 +1,43 @@
-const SuiCoin = require('./SuiCoin.js');
-const SuiCommonMethods = require('./SuiCommonMethods.js');
+import SuiCoin from './SuiCoin.js';
+import SuiCommonMethods from './SuiCommonMethods.js';
+import { allCoinMetas } from '@polymedia/coinmeta';
+import { normalizeStructTag } from "@mysten/sui/utils";
+
+/**
+ * @typedef {import("./SuiCoin.js").CoinMeta} CoinMeta
+ * @typedef {import("./SuiCoin.js").SuidoubleCoinBalance} SuidoubleCoinBalance
+ * @typedef {import("./SuiMaster.js").default} SuiMaster
+ */
+
+/**
+ * Common class to work with Coins and Coin objects. Expected to have single instance per SuiMaster instance
+ * @class
+ * @constructor
+ * @public
+ */
+export default class SuiCoins extends SuiCommonMethods {
 
-class SuiCoins extends SuiCommonMethods {
+    /**
+     * SuiCoins constructor
+     * @param {Object} params - Initialization parameters
+     * @param {SuiMaster} params.suiMaster - instance of SuiMaster
+     */
     constructor(params = {}) {
         super(params);
         
+        /** @type {SuiMaster} */
         this._suiMaster = params.suiMaster;
         if (!this._suiMaster) {
             throw new Error('suiMaster is required');
         }
+
+        /** @type {Object.<string, SuiCoin>} */
         this._coins = {};
 
-        this._isInitialized = false;
+        if (this._suiMaster.onMainnet) {
+            // pre-cached coins metadata
+            this.setCoinMetas(allCoinMetas);
+        }
     }
 
     get suiMaster() {
@@ -23,84 +49,101 @@ class SuiCoins extends SuiCommonMethods {
     }
 
     /**
-     * Optional common initialized to get a list and metadata of all safe coins defined in SuiCoin.js
+     * set predefined coin metas so they will not be fetched from RPC
+     * @param {(Object.<string, CoinMeta> | Array.<CoinMeta>)}
+     * @returns {number} count of processed items
      */
-    async init() {
-        if (this._isInitialized) {
-            return true;
+    setCoinMetas(coinMetas) {
+        let processedCount = 0;
+        if (Array.isArray(coinMetas)) {
+            // [CoinMeta, CoinMeta]
+            for (const coinMeta of coinMetas) {
+                if (coinMeta.type) {
+                    const suiCoin = this.get(coinMeta.type);
+                    const ok = suiCoin.setMetadata(coinMeta);
+                    if (ok) {
+                        processedCount++;
+                    }
+                }
+            }
+        } else {
+            // {type: CoinMeta, type: CoinMeta}
+            for (const coinType in coinMetas) {
+                const suiCoin = this.get(coinType);
+                const ok = suiCoin.setMetadata(coinMetas[coinType]);
+                if (ok) {
+                    processedCount++;
+                }
+            }
         }
 
-        const safeList = SuiCoin.safeList(this._suiMaster.connectedChain);
-        const metadataPromises = [];
-        for (const coinType in safeList) {
-            const normalizedCoinType = this.normalizeCoinType(coinType);
-            if (!this._coins[normalizedCoinType]) {
-                const suiCoin = new SuiCoin({
-                    coinType: normalizedCoinType,
-                    suiCoins: this,
-                });
-                console.log('adding coin with type', normalizedCoinType);
-                this._coins[normalizedCoinType] = suiCoin;
-
-                const metadataPromise = new Promise(async(res)=>{
-                    try {
-                        await suiCoin.getMetadata();
-                    } catch (e) {
-                        console.error(e);
-                    }
+        return processedCount;
+    }
 
-                    res();
-                });
-                metadataPromises.push(metadataPromise);
-            }
+    /**
+     * Get all CoinBalance[] for the specific address or connected address
+     * 
+     * @param {Object} params
+     * @param {string?} params.owner - owner address, if skipped - will query for connected wallet address
+     * 
+     * @returns {Promise.<Array.<SuidoubleCoinBalance>>}
+     */
+    async getAllBalances(params = {}) {
+        let owner = params.owner;
+        if (!owner) {
+            owner = this._suiMaster.address;
         }
 
-        await Promise.all(metadataPromises);
+        /** @type {Array.<SuidoubleCoinBalance>} */
+        const ret = [];
+
+        const nativeCoinBalances = await this._suiMaster.client.getAllBalances({
+                owner,
+            });
+
+        for (const nativeCoinBalance of nativeCoinBalances) {
+            /** @type {SuidoubleCoinBalance} */
+            const coinBalance = {
+                coin: this.get(nativeCoinBalance.coinType),
+                coinType: nativeCoinBalance.coinType,
+                coinObjectCount: nativeCoinBalance.coinObjectCount,
+                totalBalance: BigInt(nativeCoinBalance.totalBalance),
+                lockedBalance: nativeCoinBalance.lockedBalance,                
+            };
+            ret.push(coinBalance);
+        }
 
-        this._isInitialized = true;
+        return ret;
     }
 
+    /**
+     * normalize coinType string to sui's coin type. As extra, may take 'sui' or 'SUI' as the type and return type for it
+     * @param {string} coinType
+     * @returns {string} normalized coin type
+     */
     normalizeCoinType(coinType) {
-        if (coinType.indexOf('::') == -1) {
-            if (coinType.toLowerCase() == 'sui') {
-                return '0x2::sui::SUI';
-            } else {
-                for (const key in this._coins) {
-                    if (key == coinType) {
-                        return this._coins[key].coinType;
-                    }
-                }
-
-                const safeList = SuiCoin.safeList(this._suiMaster.connectedChain);
-                for (const key in safeList) {
-                    if (safeList[key] == coinType) {
-                        return key;
-                    }
-                }
-            }
+        let nCoinType = (''+coinType);
 
-            if (coinType.indexOf('0x') == -1) {
-                return '0x'+coinType+'::coin::COIN';
-            } else {
-                return ''+coinType+'::coin::COIN';
+        if (nCoinType.indexOf('::') == -1) {
+            if (nCoinType.toLowerCase() == 'sui') {
+                nCoinType = '0x2::sui::SUI';
             }
         }
 
-        if (coinType.indexOf('0x') == -1) {
-            coinType = '0x'+coinType;
+        if (nCoinType.indexOf('0x') == -1) {
+            nCoinType = '0x'+nCoinType;
         }
 
-        if (coinType == '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI') {
-            return '0x2::sui::SUI';
-        }
+        nCoinType = normalizeStructTag(nCoinType);
 
-        return coinType;
+        return nCoinType;
     }
 
     /**
      * Return instance of SuiCoin of specific type
      * 
      * @param {string} coinType - MoveType, or 'SUI' as helper
+     * 
      * @returns {SuiCoin}
      */
     get(coinType) {
@@ -121,6 +164,14 @@ class SuiCoins extends SuiCommonMethods {
     }
 
     static _singleInstances = {};
+
+    /**
+     * Return singleton instance of the SuiCoins object for the specific chain
+     * 
+     * @param {Object} params - parameters
+     * @param {SuiMaster} params.suiMaster - instance of SuiMaster
+     * @returns {SuiCoins}
+     */
     static getSingleton(params = {}) {
         const suiMaster = params.suiMaster;
         const connectedChain = suiMaster.connectedChain;
@@ -133,6 +184,4 @@ class SuiCoins extends SuiCommonMethods {
         return SuiCoins._singleInstances[connectedChain];
     }
 
-};
-
-module.exports = SuiCoins;
+};

package/lib/SuiCommonMethods.js

@@ -12,7 +12,7 @@ class CustomEvent extends Event {
 	}
 }
 
-class SuiCommonMethods extends EventTarget {
+export default class SuiCommonMethods extends EventTarget {
     constructor(params = {}) {
 		super();
 
@@ -42,6 +42,4 @@ class SuiCommonMethods extends EventTarget {
 			console.error(e);
 		}
 	}
-}
-
-module.exports = SuiCommonMethods;
+};

package/lib/SuiEvent.js

@@ -1,6 +1,6 @@
 
 
-class SuiEvent extends Event {
+export default class SuiEvent extends Event {
     constructor(params = {}) {
         const typeName = params.data ? ((''+params.data.type).split('<')[0].split('::').pop()) : null;
         super(typeName, {});
@@ -58,6 +58,4 @@ class SuiEvent extends Event {
             return null;
         }
     }
-};
-
-module.exports = SuiEvent;
+};