suidouble 0.0.3

package/lib/SuiInBrowser.js

@@ -0,0 +1,284 @@
+const SuiCommonMethods = require('./SuiCommonMethods.js');
+const SuiInBrowserAdapter = require('./SuiInBrowserAdapter.js');
+const WalletsStandardCore = require('@wallet-standard/core');
+const icons = require('./data/icons.json');
+const { JsonRpcProvider } = require('@mysten/sui.js');
+const SuiMaster = require('./SuiMaster.js');
+
+class SuiInBrowser extends SuiCommonMethods {
+    constructor(params = {}) {
+        super(params);
+
+        this._adapters = {};
+
+        this._defaultChain = 'sui:devnet';
+
+        this._activeAdapter = null;
+        this._connectedAddress = null;
+        this._connectedChain = null;
+        this._isConnected = false;
+        this._isConnecting = false;
+
+        this._provider = null;
+        this._suiMaster = null;
+
+        setTimeout(()=>{
+            this.initialize();
+        }, 50);
+    }
+
+    getAddress() {
+        return this._connectedAddress;
+    }
+
+    async signAndExecuteTransactionBlock(params) {
+        return await this._activeAdapter.signAndExecuteTransactionBlock(params);
+    }
+
+    get provider() {
+        return this._provider;
+    }
+
+    async getProvider() {
+        await this.initProvider();
+        return this._provider;
+    }
+
+    async getSuiMaster() {
+        await this.initProvider();
+        return this._suiMaster;
+    }
+
+    get suiMaster() {
+        return this._suiMaster;
+    }
+
+    get isConnected() {
+        return this._isConnected;
+    }
+
+    get connectedAddress() {
+        return this._connectedAddress;
+    }
+
+    get connectedChain() {
+        return this._connectedChain;
+    }
+
+    static _singleInstance = null;
+    static getSingleton(params = {}) {
+        if (SuiInBrowser._singleInstance) {
+            return SuiInBrowser._singleInstance;
+        }
+
+        SuiInBrowser._singleInstance = new SuiInBrowser(params);
+        return SuiInBrowser._singleInstance;
+    }
+
+    get adapters() {
+        return this._adapters;
+    }
+
+    async connect(adapterOrAdapterName) {
+        let adapterName = adapterOrAdapterName;
+        if (adapterOrAdapterName.name) {
+            adapterName = adapterOrAdapterName.name;
+        }
+
+        if (!this._adapters[adapterName]) {
+            return false;
+        }
+        this._activeAdapter = this._adapters[adapterName];
+
+        this._isConnecting = true;
+        try {
+            await this._activeAdapter.connect();
+        } catch (e) {
+            this.log('error', e);
+        }
+        this._isConnecting = false;
+    }
+
+    adapterConnected(suiInBrowserAdapter) {
+        this._activeAdapter = suiInBrowserAdapter;
+        this._isConnected = suiInBrowserAdapter.isConnected;
+        this._connectedAddress = suiInBrowserAdapter.connectedAddress;
+        const wasConnectedToChain = this._connectedChain;
+        this._connectedChain = suiInBrowserAdapter.connectedChain;
+
+        if (this._connectedChain != wasConnectedToChain) {
+            this.log('chain was switched');
+            this._provider = null;
+            this._suiMaster = null;
+        }
+
+        this.initProvider();
+
+        this.emit('connected');
+    }
+
+    adapterDisconnected(suiInBrowserAdapter) {
+        this._isConnected = false;
+        this._connectedAddress = null;
+
+        this.emit('disconnected');
+    }
+
+    attachAdapter(adapterParams) {
+        let adapterName = adapterParams.name;
+        if (adapterParams.standartAdapter && adapterParams.standartAdapter.name) {
+            adapterName = adapterParams.standartAdapter.name;
+        }
+
+        if (!adapterName) {
+            return false;
+        }
+
+        const adapter = new SuiInBrowserAdapter({
+            ...adapterParams,
+            debug: this._debug,
+        });
+        if (this._adapters[adapterName]) {
+            // already attached
+            if (adapterParams.standartAdapter) {
+                this._adapters[adapterName].setStandartAdapter(adapterParams.standartAdapter);
+            }
+        } else {
+            this._adapters[adapterName] = adapter;
+            this._adapters[adapterName].addEventListener('connected', (e)=>{
+                this.adapterConnected(e.detail);
+            });
+            this._adapters[adapterName].addEventListener('disconnected', (e)=>{
+                this.adapterDisconnected(e.detail);
+            });
+            this.emit('adapter', adapter);
+        }
+    }
+
+    getCurrentChain() {
+        return this._connectedChain ? this._connectedChain : this._defaultChain;
+    }
+
+    async initProvider() {
+        if (this._provider) {
+            return true;
+        }
+
+        let chainName = this.getCurrentChain();
+        const chainSettings = SuiInBrowser.getChainsSettings();
+        // https://github.com/MystenLabs/sui/blob/827f1138a09190975172ec99389751ca95cce5df/sdk/typescript/src/rpc/connection.ts#L32
+
+        if (!chainSettings[chainName]) {
+            this.log('error', 'invalid chain', chainName);
+            throw new Error('invalid chain: '+chainName);
+        }
+
+        this._provider = new JsonRpcProvider(chainSettings[chainName]);
+        this._suiMaster = new SuiMaster({
+            debug: this._debug,
+            signer: this,
+            provider: this._provider,
+        });
+    }
+
+    async initialize() {
+        await this.initProvider(); // set default provider
+
+        // create empty adapters (we need instances even if they are not installed)
+        for (const possibleAdapterParams of SuiInBrowser.getPossibleWallets()) {
+            this.attachAdapter(possibleAdapterParams);
+        }
+
+        const walletsCore = WalletsStandardCore.getWallets();
+        const standartAdapters = walletsCore.get();
+        for (const standartAdapter of standartAdapters) {
+            this.attachAdapter({
+                standartAdapter: standartAdapter,
+            });
+        }
+        walletsCore.on('register', (what)=>{
+            const adapterName = what.name;
+            if (adapterName) {
+                this.attachAdapter({
+                    standartAdapter: what,
+                });
+            }
+        });
+
+
+    }
+
+    static getChainsSettings() {
+        return {
+            'sui:devnet': {
+                fullnode: 'https://fullnode.devnet.sui.io:443/',
+                websocket: 'https://fullnode.devnet.sui.io:443/',
+                faucet: 'https://faucet.devnet.sui.io/gas',
+            },
+            'sui:testnet': {
+                fullnode: 'https://fullnode.testnet.sui.io:443/',
+                websocket: 'https://fullnode.testnet.sui.io:443/',
+                faucet: 'https://faucet.testnet.sui.io/gas',
+            },
+            'sui:mainnet': {
+                fullnode: 'https://fullnode.mainnet.sui.io:443/',
+                websocket: 'https://fullnode.mainnet.sui.io:443/',
+            },
+            'sui:localnet': {
+                websocket: 'http://127.0.0.1:9000',
+                fullnode: 'http://127.0.0.1:9000',
+                websocket: 'http://127.0.0.1:9000',
+                faucet: 'http://127.0.0.1:9123/gas',
+            },
+        };
+    }
+
+    static getPossibleWallets() {
+        return [
+            {
+                name: 'Sui Wallet',
+                icon: icons['SUI'],
+                downloadUrls: {
+                    chrome: 'https://chrome.google.com/webstore/detail/sui-wallet/opcgpfmipidbgpenhmajoajpbobppdil',
+                },
+            },
+            {
+                name: 'Suiet',
+                icon: icons['SUIET'],
+                downloadUrls: {
+                    chrome: 'https://chrome.google.com/webstore/detail/suiet-sui-wallet/khpkpbbcccdmmclmpigdgddabeilkdpd',
+                },
+            },
+            {
+                name: 'GlassWallet',
+                icon: icons['GLASS'],
+                downloadUrls: {
+                    chrome: 'https://chrome.google.com/webstore/detail/glass-wallet-sui-wallet/loinekcabhlmhjjbocijdoimmejangoa',
+                },
+            },
+            {
+                name: 'Ethos Wallet',
+                icon: icons['ETHOS'],
+                downloadUrls: {
+                    chrome: 'https://chrome.google.com/webstore/detail/ethos-sui-wallet/mcbigmjiafegjnnogedioegffbooigli',
+                },
+            },
+            {
+                name: 'Surf Wallet',
+                icon: icons['SURF'],
+                downloadUrls: {
+                    chrome: 'https://chrome.google.com/webstore/detail/surf-wallet/emeeapjkbcbpbpgaagfchmcgglmebnen',
+                },
+            },
+            {
+                name: 'Nightly Wallet',
+                icon: icons['NIGHTLY'],
+                downloadUrls: {
+                    chrome: 'https://chrome.google.com/webstore/detail/nightly/fiikommddbeccaoicoejoniammnalkfa',
+                },
+            },
+        ];
+    }
+};
+
+module.exports = SuiInBrowser;

package/lib/SuiInBrowserAdapter.js

@@ -0,0 +1,181 @@
+const SuiCommonMethods = require('./SuiCommonMethods.js');
+// const WalletsStandardCore = require('@wallet-standard/core');
+// const icons = require('./data/icons.json');
+
+const Feature = {
+    DISCONNECT: 'standard:disconnect',
+    CONNECT: 'standard:connect',
+    EVENTS: 'standard:events',
+    SUI_SIGN_AND_EXECUTE_TX_BLOCK: 'sui:signAndExecuteTransactionBlock',
+    SUI_SIGN_TX_BLOCK: 'sui:signTransactionBlock',
+    SUI_SIGN_MESSAGE: 'sui:signMessage'
+};
+
+class SuiInBrowserAdapter extends SuiCommonMethods {
+    constructor(params = {}) {
+        super(params);
+
+        this._standartAdapter = null;
+        //  params.standartAdapter || null; // instance returned from '@wallet-standard/core'
+        if (params.standartAdapter) {
+            this.setStandartAdapter(params.standartAdapter);
+        }
+        
+        this._name = params.name || null;
+        this._icon = params.icon || null;
+        this._downloadUrls = params.downloadUrls || {};
+
+        this._connectedAddress = null;
+        this._connectedChain = null;
+        this._isConnected = false;
+    }
+
+    getDownloadURL() {
+        if (this._downloadUrls && this._downloadUrls.chrome) {
+            return this._downloadUrls.chrome;
+        }
+        return null;
+    }
+
+    get isDefault() {
+        if (!this._standartAdapter) {
+            return true;
+        }
+        return false;
+    }
+
+    get connectedAddress() {
+        return this._connectedAddress;
+    }
+
+    get connectedChain() {
+        return this._connectedChain;
+    }
+
+    get isConnected() {
+        return this._isConnected;
+    }
+
+    async connect() {
+        try {
+            await this.getFeature(Feature.CONNECT).connect();
+        } catch (e) {
+            console.error(e);
+        }
+
+        this.connectionUpdated();
+    }
+
+    connectionUpdated() {
+        const wasConnectedAddress = ''+this._connectedAddress;
+        const wasConnectedChain = ''+this._connectedChain;
+
+        try {
+            if (this._standartAdapter && this._standartAdapter.accounts && this._standartAdapter.accounts.length) {
+                this._connectedAddress = this._standartAdapter.accounts[0].address;
+                this._connectedChain = this._standartAdapter.accounts[0].chains[0];
+            } else {
+                this._connectedAddress = null;
+                this._connectedChain = null;
+            }
+        } catch (e) {
+            this._connectedAddress = null;
+            this._connectedChain = null;
+        }
+
+        if ((''+this._connectedAddress) != wasConnectedAddress || (''+this._connectedChain) != wasConnectedChain) {
+            if (this._connectedAddress && this._connectedChain) {
+                this._isConnected = true;
+                this.emit('connected', this);
+            } else {
+                this._isConnected = false;
+                this.emit('disconnected', this);
+            }
+        }
+    }
+
+
+    setStandartAdapter(standartAdapter) {
+        if (this._standartAdapter) {
+            // no need to re-attach
+            return true;
+        }
+
+        this._standartAdapter = standartAdapter;
+        if (!this.__standartAdapterChangeListener) {
+            this.__standartAdapterChangeListener = (e) => {
+                this.connectionUpdated();
+            };
+        }
+        this.getFeature(Feature.EVENTS).on('change', this.__standartAdapterChangeListener);
+
+        this.connectionUpdated();
+    }
+
+    async signAndExecuteTransactionBlock(params) {
+        return await this.getFeature(Feature.SUI_SIGN_AND_EXECUTE_TX_BLOCK).signAndExecuteTransactionBlock(params);
+        // console.log(this.getFeature(Feature.SUI_SIGN_AND_EXECUTE_TX_BLOCK));
+    }
+
+    get okForSui() {
+        if (!this.isInstalled) {
+            return false;
+        }
+
+        return this.hasFeature(Feature.SUI_SIGN_AND_EXECUTE_TX_BLOCK) && this.hasFeature(Feature.EVENTS);
+    }
+
+    get isInstalled() {
+        if (this._standartAdapter) {
+            return true;
+        }
+        return false;
+    }
+
+    get features() {
+        if (this._standartAdapter) {
+            return this._standartAdapter.features;
+        }
+        return {};
+    }
+
+    get name() {
+        if (this._standartAdapter) {
+            return this._standartAdapter.name;
+        } else {
+            return this._name;
+        }
+    }
+
+    get icon() {
+        if (this._standartAdapter) {
+            return this._standartAdapter.icon;
+        } else {
+            return this._icon;
+        }
+    }
+
+    get version() {
+        if (this._standartAdapter) {
+            return this._standartAdapter.version;
+        }
+    }
+
+    hasFeature(featureName) {
+        return (!!this.getFeature(featureName));
+    }
+
+    getFeature(featureName) {
+        const features = this.features;
+
+        if (features && features[Feature[featureName]]) {
+            return features[Feature[featureName]];
+        }
+        if (features && features[featureName]) {
+            return features[featureName];
+        }
+        return null;
+    }
+};
+
+module.exports = SuiInBrowserAdapter;

package/lib/SuiLocalTestValidator.js

@@ -0,0 +1,93 @@
+// const { spawn } = require('child_process');
+const SuiCliCommands = require('./SuiCliCommands.js');
+const SuiCommonMethods = require('./SuiCommonMethods.js');
+
+class SuiLocalTestValidator extends SuiCommonMethods {
+    constructor(params = {}) {
+        super(params);
+
+        this._child = null;
+        this._active = false;
+    }
+
+    static async launch(params = {}) {
+        if (SuiLocalTestValidator.__instance) {
+            return await SuiLocalTestValidator.__instance.launch();
+        }
+
+        SuiLocalTestValidator.__instance = new SuiLocalTestValidator(params);
+        return await SuiLocalTestValidator.__instance.launch();
+    }
+
+    static async stop() {
+        if (SuiLocalTestValidator.__instance) {
+            return await SuiLocalTestValidator.__instance.stop();
+        }
+    }
+
+    async launch() {
+        if (this._child && this._active) {
+            return true;
+        }
+
+        this.log('launching sui-test-validator ...');
+
+        this._child = await SuiCliCommands.spawn('sui-test-validator', { RUST_LOG: 'consensus=off' });
+        
+        // spawn('sui-test-validator', [], {
+        //     env: {
+        //         ...process.env,
+        //         RUST_LOG: 'consensus=off',
+        //     }
+        // });
+
+        this.__readyLaunchedPromiseResolver = null;
+        this.__readyLaunchedPromise = new Promise((res)=>{
+            this.__readyLaunchedPromiseResolver = res;
+        });
+
+        this._child.stdout.on('data', (data) => {
+            this.log(`stdout:\n${data}`);
+            if ((`${data}`).indexOf('Fullnode RPC URL') !== -1) {
+                this._active = true;
+
+                this.log('sui-test-validator launched');
+                this.__readyLaunchedPromiseResolver();
+            }
+        });
+        
+        this._child.stderr.on('data', (data) => {
+            this.log(`stderr: ${data}`);
+        });
+        
+        this._child.on('error', (error) => {
+            this.log(`error: ${error.message}`);
+        });
+        
+        this._child.on('close', (code) => {
+            this._active = false;
+            this.log(`child process exited with code ${code}`);
+        });
+
+        process.on('exit', ()=>{
+            if (this._child) {
+                this._child.kill();
+            }
+        });
+        const cleanExit = function() { process.exit() };
+        process.on('SIGINT', cleanExit); // catch ctrl-c
+        process.on('SIGTERM', cleanExit); // catch kill
+
+        await this.__readyLaunchedPromise;
+
+        return this;
+    }
+
+    async stop() {
+        if (this._child) {
+            await this._child.kill();
+        }
+    }
+}
+
+module.exports = SuiLocalTestValidator;