@cityofzion/bs-ethereum 2.0.2 → 2.1.0

package/dist/BSEthereum.js

@@ -43,12 +43,11 @@ const ethers_1 = require("ethers");
 const ethersJsonWallets = __importStar(require("@ethersproject/json-wallets"));
 const ethersBytes = __importStar(require("@ethersproject/bytes"));
 const ethersBigNumber = __importStar(require("@ethersproject/bignumber"));
-const BitqueryEDSEthereum_1 = require("./BitqueryEDSEthereum");
 const GhostMarketNDSEthereum_1 = require("./GhostMarketNDSEthereum");
-const RpcBDSEthereum_1 = require("./RpcBDSEthereum");
-const BitqueryBDSEthereum_1 = require("./BitqueryBDSEthereum");
 const EthersLedgerServiceEthereum_1 = require("./EthersLedgerServiceEthereum");
 const BSEthereumHelper_1 = require("./BSEthereumHelper");
+const MoralisBDSEthereum_1 = require("./MoralisBDSEthereum");
+const MoralisEDSEthereum_1 = require("./MoralisEDSEthereum");
 class BSEthereum {
     constructor(blockchainName, network, getLedgerTransport) {
         _BSEthereum_instances.add(this);
@@ -61,9 +60,8 @@ class BSEthereum {
     setNetwork(network) {
         __classPrivateFieldGet(this, _BSEthereum_instances, "m", _BSEthereum_setTokens).call(this, network);
         this.network = network;
-        const bitqueryNetwork = BitqueryBDSEthereum_1.BitqueryBDSEthereum.MIRROR_NETWORK_BY_NETWORK_ID[network.id];
-        this.blockchainDataService = bitqueryNetwork ? new BitqueryBDSEthereum_1.BitqueryBDSEthereum(network) : new RpcBDSEthereum_1.RpcBDSEthereum(network);
-        this.exchangeDataService = new BitqueryEDSEthereum_1.BitqueryEDSEthereum(network, this.tokens);
+        this.blockchainDataService = new MoralisBDSEthereum_1.MoralisBDSEthereum(network);
+        this.exchangeDataService = new MoralisEDSEthereum_1.MoralisEDSEthereum(network, this.blockchainDataService);
         this.nftDataService = new GhostMarketNDSEthereum_1.GhostMarketNDSEthereum(network);
     }
     validateAddress(address) {
@@ -144,7 +142,7 @@ class BSEthereum {
             }
             let signer;
             if (ledgerTransport) {
-                signer = new EthersLedgerServiceEthereum_1.EthersLedgerSigner(ledgerTransport, provider);
+                signer = this.ledgerService.getSigner(ledgerTransport, provider);
             }
             else {
                 signer = new ethers_1.ethers.Wallet(param.senderAccount.key, provider);
@@ -181,7 +179,7 @@ class BSEthereum {
             }
             let signer;
             if (ledgerTransport) {
-                signer = new EthersLedgerServiceEthereum_1.EthersLedgerSigner(ledgerTransport, provider);
+                signer = this.ledgerService.getSigner(ledgerTransport, provider);
             }
             else {
                 signer = new ethers_1.ethers.Wallet(param.senderAccount.key, provider);

package/dist/EthersLedgerServiceEthereum.d.ts

@@ -18,5 +18,5 @@ export declare class EthersLedgerServiceEthereum implements LedgerService {
     constructor(getLedgerTransport?: ((account: Account) => Promise<Transport>) | undefined);
     getAddress(transport: Transport): Promise<string>;
     getPublicKey(transport: Transport): Promise<string>;
-    getSigner(transport: Transport): EthersLedgerSigner;
+    getSigner(transport: Transport, provider?: ethers.providers.Provider): EthersLedgerSigner;
 }

package/dist/EthersLedgerServiceEthereum.js

@@ -200,18 +200,18 @@ class EthersLedgerServiceEthereum {
     }
     getAddress(transport) {
         return __awaiter(this, void 0, void 0, function* () {
-            const signer = new EthersLedgerSigner(transport);
+            const signer = this.getSigner(transport);
             return yield signer.getAddress();
         });
     }
     getPublicKey(transport) {
         return __awaiter(this, void 0, void 0, function* () {
-            const signer = new EthersLedgerSigner(transport);
+            const signer = this.getSigner(transport);
             return yield signer.getPublicKey();
         });
     }
-    getSigner(transport) {
-        return new EthersLedgerSigner(transport, undefined, this.emitter);
+    getSigner(transport, provider) {
+        return new EthersLedgerSigner(transport, provider, this.emitter);
     }
 }
 exports.EthersLedgerServiceEthereum = EthersLedgerServiceEthereum;

package/dist/MoralisBDSEthereum.d.ts

@@ -0,0 +1,15 @@
+import { BalanceResponse, ContractResponse, Network, Token, TransactionResponse, TransactionsByAddressParams, TransactionsByAddressResponse } from '@cityofzion/blockchain-service';
+import { RpcBDSEthereum } from './RpcBDSEthereum';
+import { BSEthereumNetworkId } from './BSEthereumHelper';
+export declare class MoralisBDSEthereum extends RpcBDSEthereum {
+    static BASE_URL: string;
+    static SUPPORTED_CHAINS: string[];
+    static getClient(network: Network<BSEthereumNetworkId>): import("axios").AxiosInstance;
+    static isSupported(network: Network<BSEthereumNetworkId>): boolean;
+    constructor(network: Network<BSEthereumNetworkId>);
+    getBalance(address: string): Promise<BalanceResponse[]>;
+    getTokenInfo(hash: string): Promise<Token>;
+    getTransaction(hash: string): Promise<TransactionResponse>;
+    getTransactionsByAddress(params: TransactionsByAddressParams): Promise<TransactionsByAddressResponse>;
+    getContract(hash: string): Promise<ContractResponse>;
+}

package/dist/MoralisBDSEthereum.js

@@ -0,0 +1,323 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoralisBDSEthereum = void 0;
+const RpcBDSEthereum_1 = require("./RpcBDSEthereum");
+const BSEthereumHelper_1 = require("./BSEthereumHelper");
+const axios_1 = __importDefault(require("axios"));
+const ethers_1 = require("ethers");
+const ERC20_1 = require("./assets/abis/ERC20");
+class MoralisBDSEthereum extends RpcBDSEthereum_1.RpcBDSEthereum {
+    static getClient(network) {
+        return axios_1.default.create({
+            baseURL: MoralisBDSEthereum.BASE_URL,
+            params: {
+                chain: `0x${Number(network.id).toString(16)}`,
+            },
+        });
+    }
+    static isSupported(network) {
+        return MoralisBDSEthereum.SUPPORTED_CHAINS.includes(network.id);
+    }
+    constructor(network) {
+        super(network);
+    }
+    getBalance(address) {
+        const _super = Object.create(null, {
+            getBalance: { get: () => super.getBalance }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!MoralisBDSEthereum.isSupported(this._network)) {
+                return _super.getBalance.call(this, address);
+            }
+            const client = MoralisBDSEthereum.getClient(this._network);
+            const { data: { balance: nativeBalance }, } = yield client.get(`${address}/balance`);
+            const nativeToken = BSEthereumHelper_1.BSEthereumHelper.getNativeAsset(this._network);
+            const balances = [
+                {
+                    amount: nativeBalance,
+                    token: nativeToken,
+                },
+            ];
+            const { data: erc20Balances } = yield client.get(`${address}/erc20`);
+            erc20Balances.forEach(balance => {
+                if (balance.possible_spam)
+                    return;
+                balances.push({
+                    amount: balance.balance,
+                    token: {
+                        decimals: balance.decimals,
+                        hash: balance.token_address,
+                        name: balance.name,
+                        symbol: balance.symbol,
+                    },
+                });
+            });
+            return balances;
+        });
+    }
+    getTokenInfo(hash) {
+        const _super = Object.create(null, {
+            getTokenInfo: { get: () => super.getTokenInfo }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!MoralisBDSEthereum.isSupported(this._network)) {
+                return _super.getTokenInfo.call(this, hash);
+            }
+            const nativeAsset = BSEthereumHelper_1.BSEthereumHelper.getNativeAsset(this._network);
+            if (nativeAsset.hash === hash)
+                return nativeAsset;
+            if (this._tokenCache.has(hash)) {
+                return this._tokenCache.get(hash);
+            }
+            const client = MoralisBDSEthereum.getClient(this._network);
+            const response = yield client.get(`/erc20/metadata`, {
+                params: {
+                    addresses: [hash],
+                },
+            });
+            const data = response.data[0];
+            const token = {
+                decimals: Number(data.decimals),
+                symbol: data.symbol,
+                hash,
+                name: data.name,
+            };
+            this._tokenCache.set(hash, token);
+            return token;
+        });
+    }
+    getTransaction(hash) {
+        const _super = Object.create(null, {
+            getTransaction: { get: () => super.getTransaction }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!MoralisBDSEthereum.isSupported(this._network)) {
+                return _super.getTransaction.call(this, hash);
+            }
+            const client = MoralisBDSEthereum.getClient(this._network);
+            const { data } = yield client.get(`/transaction/${hash}/verbose`);
+            const transfers = [];
+            if (data.value && Number(data.value) > 0) {
+                const nativeToken = BSEthereumHelper_1.BSEthereumHelper.getNativeAsset(this._network);
+                transfers.push({
+                    amount: data.value,
+                    from: data.from_address,
+                    to: data.to_address,
+                    type: 'token',
+                    token: nativeToken,
+                    contractHash: nativeToken.hash,
+                });
+            }
+            if (data.logs) {
+                const promises = data.logs.map((log) => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b, _c, _d;
+                    if (!log.decoded_event)
+                        return;
+                    if (log.decoded_event.label.toLowerCase() !== 'transfer')
+                        return;
+                    const contractHash = log.address;
+                    const amount = (_a = log.decoded_event.params.find((param) => param.name === 'value')) === null || _a === void 0 ? void 0 : _a.value;
+                    const from = (_b = log.decoded_event.params.find((param) => param.name === 'from')) === null || _b === void 0 ? void 0 : _b.value;
+                    const to = (_c = log.decoded_event.params.find((param) => param.name === 'to')) === null || _c === void 0 ? void 0 : _c.value;
+                    if (!from || !to)
+                        return;
+                    if (amount) {
+                        const token = yield this.getTokenInfo(contractHash);
+                        transfers.push({
+                            contractHash,
+                            amount: ethers_1.ethers.utils.formatUnits(amount, token.decimals),
+                            from,
+                            to,
+                            type: 'token',
+                        });
+                    }
+                    const tokenId = (_d = log.decoded_event.params.find((param) => param.name === 'tokenId')) === null || _d === void 0 ? void 0 : _d.value;
+                    if (!tokenId)
+                        return;
+                    transfers.push({
+                        contractHash,
+                        tokenId,
+                        from,
+                        to,
+                        type: 'nft',
+                    });
+                }));
+                yield Promise.allSettled(promises);
+            }
+            return {
+                block: Number(data.block_number),
+                hash,
+                notifications: [],
+                time: new Date(data.block_timestamp).getTime(),
+                transfers,
+                fee: data.transaction_fee,
+            };
+        });
+    }
+    getTransactionsByAddress(params) {
+        const _super = Object.create(null, {
+            getTransactionsByAddress: { get: () => super.getTransactionsByAddress }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!MoralisBDSEthereum.isSupported(this._network)) {
+                return _super.getTransactionsByAddress.call(this, params);
+            }
+            const client = MoralisBDSEthereum.getClient(this._network);
+            const { data } = yield client.get(`/wallets/${params.address}/history`, {
+                params: {
+                    limit: 15,
+                    cursor: params.cursor,
+                },
+            });
+            const transactions = [];
+            const nativeAsset = BSEthereumHelper_1.BSEthereumHelper.getNativeAsset(this._network);
+            const promises = data.result.map((item) => __awaiter(this, void 0, void 0, function* () {
+                const transfers = [];
+                item.native_transfers.forEach(transfer => {
+                    transfers.push({
+                        amount: ethers_1.ethers.utils.formatUnits(transfer.value, nativeAsset.decimals),
+                        from: transfer.from_address,
+                        to: transfer.to_address,
+                        type: 'token',
+                        token: nativeAsset,
+                        contractHash: nativeAsset.hash,
+                    });
+                });
+                item.erc20_transfers.forEach(transfer => {
+                    if (transfer.possible_spam)
+                        return;
+                    transfers.push({
+                        amount: ethers_1.ethers.utils.formatUnits(transfer.value, transfer.token_decimals),
+                        from: transfer.from_address,
+                        to: transfer.to_address,
+                        type: 'token',
+                        token: {
+                            decimals: Number(transfer.token_decimals),
+                            hash: transfer.address,
+                            name: transfer.token_name,
+                            symbol: transfer.token_symbol,
+                        },
+                        contractHash: transfer.address,
+                    });
+                });
+                item.nft_transfers.forEach(transfer => {
+                    transfers.push({
+                        contractHash: transfer.token_address,
+                        tokenId: transfer.token_id,
+                        from: transfer.from_address,
+                        to: transfer.to_address,
+                        type: 'nft',
+                    });
+                });
+                transactions.push({
+                    block: Number(item.block_number),
+                    hash: item.hash,
+                    notifications: [],
+                    time: new Date(item.block_timestamp).getTime(),
+                    transfers,
+                    fee: item.transaction_fee,
+                });
+            }));
+            yield Promise.allSettled(promises);
+            return {
+                nextCursor: data.cursor,
+                transactions,
+            };
+        });
+    }
+    getContract(hash) {
+        const _super = Object.create(null, {
+            getContract: { get: () => super.getContract }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!MoralisBDSEthereum.isSupported(this._network)) {
+                return _super.getContract.call(this, hash);
+            }
+            try {
+                const client = MoralisBDSEthereum.getClient(this._network);
+                const { data } = yield client.get(`erc20/metadata`, {
+                    params: {
+                        addresses: [hash],
+                    },
+                });
+                const methods = [];
+                ERC20_1.ERC20_ABI.forEach(abi => {
+                    var _a, _b;
+                    if (abi.type !== 'function')
+                        return;
+                    const parameters = (_a = abi.inputs) === null || _a === void 0 ? void 0 : _a.map(param => ({
+                        name: param.name,
+                        type: param.type,
+                    }));
+                    methods.push({
+                        name: (_b = abi.name) !== null && _b !== void 0 ? _b : '',
+                        parameters: parameters !== null && parameters !== void 0 ? parameters : [],
+                    });
+                });
+                return {
+                    hash,
+                    name: data[0].name,
+                    methods,
+                };
+            }
+            catch (_a) {
+                throw new Error('Contract not found or not an ERC20 token');
+            }
+        });
+    }
+}
+exports.MoralisBDSEthereum = MoralisBDSEthereum;
+MoralisBDSEthereum.BASE_URL = 'https://nxlrja2d1a.execute-api.us-east-1.amazonaws.com/production';
+MoralisBDSEthereum.SUPPORTED_CHAINS = [
+    '1',
+    '11155111',
+    '17000',
+    '137',
+    '80002',
+    '56',
+    '97',
+    '42161',
+    '421614',
+    '8453',
+    '84532',
+    '10',
+    '11155420',
+    '59144',
+    '59141',
+    '43114',
+    '250',
+    '4002',
+    '25',
+    '11297108109',
+    '2020',
+    '100',
+    '10200',
+    '88888',
+    '88882',
+    '369',
+    '1284',
+    '1285',
+    '1287',
+    '81457',
+    '168587773',
+    '324',
+    '300',
+    '5000',
+    '5003',
+    '1101',
+    '2442',
+    '7000',
+    '7001',
+];

package/dist/MoralisEDSEthereum.d.ts

@@ -0,0 +1,8 @@
+import { BlockchainDataService, CryptoCompareEDS, ExchangeDataService, GetTokenPriceHistoryParams, GetTokenPricesParams, Network, TokenPricesHistoryResponse, TokenPricesResponse } from '@cityofzion/blockchain-service';
+import { BSEthereumNetworkId } from './BSEthereumHelper';
+export declare class MoralisEDSEthereum extends CryptoCompareEDS implements ExchangeDataService {
+    #private;
+    constructor(network: Network<BSEthereumNetworkId>, blockchainDataService: BlockchainDataService);
+    getTokenPrices(params: GetTokenPricesParams): Promise<TokenPricesResponse[]>;
+    getTokenPriceHistory(params: GetTokenPriceHistoryParams): Promise<TokenPricesHistoryResponse[]>;
+}

package/dist/MoralisEDSEthereum.js

@@ -0,0 +1,139 @@
+"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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+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");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _MoralisEDSEthereum_instances, _MoralisEDSEthereum_network, _MoralisEDSEthereum_blockchainDataService, _MoralisEDSEthereum_numberOfBlockByHour, _MoralisEDSEthereum_numberOfBlockByDay, _MoralisEDSEthereum_getWrappedNativeToken;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoralisEDSEthereum = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
+const BSEthereumHelper_1 = require("./BSEthereumHelper");
+const MoralisBDSEthereum_1 = require("./MoralisBDSEthereum");
+class MoralisEDSEthereum extends blockchain_service_1.CryptoCompareEDS {
+    constructor(network, blockchainDataService) {
+        super();
+        _MoralisEDSEthereum_instances.add(this);
+        _MoralisEDSEthereum_network.set(this, void 0);
+        _MoralisEDSEthereum_blockchainDataService.set(this, void 0);
+        _MoralisEDSEthereum_numberOfBlockByHour.set(this, (15 / 60) * 60);
+        _MoralisEDSEthereum_numberOfBlockByDay.set(this, __classPrivateFieldGet(this, _MoralisEDSEthereum_numberOfBlockByHour, "f") * 24);
+        __classPrivateFieldSet(this, _MoralisEDSEthereum_network, network, "f");
+        __classPrivateFieldSet(this, _MoralisEDSEthereum_blockchainDataService, blockchainDataService, "f");
+    }
+    getTokenPrices(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!BSEthereumHelper_1.BSEthereumHelper.isMainnet(__classPrivateFieldGet(this, _MoralisEDSEthereum_network, "f")))
+                throw new Error('Exchange is only available on mainnet');
+            if (!MoralisBDSEthereum_1.MoralisBDSEthereum.isSupported(__classPrivateFieldGet(this, _MoralisEDSEthereum_network, "f")))
+                throw new Error('Exchange is not supported on this network');
+            const client = MoralisBDSEthereum_1.MoralisBDSEthereum.getClient(__classPrivateFieldGet(this, _MoralisEDSEthereum_network, "f"));
+            const nativeToken = BSEthereumHelper_1.BSEthereumHelper.getNativeAsset(__classPrivateFieldGet(this, _MoralisEDSEthereum_network, "f"));
+            let wrappedNativeToken;
+            if (params.tokens.some(token => token.symbol === nativeToken.symbol)) {
+                wrappedNativeToken = yield __classPrivateFieldGet(this, _MoralisEDSEthereum_instances, "m", _MoralisEDSEthereum_getWrappedNativeToken).call(this);
+            }
+            const tokensBody = params.tokens.map(token => {
+                if (token.symbol !== nativeToken.symbol) {
+                    return {
+                        token_address: token.hash,
+                    };
+                }
+                return {
+                    token_address: wrappedNativeToken.hash,
+                };
+            });
+            const { data } = yield client.post(`/erc20/prices`, {
+                tokens: tokensBody,
+            });
+            return data.map(item => {
+                let token;
+                if (item.tokenAddress === (wrappedNativeToken === null || wrappedNativeToken === void 0 ? void 0 : wrappedNativeToken.hash)) {
+                    token = nativeToken;
+                }
+                else {
+                    token = {
+                        decimals: Number(item.tokenDecimals),
+                        hash: item.tokenAddress,
+                        name: item.tokenName,
+                        symbol: item.tokenSymbol,
+                    };
+                }
+                return {
+                    usdPrice: item.usdPrice,
+                    token,
+                };
+            });
+        });
+    }
+    getTokenPriceHistory(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!BSEthereumHelper_1.BSEthereumHelper.isMainnet(__classPrivateFieldGet(this, _MoralisEDSEthereum_network, "f")))
+                throw new Error('Exchange is only available on mainnet');
+            if (!MoralisBDSEthereum_1.MoralisBDSEthereum.isSupported(__classPrivateFieldGet(this, _MoralisEDSEthereum_network, "f")))
+                throw new Error('Exchange is not supported on this network');
+            const nativeToken = BSEthereumHelper_1.BSEthereumHelper.getNativeAsset(__classPrivateFieldGet(this, _MoralisEDSEthereum_network, "f"));
+            let token;
+            if (params.token.hash === nativeToken.hash) {
+                token = yield __classPrivateFieldGet(this, _MoralisEDSEthereum_instances, "m", _MoralisEDSEthereum_getWrappedNativeToken).call(this);
+            }
+            else {
+                token = params.token;
+            }
+            const client = MoralisBDSEthereum_1.MoralisBDSEthereum.getClient(__classPrivateFieldGet(this, _MoralisEDSEthereum_network, "f"));
+            const actualBlockNumber = (yield __classPrivateFieldGet(this, _MoralisEDSEthereum_blockchainDataService, "f").getBlockHeight()) - 1; // Last block is not included
+            const history = [];
+            yield Promise.allSettled(Array.from({ length: params.limit }).map((_, index) => __awaiter(this, void 0, void 0, function* () {
+                const block = actualBlockNumber - index * (params.type === 'hour' ? __classPrivateFieldGet(this, _MoralisEDSEthereum_numberOfBlockByHour, "f") : __classPrivateFieldGet(this, _MoralisEDSEthereum_numberOfBlockByDay, "f"));
+                const priceResponse = yield client.get(`/erc20/${token.hash}/price`, {
+                    params: {
+                        to_block: block,
+                    },
+                });
+                const blockResponse = yield client.get(`/block/${block}`);
+                history.push({
+                    timestamp: new Date(blockResponse.data.timestamp).getTime(),
+                    usdPrice: priceResponse.data.usdPrice,
+                    token: params.token,
+                });
+            })));
+            return history;
+        });
+    }
+}
+exports.MoralisEDSEthereum = MoralisEDSEthereum;
+_MoralisEDSEthereum_network = new WeakMap(), _MoralisEDSEthereum_blockchainDataService = new WeakMap(), _MoralisEDSEthereum_numberOfBlockByHour = new WeakMap(), _MoralisEDSEthereum_numberOfBlockByDay = new WeakMap(), _MoralisEDSEthereum_instances = new WeakSet(), _MoralisEDSEthereum_getWrappedNativeToken = function _MoralisEDSEthereum_getWrappedNativeToken() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const nativeToken = BSEthereumHelper_1.BSEthereumHelper.getNativeAsset(__classPrivateFieldGet(this, _MoralisEDSEthereum_network, "f"));
+        const client = MoralisBDSEthereum_1.MoralisBDSEthereum.getClient(__classPrivateFieldGet(this, _MoralisEDSEthereum_network, "f"));
+        const { data } = yield client.get('/erc20/metadata/symbols', {
+            params: {
+                symbols: [`W${nativeToken.symbol}`],
+            },
+        });
+        const wrapperToken = data.find(token => token.verified_contract && !token.possible_spam);
+        if (!wrapperToken)
+            throw new Error('Wrapper token not found');
+        return {
+            decimals: Number(wrapperToken.decimals),
+            hash: wrapperToken.address,
+            name: wrapperToken.name,
+            symbol: wrapperToken.symbol,
+        };
+    });
+};

package/dist/RpcBDSEthereum.d.ts

@@ -1,12 +1,13 @@
 import { BalanceResponse, BlockchainDataService, ContractResponse, Network, RpcResponse, Token, TransactionResponse, TransactionsByAddressParams, TransactionsByAddressResponse } from '@cityofzion/blockchain-service';
 import { BSEthereumNetworkId } from './BSEthereumHelper';
 export declare class RpcBDSEthereum implements BlockchainDataService {
-    #private;
+    _network: Network<BSEthereumNetworkId>;
+    _tokenCache: Map<string, Token>;
     maxTimeToConfirmTransactionInMs: number;
     constructor(network: Network<BSEthereumNetworkId>);
     getTransaction(hash: string): Promise<TransactionResponse>;
     getTransactionsByAddress(_params: TransactionsByAddressParams): Promise<TransactionsByAddressResponse>;
-    getContract(): Promise<ContractResponse>;
+    getContract(_hash: string): Promise<ContractResponse>;
     getTokenInfo(hash: string): Promise<Token>;
     getBalance(address: string): Promise<BalanceResponse[]>;
     getBlockHeight(): Promise<number>;