suidouble 0.0.3

package/lib/SuiMaster.js

@@ -0,0 +1,199 @@
+const sui = require('@mysten/sui.js');
+const SuiCommonMethods = require('./SuiCommonMethods.js');
+const SuiPackage = require('./SuiPackage.js');
+const SuiPseudoRandomAddress = require('./SuiPseudoRandomAddress.js');
+const SuiMemoryObjectStorage = require('./SuiMemoryObjectStorage.js');
+
+class SuiMaster extends SuiCommonMethods {
+    constructor(params = {}) {
+        super(params);
+        
+        // quick value to differenciate instances (if there're few) in logs
+        SuiMaster.instancesCount++;
+        this._instanceN = SuiMaster.instancesCount;
+
+        this._signer = null;
+        this._keypair = null;
+
+        if (params.signer) {
+            this._signer = params.signer;
+        } else if (params.keypair) {
+            this._keypair = params.keypair;
+        } else if (params.phrase) {
+            this._keypair = sui.Ed25519Keypair.deriveKeypair(params.phrase);
+
+            this.log('goint to use keypair of', this._keypair.getPublicKey().toSuiAddress());
+        } else if (params.as) {
+            // generate pseudo-random keypair
+            this._keypair = SuiPseudoRandomAddress.stringToKeyPair(params.as);
+
+            this.log('goint to use keypair of', this._keypair.getPublicKey().toSuiAddress());
+        }
+
+        this._provider = null;
+        this._providerName = null;
+        if (params.provider) {
+            if (params.provider == 'local' || (params.provider.constructor && params.provider.constructor.name && params.provider.constructor.name == 'SuiLocalTestValidator')) {
+                this._provider = new sui.JsonRpcProvider(sui.localnetConnection);
+                this._providerName = 'local'; 
+            } else if (params.provider == 'test' || params.provider == 'testnet') {
+                this._provider = new sui.JsonRpcProvider(sui.testnetConnection);
+                this._providerName = 'test';
+            } else if (params.provider == 'dev' || params.provider == 'devnet') {
+                this._provider = new sui.JsonRpcProvider(sui.devnetConnection);
+                this._providerName = 'dev';
+            } else {
+                if (params.provider && params.provider.connection && params.provider.connection.fullnode) {
+                    this._provider = params.provider;
+                    this._providerName = params.provider.connection.fullnode;
+                }
+            }
+        }
+
+        if (!this._provider) {
+            throw new Error('Can not do anything without provider. Set params.provider at least to `local`');
+        }
+
+        // we are differient single instances of object storage by provider name (so we can separate like devnet-testnet entities if needed)
+        this._objectStorage = SuiMemoryObjectStorage.instanceOf(this._providerName, {
+            debug: this._debug,
+        });
+
+        this._initialized = false;
+
+        this._address = null;
+
+        this._packages = {};
+    }
+
+    get objectStorage() {
+        return this._objectStorage;
+    }
+
+    get instanceN() {
+        return this._instanceN;
+    }
+
+    static instancesCount = 0;
+
+    get provider() {
+        return this._provider;
+    }
+
+    get address() {
+        return this._address;
+    }
+
+    get signer() {
+        return this._signer;
+    }
+
+    package(params = {}) {
+        return this.addPackage(params);
+    }
+
+    addPackage(params = {}) {
+        if (params.id && this._packages[params.id]) {
+            return this._packages[params.id];
+        }
+        const suiPackage = new SuiPackage({
+            ...params,
+            debug: this._debug,
+            suiMaster: this,
+        });
+
+        if (params.id) {
+            this._packages[params.id] = suiPackage;
+        }
+
+        return suiPackage;
+    }
+
+    async getProvider() {
+        await this.initialize();
+        return this._provider;
+    }
+
+    async initialize() {
+        if (this._initialized) {
+            return true;
+        }
+
+        this.log('initializing...');
+
+        this._initialized = true;
+
+        // this._keypair = sui.Ed25519Keypair.deriveKeypair(this._phrase);
+        if (!this._signer && this._keypair) { // we may optionally go without signer, to work in read-only mode
+            this._signer = new sui.RawSigner(this._keypair, this._provider);
+        }
+
+        // const publicKey = this._keypair.getPublicKey();
+        // this._address = publicKey.toSuiAddress();
+        if (this._signer) {
+            this._address = await this._signer.getAddress();
+            // console.log(this._signer);
+            // console.log(this._providerName);
+            this.log('initialized. connected as', this._address);
+        } else {
+            this.log('initialized in read-only mode.');
+        }
+
+
+        return true;
+    }
+
+    async requestSuiFromFaucet() {
+        await this.initialize();
+
+        this.log('requesting sui from faucet...');
+
+        let res = null;
+        try {
+            res = await this._provider.requestSuiFromFaucet(this._address);
+        } catch (e) {
+            this.log('error', e);
+            res = null;
+        }
+
+        let amount = BigInt(0);
+        let objectsCount = 0;
+
+        if (res && res.transferredGasObjects) {
+            for (let transferredGasObject of res.transferredGasObjects) {
+                amount += BigInt(transferredGasObject.amount);
+                objectsCount++;
+            }
+        }
+
+        this.log('got from faucet', amount, 'MIST in', objectsCount, 'objects');
+
+        return amount;
+    }
+
+    async getBalance(coinType = '0x2::sui::SUI') {
+        await this.initialize();
+
+        this.log('requesting balance of coin', coinType, '...');
+
+        let res = null;
+        try {
+            res = await this._provider.getBalance({owner: this._address, coinType});
+        } catch (e) {
+            this.log('error', e);
+            res = null;
+        }
+
+        let ret = BigInt(0);
+        if (res && res.totalBalance) {
+            ret = BigInt(res.totalBalance);
+        }
+
+        this.log('balance of', coinType, 'is', ret);
+        return ret;
+    }
+};
+
+
+
+module.exports = SuiMaster;

package/lib/SuiMemoryObjectStorage.js

@@ -0,0 +1,69 @@
+const SuiCommonMethods = require('./SuiCommonMethods.js');
+
+class SuiMemoryObjectStorage extends SuiCommonMethods {
+    constructor(params = {}) {
+        super(params);
+
+        this._objects = {};
+    }
+
+    asArray() {
+        return Object.values(this._objects);
+    }
+
+    find(filterFunction) {
+        for (const id in this._objects) {
+            if (filterFunction(this._objects[id])) {
+                return this._objects[id];
+            }
+        }
+
+        return null;
+    }
+
+    findMostRecent(filterFunction) {
+        let mostRecentDate = null;
+        let mostRecentObject = null;
+
+        for (const id in this._objects) {
+            if (filterFunction(this._objects[id])) {
+                if (!mostRecentDate || (mostRecentDate.getTime() <= this._objects[id].constructedAt.getTime())) {
+                    mostRecentDate = this._objects[id].constructedAt;
+                    mostRecentObject = this._objects[id];
+                }
+            }
+        }
+
+        return mostRecentObject;
+    }
+
+    push(object) {
+        if (object.address) {
+            this._objects[object.address] = object;
+
+            return true;
+        }
+
+        return false;
+    }
+
+    byAddress(address) {
+        if (this._objects[address]) {
+            return this._objects[address];
+        }
+        return null;
+    }
+
+    static _instances = {};
+
+    static instanceOf(validatorId, params = {}) {
+        if (SuiMemoryObjectStorage._instances[validatorId]) {
+            return SuiMemoryObjectStorage._instances[validatorId];
+        }
+
+        SuiMemoryObjectStorage._instances[validatorId] = new SuiMemoryObjectStorage(params);
+        return SuiMemoryObjectStorage._instances[validatorId];
+    }
+};
+
+module.exports = SuiMemoryObjectStorage;

package/lib/SuiObject.js

@@ -0,0 +1,211 @@
+const sui = require('@mysten/sui.js');
+const SuiCommonMethods = require('./SuiCommonMethods.js');
+
+class SuiObject extends SuiCommonMethods {
+    constructor(params = {}) {
+        super(params);
+
+        this._suiMaster = params.suiMaster;
+        if (!this._suiMaster) {
+            throw new Error('suiMaster is requried for suiPackage');
+        }
+
+        this._id = params.id || null;
+        this._version = params.version || null;
+        this._type = params.type || null;
+
+        this._fields = {};          //  on-chain fields on the object
+                                    //
+
+        this._display = {};         // https://examples.sui.io/basics/display.html
+                                    // https://docs.sui.io/devnet/build/sui-object-display
+
+        this._owner = null;         // Going to store it in the same format as in rpc responses
+
+        this._localProperties = {}; // object to store some local data for you to help with your local calculations, no interaction with blockchain
+
+        // this._ownerAddress = null;
+
+        this._isDeleted = false;
+
+        if (params.objectChange) {
+            this.tryToFillDataFromObjectChange(params.objectChange);
+        }
+
+        this._constructedAt = new Date(); // just a helpful data so we can sort later when trying to find most recent item in different modules
+    }
+
+    get constructedAt() {
+        return this._constructedAt;
+    }
+
+    static idsEqual(id1, id2) {
+        return (sui.normalizeSuiAddress(id1) === sui.normalizeSuiAddress(id2));
+    }
+
+    get isDeleted() {
+        return this._isDeleted;
+    }
+
+    get isShared() {
+        return (this._owner && this._owner.Shared);
+    }
+
+    get isImmutable() {
+        return (this._owner && this._owner == 'Immutable');
+    }
+
+    isOwnedBy(addressOrSuiObject) {
+        let toId = addressOrSuiObject;
+        if (toId.id) {
+            toId = toId.id;
+        }
+
+        if (this._owner && this._owner.AddressOwner && this._owner.AddressOwner == toId) {
+            return true;
+        }
+
+        return false;
+    }
+
+    markAsDeleted() {
+        this._isDeleted = true;
+    }
+
+    get id() {
+        return this._id;
+    }
+
+    get type() {
+        return this._type;
+    }
+
+    /**
+     * In module type name, without package and module prefix
+     */
+    get typeName() {
+        return this._type ? this._type.split('::').pop() : null;
+    }
+
+    idEquals(toId) {
+        if (!toId) {
+            return false;
+        }
+        
+        const thisAddress = this.address;
+        if (thisAddress && thisAddress === sui.normalizeSuiAddress(toId)) {
+            return true;
+        }
+        return false;
+    }
+
+    get address() {
+        try {
+            return sui.normalizeSuiAddress(this._id);
+        } catch (e) {
+            return null;
+        }
+    }
+
+    get fields() {
+        return this._fields;
+    }
+
+    get display() {
+        return this._display;
+    }
+
+    get localProperties() {
+        return this._localProperties;
+    }
+
+    async getDynamicFields() {
+        const result = await this._suiMaster._provider.getDynamicFields({
+            parentId: this.address, // normalized id
+            options: {
+              showType: true,
+              showContent: true,
+              showOwner: true,
+              showDisplay: true,
+              "showPreviousTransaction": true,
+              "showBcs": false,
+              "showStorageRebate": true
+            },
+        });
+    }
+
+    async fetchFields() {
+        const result = await this._suiMaster._provider.getObject({
+            id: this.address, // normalized id
+            options: {
+              showType: true,
+              showContent: true,
+              showOwner: true,
+              showDisplay: true,
+              "showPreviousTransaction": true,
+              "showBcs": false,
+              "showStorageRebate": true
+            },
+        });
+        if (result && result.data) {
+            this.tryToFillDataFromObjectChange(result.data);
+        }
+    }
+
+    /**
+     * Try to fill local object properties with values from ( showObjectChanges = true ) rpc response   
+     * @param {Object} objectChange 
+     */
+    tryToFillDataFromObjectChange(objectChange) {
+        if (!objectChange.objectId && objectChange.data && objectChange.data.objectId) {
+            objectChange = objectChange.data;
+        }
+
+        if (objectChange.type && objectChange.type == 'deleted') {
+            this.markAsDeleted();
+        }
+
+        // basic fields. Available both in getObject and in results of .moveCall
+        if (objectChange.objectId) {
+            if (!this._id) {
+                this._id = objectChange.objectId;
+            } else if (!this.idEquals(objectChange.objectId)) {
+                throw new Error('Trying to fill from different object');
+            }
+            if (objectChange.type && !this._type) {
+                this._type = objectChange.type;
+            }
+        }
+        if (objectChange.version) {
+            this._version = BigInt(objectChange.version);
+        }
+        if (objectChange.objectType) {
+            this._type = `${objectChange.objectType}`;
+        }
+
+        // extra fields. Possible to get them from separate call to getObject or multiGetObjects
+        // .content
+        if (objectChange?.content?.fields) {
+            for (const key in objectChange?.content?.fields) {
+                if (key !== 'id') {
+                    this._fields[key] = objectChange.content.fields[key];
+                }
+            }
+        }
+
+        // .display
+        if (objectChange?.display?.data) {
+            for (const key in objectChange?.display?.data) {
+                this._display[key] = objectChange.display.data[key];
+            }
+        }
+
+        // .owner
+        if (objectChange.owner) {
+            this._owner = objectChange.owner;
+        }
+
+    }
+};
+
+module.exports = SuiObject;