@cityofzion/bs-ethereum 3.0.3 → 3.0.5

package/dist/BSEthereum.d.ts

@@ -36,9 +36,9 @@ export declare class BSEthereum<N extends string = string, A extends string = TB
     validateEncrypted(json: string): boolean;
     validateKey(key: string): boolean;
     validateNameServiceDomainFormat(domainName: string): boolean;
-    generateAccountFromMnemonic(mnemonic: string[] | string, index: number): TBSAccount<N>;
-    generateAccountFromKey(key: string): TBSAccount<N>;
-    generateAccountFromPublicKey(publicKey: string): TBSAccount<N>;
+    generateAccountFromMnemonic(mnemonic: string[] | string, index: number): Promise<TBSAccount<N>>;
+    generateAccountFromKey(key: string): Promise<TBSAccount<N>>;
+    generateAccountFromPublicKey(publicKey: string): Promise<TBSAccount<N>>;
     decrypt(json: string, password: string): Promise<TBSAccount<N>>;
     encrypt(key: string, password: string): Promise<string>;
     transfer(param: TTransferParam<N>): Promise<string[]>;

package/dist/BSEthereum.js

@@ -32,15 +32,6 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-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");
@@ -80,47 +71,46 @@ class BSEthereum {
             return;
         this.availableNetworks = BSEthereumConstants_1.BSEthereumConstants.NETWORKS_BY_EVM[evm];
         this.defaultNetwork = this.availableNetworks.find(network => network.type === 'mainnet');
-        this.setNetwork(network !== null && network !== void 0 ? network : this.defaultNetwork);
+        this.setNetwork(network ?? this.defaultNetwork);
     }
-    _buildTransferParams(intent) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const provider = new ethers_1.ethers.providers.JsonRpcProvider(this.network.url);
-            const amount = ethersBigNumber.parseFixed(intent.amount, intent.token.decimals);
-            const gasPrice = yield provider.getGasPrice();
-            let transactionParams = {
-                type: 2,
-            };
-            const isNative = this.tokenService.predicateByHash(this.feeToken, intent.token.hash);
-            if (isNative) {
-                transactionParams.to = intent.receiverAddress;
-                transactionParams.value = amount;
-            }
-            else {
-                const contract = new ethers_1.ethers.Contract(intent.token.hash, [
-                    'function transfer(address to, uint amount) returns (bool)',
-                ]);
-                const populatedTransaction = yield contract.populateTransaction.transfer(intent.receiverAddress, amount);
-                transactionParams = Object.assign(Object.assign({}, populatedTransaction), transactionParams);
-            }
-            return {
-                transactionParams,
-                gasPrice,
+    async _buildTransferParams(intent) {
+        const provider = new ethers_1.ethers.providers.JsonRpcProvider(this.network.url);
+        const amount = ethersBigNumber.parseFixed(intent.amount, intent.token.decimals);
+        const gasPrice = await provider.getGasPrice();
+        let transactionParams = {
+            type: 2,
+        };
+        const isNative = this.tokenService.predicateByHash(this.feeToken, intent.token.hash);
+        if (isNative) {
+            transactionParams.to = intent.receiverAddress;
+            transactionParams.value = amount;
+        }
+        else {
+            const contract = new ethers_1.ethers.Contract(intent.token.hash, [
+                'function transfer(address to, uint amount) returns (bool)',
+            ]);
+            const populatedTransaction = await contract.populateTransaction.transfer(intent.receiverAddress, amount);
+            transactionParams = {
+                ...populatedTransaction,
+                ...transactionParams,
             };
-        });
+        }
+        return {
+            transactionParams,
+            gasPrice,
+        };
     }
-    generateSigner(account) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const provider = new ethers_1.ethers.providers.JsonRpcProvider(this.network.url);
-            if (account.isHardware) {
-                if (!this.ledgerService.getLedgerTransport)
-                    throw new Error('You must provide 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 this.ledgerService.getSigner(ledgerTransport, account.bip44Path, provider);
-            }
-            return new ethers_1.ethers.Wallet(account.key, provider);
-        });
+    async generateSigner(account) {
+        const provider = new ethers_1.ethers.providers.JsonRpcProvider(this.network.url);
+        if (account.isHardware) {
+            if (!this.ledgerService.getLedgerTransport)
+                throw new Error('You must provide 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 this.ledgerService.getSigner(ledgerTransport, account.bip44Path, provider);
+        }
+        return new ethers_1.ethers.Wallet(account.key, provider);
     }
     setNetwork(network) {
         const rpcNetworkUrls = BSEthereumConstants_1.BSEthereumConstants.RPC_LIST_BY_NETWORK_ID[network.id] || [];
@@ -140,22 +130,20 @@ class BSEthereum {
         this.fullTransactionsDataService = new MoralisFullTransactionsDataServiceEthereum_1.MoralisFullTransactionsDataServiceEthereum(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: 'eth_blockNumber', params: [], id: 1234 }, { timeout: 5000, signal: abortController.signal });
-            clearTimeout(timeout);
-            const latency = Date.now() - timeStart;
-            return {
-                latency,
-                url,
-                height: ethers_1.ethers.BigNumber.from(response.data.result).toNumber(),
-            };
-        });
+    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: 'eth_blockNumber', params: [], id: 1234 }, { timeout: 5000, signal: abortController.signal });
+        clearTimeout(timeout);
+        const latency = Date.now() - timeStart;
+        return {
+            latency,
+            url,
+            height: ethers_1.ethers.BigNumber.from(response.data.result).toNumber(),
+        };
     }
     validateAddress(address) {
         return ethers_1.ethers.utils.isAddress(address);
@@ -170,14 +158,14 @@ class BSEthereum {
             }
             return ethersBytes.hexDataLength(key) === 32;
         }
-        catch (_a) {
+        catch {
             return false;
         }
     }
     validateNameServiceDomainFormat(domainName) {
         return domainName.endsWith('.eth');
     }
-    generateAccountFromMnemonic(mnemonic, index) {
+    async generateAccountFromMnemonic(mnemonic, index) {
         const bip44Path = this.bip44DerivationPath.replace('?', index.toString());
         const hd = ethers_1.ethers.utils.HDNode.fromMnemonic(Array.isArray(mnemonic) ? mnemonic.join(' ') : mnemonic).derivePath(bip44Path);
         return {
@@ -188,7 +176,7 @@ class BSEthereum {
             blockchain: this.name,
         };
     }
-    generateAccountFromKey(key) {
+    async generateAccountFromKey(key) {
         const wallet = new ethers_1.ethers.Wallet(key);
         return {
             address: wallet.address,
@@ -197,7 +185,7 @@ class BSEthereum {
             blockchain: this.name,
         };
     }
-    generateAccountFromPublicKey(publicKey) {
+    async generateAccountFromPublicKey(publicKey) {
         const address = ethers_1.ethers.utils.computeAddress(publicKey);
         return {
             address,
@@ -206,75 +194,70 @@ class BSEthereum {
             blockchain: this.name,
         };
     }
-    decrypt(json, password) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const wallet = yield ethers_1.ethers.Wallet.fromEncryptedJson(json, password);
-            return {
-                address: wallet.address,
-                key: wallet.privateKey,
-                type: 'privateKey',
-                blockchain: this.name,
-            };
-        });
+    async decrypt(json, password) {
+        const wallet = await ethers_1.ethers.Wallet.fromEncryptedJson(json, password);
+        return {
+            address: wallet.address,
+            key: wallet.privateKey,
+            type: 'privateKey',
+            blockchain: this.name,
+        };
     }
-    encrypt(key, password) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const wallet = new ethers_1.ethers.Wallet(key);
-            return wallet.encrypt(password);
-        });
+    async encrypt(key, password) {
+        const wallet = new ethers_1.ethers.Wallet(key);
+        return wallet.encrypt(password);
     }
-    transfer(param) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const signer = yield this.generateSigner(param.senderAccount);
-            const sentTransactionHashes = [];
-            let error;
-            for (const intent of param.intents) {
-                let transactionHash = '';
+    async transfer(param) {
+        const signer = await this.generateSigner(param.senderAccount);
+        const sentTransactionHashes = [];
+        let error;
+        for (const intent of param.intents) {
+            let transactionHash = '';
+            try {
+                const { transactionParams, gasPrice } = await this._buildTransferParams(intent);
+                let gasLimit;
                 try {
-                    const { transactionParams, gasPrice } = yield this._buildTransferParams(intent);
-                    let gasLimit;
-                    try {
-                        gasLimit = yield signer.estimateGas(transactionParams);
-                    }
-                    catch (_a) {
-                        gasLimit = BSEthereumConstants_1.BSEthereumConstants.DEFAULT_GAS_LIMIT;
-                    }
-                    const transaction = yield signer.sendTransaction(Object.assign(Object.assign({}, transactionParams), { gasLimit, maxPriorityFeePerGas: gasPrice, maxFeePerGas: gasPrice }));
-                    transactionHash = transaction.hash;
+                    gasLimit = await signer.estimateGas(transactionParams);
                 }
-                catch (err) {
-                    if (!error)
-                        error = err;
+                catch {
+                    gasLimit = BSEthereumConstants_1.BSEthereumConstants.DEFAULT_GAS_LIMIT;
                 }
-                sentTransactionHashes.push(transactionHash);
+                const transaction = await signer.sendTransaction({
+                    ...transactionParams,
+                    gasLimit,
+                    maxPriorityFeePerGas: gasPrice,
+                    maxFeePerGas: gasPrice,
+                });
+                transactionHash = transaction.hash;
             }
-            if (error && sentTransactionHashes.every(hash => !hash)) {
-                throw error;
+            catch (err) {
+                if (!error)
+                    error = err;
             }
-            return sentTransactionHashes;
-        });
+            sentTransactionHashes.push(transactionHash);
+        }
+        if (error && sentTransactionHashes.every(hash => !hash)) {
+            throw error;
+        }
+        return sentTransactionHashes;
     }
-    calculateTransferFee(param) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const signer = yield this.generateSigner(param.senderAccount);
-            let fee = ethers_1.ethers.utils.parseEther('0');
-            for (const intent of param.intents) {
-                const { gasPrice, transactionParams } = yield this._buildTransferParams(intent);
-                const estimated = yield signer.estimateGas(transactionParams);
-                const intentFee = gasPrice.mul(estimated);
-                fee = fee.add(intentFee);
-            }
-            return ethers_1.ethers.utils.formatEther(fee);
-        });
+    async calculateTransferFee(param) {
+        const signer = await this.generateSigner(param.senderAccount);
+        let fee = ethers_1.ethers.utils.parseEther('0');
+        for (const intent of param.intents) {
+            const { gasPrice, transactionParams } = await this._buildTransferParams(intent);
+            const estimated = await signer.estimateGas(transactionParams);
+            const intentFee = gasPrice.mul(estimated);
+            fee = fee.add(intentFee);
+        }
+        return ethers_1.ethers.utils.formatEther(fee);
     }
-    resolveNameServiceDomain(domainName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const provider = new ethers_1.ethers.providers.JsonRpcProvider(this.network.url);
-            const address = yield provider.resolveName(domainName);
-            if (!address)
-                throw new Error('No address found for domain name');
-            return address;
-        });
+    async resolveNameServiceDomain(domainName) {
+        const provider = new ethers_1.ethers.providers.JsonRpcProvider(this.network.url);
+        const address = await provider.resolveName(domainName);
+        if (!address)
+            throw new Error('No address found for domain name');
+        return address;
     }
 }
 exports.BSEthereum = BSEthereum;

package/dist/helpers/BSEthereumHelper.js

@@ -4,8 +4,7 @@ exports.BSEthereumHelper = void 0;
 const BSEthereumConstants_1 = require("../constants/BSEthereumConstants");
 class BSEthereumHelper {
     static getNativeAsset(network) {
-        var _a;
-        const symbol = (_a = BSEthereumConstants_1.BSEthereumConstants.NATIVE_SYMBOL_BY_NETWORK_ID[network.id]) !== null && _a !== void 0 ? _a : 'ETH';
+        const symbol = BSEthereumConstants_1.BSEthereumConstants.NATIVE_SYMBOL_BY_NETWORK_ID[network.id] ?? 'ETH';
         return { symbol, name: symbol, decimals: 18, hash: '0x' };
     }
     static isMainnetNetwork(service) {

package/dist/services/blockchain-data/MoralisBDSEthereum.d.ts

@@ -1,12 +1,12 @@
 import { TBalanceResponse, TBSToken, TBSNetwork, TBSNetworkId, type TContractResponse, type TTransaction, type TGetTransactionsByAddressResponse, type TGetTransactionsByAddressParams } from '@cityofzion/blockchain-service';
-import { AxiosInstance } from 'axios';
+import axios from 'axios';
 import { IBSEthereum, TBSEthereumNetworkId } from '../../types';
 import { RpcBDSEthereum } from './RpcBDSEthereum';
 export declare class MoralisBDSEthereum<N extends string, A extends TBSNetworkId> extends RpcBDSEthereum<N, A> {
     #private;
     static readonly BASE_URL: string;
     static readonly MORALIS_SUPPORTED_NETWORKS_IDS: TBSEthereumNetworkId[];
-    static getClient(network: TBSNetwork<TBSEthereumNetworkId>): AxiosInstance;
+    static getClient(network: TBSNetwork<TBSEthereumNetworkId>): axios.AxiosInstance;
     static isSupported(network: TBSNetwork<TBSEthereumNetworkId>): boolean;
     constructor(service: IBSEthereum<N, A>);
     getBalance(address: string): Promise<TBalanceResponse[]>;