@cityofzion/bs-neo3 3.0.3 → 3.0.5

package/dist/BSNeo3.d.ts

@@ -39,9 +39,9 @@ export declare class BSNeo3<N extends string = string> implements IBSNeo3<N> {
     validateEncrypted(encryptedKey: string): boolean;
     validateKey(key: string): boolean;
     validateNameServiceDomainFormat(domainName: string): boolean;
-    generateAccountFromMnemonic(mnemonic: string[] | string, index: number): TBSAccount<N>;
-    generateAccountFromPublicKey(publicKey: string): TBSAccount<N>;
-    generateAccountFromKey(key: string): TBSAccount<N>;
+    generateAccountFromMnemonic(mnemonic: string[] | string, index: number): Promise<TBSAccount<N>>;
+    generateAccountFromPublicKey(publicKey: string): Promise<TBSAccount<N>>;
+    generateAccountFromKey(key: string): Promise<TBSAccount<N>>;
     decrypt(encryptedKey: string, password: string): Promise<TBSAccount<N>>;
     encrypt(key: string, password: string): Promise<string>;
     calculateTransferFee(param: TTransferParam<N>): Promise<string>;

package/dist/BSNeo3.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
@@ -50,7 +41,7 @@ class BSNeo3 {
         this.claimToken = BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN;
         this.availableNetworks = BSNeo3Constants_1.BSNeo3Constants.ALL_NETWORKS;
         this.defaultNetwork = BSNeo3Constants_1.BSNeo3Constants.MAINNET_NETWORK;
-        this.setNetwork(network !== null && network !== void 0 ? network : this.defaultNetwork);
+        this.setNetwork(network ?? this.defaultNetwork);
     }
     setNetwork(network) {
         const rpcNetworkUrls = BSNeo3Constants_1.BSNeo3Constants.RPC_LIST_BY_NETWORK_ID[network.id] || [];
@@ -80,48 +71,44 @@ class BSNeo3 {
         this.fullTransactionsDataService = new DoraFullTransactionsDataServiceNeo3_1.DoraFullTransactionsDataServiceNeo3(this);
     }
     // This method is done manually because we need to ensure that the request is aborted after timeout
-    pingNode(url) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const abortController = new AbortController();
-            const timeout = setTimeout(() => {
-                abortController.abort();
-            }, 5000);
-            const timeStart = Date.now();
-            const response = yield axios_1.default.post(url, {
-                jsonrpc: '2.0',
-                method: 'getblockcount',
-                params: [],
-                id: 1234,
-            }, { timeout: 5000, signal: abortController.signal });
-            clearTimeout(timeout);
-            const latency = Date.now() - timeStart;
-            return {
-                latency,
-                url,
-                height: response.data.result,
-            };
-        });
+    async pingNode(url) {
+        const abortController = new AbortController();
+        const timeout = setTimeout(() => {
+            abortController.abort();
+        }, 5000);
+        const timeStart = Date.now();
+        const response = await axios_1.default.post(url, {
+            jsonrpc: '2.0',
+            method: 'getblockcount',
+            params: [],
+            id: 1234,
+        }, { timeout: 5000, signal: abortController.signal });
+        clearTimeout(timeout);
+        const latency = Date.now() - timeStart;
+        return {
+            latency,
+            url,
+            height: response.data.result,
+        };
     }
-    generateSigningCallback(account) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { wallet, api } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
-            const neonJsAccount = new wallet.Account(account.key);
-            if (account.isHardware) {
-                if (!this.ledgerService.getLedgerTransport)
-                    throw new Error('You must provide a getLedgerTransport function to use Ledger');
-                if (typeof account.bip44Path !== 'string')
-                    throw new Error('Your account must have bip44 path to use Ledger');
-                const ledgerTransport = yield this.ledgerService.getLedgerTransport(account);
-                return {
-                    neonJsAccount,
-                    signingCallback: this.ledgerService.getSigningCallback(ledgerTransport, account),
-                };
-            }
+    async generateSigningCallback(account) {
+        const { wallet, api } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
+        const neonJsAccount = new wallet.Account(account.key);
+        if (account.isHardware) {
+            if (!this.ledgerService.getLedgerTransport)
+                throw new Error('You must provide a getLedgerTransport function to use Ledger');
+            if (typeof account.bip44Path !== 'string')
+                throw new Error('Your account must have bip44 path to use Ledger');
+            const ledgerTransport = await this.ledgerService.getLedgerTransport(account);
             return {
                 neonJsAccount,
-                signingCallback: api.signWithAccount(neonJsAccount),
+                signingCallback: this.ledgerService.getSigningCallback(ledgerTransport, account),
             };
-        });
+        }
+        return {
+            neonJsAccount,
+            signingCallback: api.signWithAccount(neonJsAccount),
+        };
     }
     validateAddress(address) {
         const { wallet } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
@@ -138,7 +125,7 @@ class BSNeo3 {
     validateNameServiceDomainFormat(domainName) {
         return domainName.endsWith('.neo');
     }
-    generateAccountFromMnemonic(mnemonic, index) {
+    async generateAccountFromMnemonic(mnemonic, index) {
         const mnemonicStr = Array.isArray(mnemonic) ? mnemonic.join(' ') : mnemonic;
         const bip44Path = this.bip44DerivationPath.replace('?', index.toString());
         const key = blockchain_service_1.BSKeychainHelper.generateNeoPrivateKeyFromMnemonic(mnemonicStr, bip44Path);
@@ -146,7 +133,7 @@ class BSNeo3 {
         const { address, WIF } = new wallet.Account(key);
         return { address, key: WIF, type: 'wif', bip44Path, blockchain: this.name };
     }
-    generateAccountFromPublicKey(publicKey) {
+    async generateAccountFromPublicKey(publicKey) {
         const { wallet } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
         if (!wallet.isPublicKey(publicKey))
             throw new Error('Invalid public key');
@@ -158,7 +145,7 @@ class BSNeo3 {
             blockchain: this.name,
         };
     }
-    generateAccountFromKey(key) {
+    async generateAccountFromKey(key) {
         const { wallet } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
         const type = wallet.isWIF(key) ? 'wif' : wallet.isPrivateKey(key) ? 'privateKey' : undefined;
         if (!type)
@@ -166,107 +153,92 @@ class BSNeo3 {
         const { address } = new wallet.Account(key);
         return { address, key, type, blockchain: this.name };
     }
-    decrypt(encryptedKey, password) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { wallet } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
-            const key = yield wallet.decrypt(encryptedKey, password);
-            return this.generateAccountFromKey(key);
-        });
+    async decrypt(encryptedKey, password) {
+        const { wallet } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
+        const key = await wallet.decrypt(encryptedKey, password);
+        return await this.generateAccountFromKey(key);
     }
-    encrypt(key, password) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { wallet } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
-            return yield wallet.encrypt(key, password);
+    async encrypt(key, password) {
+        const { wallet } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
+        return await wallet.encrypt(key, password);
+    }
+    async calculateTransferFee(param) {
+        const { neonJsAccount } = await this.generateSigningCallback(param.senderAccount);
+        const { NeonInvoker } = BSNeo3NeonDappKitSingletonHelper_1.BSNeo3NeonDappKitSingletonHelper.getInstance();
+        const invoker = await NeonInvoker.init({
+            rpcAddress: this.network.url,
+            account: neonJsAccount,
         });
-    }
-    calculateTransferFee(param) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { neonJsAccount } = yield this.generateSigningCallback(param.senderAccount);
-            const { NeonInvoker } = BSNeo3NeonDappKitSingletonHelper_1.BSNeo3NeonDappKitSingletonHelper.getInstance();
-            const invoker = yield NeonInvoker.init({
-                rpcAddress: this.network.url,
-                account: neonJsAccount,
-            });
-            const invocations = yield __classPrivateFieldGet(this, _BSNeo3_instances, "m", _BSNeo3_buildTransferInvocation).call(this, param, neonJsAccount);
-            const { total } = yield invoker.calculateFee({
-                invocations,
-                signers: [],
-            });
-            return total.toString();
+        const invocations = await __classPrivateFieldGet(this, _BSNeo3_instances, "m", _BSNeo3_buildTransferInvocation).call(this, param, neonJsAccount);
+        const { total } = await invoker.calculateFee({
+            invocations,
+            signers: [],
         });
-    }
-    transfer(param) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { neonJsAccount, signingCallback } = yield this.generateSigningCallback(param.senderAccount);
-            const { NeonInvoker } = BSNeo3NeonDappKitSingletonHelper_1.BSNeo3NeonDappKitSingletonHelper.getInstance();
-            const invoker = yield NeonInvoker.init({
-                rpcAddress: this.network.url,
-                account: neonJsAccount,
-                signingCallback: signingCallback,
-            });
-            const invocations = yield __classPrivateFieldGet(this, _BSNeo3_instances, "m", _BSNeo3_buildTransferInvocation).call(this, param, neonJsAccount);
-            const transactionHash = yield invoker.invokeFunction({
-                invocations,
-                signers: [],
-            });
-            return param.intents.map(() => transactionHash);
+        return total.toString();
+    }
+    async transfer(param) {
+        const { neonJsAccount, signingCallback } = await this.generateSigningCallback(param.senderAccount);
+        const { NeonInvoker } = BSNeo3NeonDappKitSingletonHelper_1.BSNeo3NeonDappKitSingletonHelper.getInstance();
+        const invoker = await NeonInvoker.init({
+            rpcAddress: this.network.url,
+            account: neonJsAccount,
+            signingCallback: signingCallback,
         });
-    }
-    claim(account) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { neonJsAccount, signingCallback } = yield this.generateSigningCallback(account);
-            const { api } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
-            const facade = yield api.NetworkFacade.fromConfig({ node: this.network.url });
-            return yield facade.claimGas(neonJsAccount, {
-                signingCallback: signingCallback,
-            });
+        const invocations = await __classPrivateFieldGet(this, _BSNeo3_instances, "m", _BSNeo3_buildTransferInvocation).call(this, param, neonJsAccount);
+        const transactionHash = await invoker.invokeFunction({
+            invocations,
+            signers: [],
+        });
+        return param.intents.map(() => transactionHash);
+    }
+    async claim(account) {
+        const { neonJsAccount, signingCallback } = await this.generateSigningCallback(account);
+        const { api } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
+        const facade = await api.NetworkFacade.fromConfig({ node: this.network.url });
+        return await facade.claimGas(neonJsAccount, {
+            signingCallback: signingCallback,
         });
     }
-    resolveNameServiceDomain(domainName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { NeonParser, NeonInvoker } = BSNeo3NeonDappKitSingletonHelper_1.BSNeo3NeonDappKitSingletonHelper.getInstance();
-            const invoker = yield NeonInvoker.init({ rpcAddress: this.network.url });
-            const response = yield invoker.testInvoke({
-                invocations: [
-                    {
-                        scriptHash: BSNeo3Constants_1.BSNeo3Constants.NEO_NS_HASH,
-                        operation: 'ownerOf',
-                        args: [{ type: 'String', value: domainName }],
-                    },
-                ],
-            });
-            if (response.stack.length === 0) {
-                throw new Error((_a = response.exception) !== null && _a !== void 0 ? _a : 'unrecognized response');
-            }
-            const parsed = NeonParser.parseRpcResponse(response.stack[0], {
-                type: 'Hash160',
-            });
-            return NeonParser.accountInputToAddress(parsed.replace('0x', ''));
+    async resolveNameServiceDomain(domainName) {
+        const { NeonParser, NeonInvoker } = BSNeo3NeonDappKitSingletonHelper_1.BSNeo3NeonDappKitSingletonHelper.getInstance();
+        const invoker = await NeonInvoker.init({ rpcAddress: this.network.url });
+        const response = await invoker.testInvoke({
+            invocations: [
+                {
+                    scriptHash: BSNeo3Constants_1.BSNeo3Constants.NEO_NS_HASH,
+                    operation: 'ownerOf',
+                    args: [{ type: 'String', value: domainName }],
+                },
+            ],
+        });
+        if (response.stack.length === 0) {
+            throw new Error(response.exception ?? 'unrecognized response');
+        }
+        const parsed = NeonParser.parseRpcResponse(response.stack[0], {
+            type: 'Hash160',
         });
+        return NeonParser.accountInputToAddress(parsed.replace('0x', ''));
     }
 }
 exports.BSNeo3 = BSNeo3;
 _BSNeo3_instances = new WeakSet(), _BSNeo3_setTokens = function _BSNeo3_setTokens(network) {
     this.tokens = BSNeo3Helper_1.BSNeo3Helper.getTokens(network);
-}, _BSNeo3_buildTransferInvocation = function _BSNeo3_buildTransferInvocation(_a, account_1) {
-    return __awaiter(this, arguments, void 0, function* ({ intents }, account) {
-        const invocations = [];
-        for (const intent of intents) {
-            invocations.push({
-                operation: 'transfer',
-                scriptHash: intent.token.hash,
-                args: [
-                    { type: 'Hash160', value: account.address },
-                    { type: 'Hash160', value: intent.receiverAddress },
-                    {
-                        type: 'Integer',
-                        value: blockchain_service_1.BSBigNumberHelper.toDecimals(blockchain_service_1.BSBigNumberHelper.fromNumber(intent.amount), intent.token.decimals),
-                    },
-                    { type: 'Any', value: null },
-                ],
-            });
-        }
-        return invocations;
-    });
+}, _BSNeo3_buildTransferInvocation = async function _BSNeo3_buildTransferInvocation({ intents }, account) {
+    const invocations = [];
+    for (const intent of intents) {
+        invocations.push({
+            operation: 'transfer',
+            scriptHash: intent.token.hash,
+            args: [
+                { type: 'Hash160', value: account.address },
+                { type: 'Hash160', value: intent.receiverAddress },
+                {
+                    type: 'Integer',
+                    value: blockchain_service_1.BSBigNumberHelper.toDecimals(blockchain_service_1.BSBigNumberHelper.fromNumber(intent.amount), intent.token.decimals),
+                },
+                { type: 'Any', value: null },
+            ],
+        });
+    }
+    return invocations;
 };

package/dist/helpers/BSNeo3Helper.js

@@ -4,8 +4,7 @@ exports.BSNeo3Helper = void 0;
 const BSNeo3Constants_1 = require("../constants/BSNeo3Constants");
 class BSNeo3Helper {
     static getTokens(network) {
-        var _a;
-        const extraTokens = (_a = BSNeo3Constants_1.BSNeo3Constants.EXTRA_TOKENS_BY_NETWORK_ID[network.id]) !== null && _a !== void 0 ? _a : [];
+        const extraTokens = BSNeo3Constants_1.BSNeo3Constants.EXTRA_TOKENS_BY_NETWORK_ID[network.id] ?? [];
         return [...extraTokens, ...BSNeo3Constants_1.BSNeo3Constants.NATIVE_ASSETS];
     }
     static isCustomNetwork(network) {