@cityofzion/bs-ethereum 0.7.0 → 0.7.1

package/.rush/temp/package-deps_build.json

@@ -0,0 +1,24 @@
+{
+  "files": {
+    "packages/bs-ethereum/jest.config.ts": "d944475db93cbe41a9339187fd94b9962e411c43",
+    "packages/bs-ethereum/jest.setup.ts": "9a1976a32050616d4d2ee95b1aa21041bc4daca3",
+    "packages/bs-ethereum/package.json": "bc413e80daf25edafffbc30138ce3900d4bcfa5c",
+    "packages/bs-ethereum/src/BSEthereum.ts": "ea8070202977445b77ff67135f7fc7093f0ed2b9",
+    "packages/bs-ethereum/src/BitqueryBDSEthereum.ts": "811c83c0610f64e44318ea8edce5ac9d1390ebc4",
+    "packages/bs-ethereum/src/BitqueryEDSEthereum.ts": "69c8a010389fa636fbbfb6eb2772daa0bde910a7",
+    "packages/bs-ethereum/src/GhostMarketNDSEthereum.ts": "145273284b3c27494eea0e80c0c1de8001b11c57",
+    "packages/bs-ethereum/src/RpcBDSEthereum.ts": "d5e1ec436231894672fee3e677a8dc2f56628b0e",
+    "packages/bs-ethereum/src/__tests__/BDSEthereum.spec.ts": "ef43b385d3a26181ed0ebf8ef07c643476d5d364",
+    "packages/bs-ethereum/src/__tests__/BSEthereum.spec.ts": "0da33cb4c9f89a3b6c2c8445d800ff4ddb41d161",
+    "packages/bs-ethereum/src/__tests__/BitqueryEDSEthereum.spec.ts": "8e26084a00916be48eeeb65d3918e5eed6368f0c",
+    "packages/bs-ethereum/src/__tests__/GhostMarketNDSEthereum.spec.ts": "f5c9ba8f6c866b97bcf647d105bfa2d5f140180d",
+    "packages/bs-ethereum/src/assets/tokens/common.json": "4dbbf3a3b38422e743cf631ffb6c39231777b88d",
+    "packages/bs-ethereum/src/constants.ts": "40862a7cc04298a21e380ecdf02e09349897a6f5",
+    "packages/bs-ethereum/src/graphql.ts": "06c16fa064a6b0ec523e6917f142ed4abb5214e0",
+    "packages/bs-ethereum/src/index.ts": "69ca9c23acdd0afd70f7eaa0a840b07b62bdb07a",
+    "packages/bs-ethereum/tsconfig.build.json": "4dc23fb9c4c5e4d19a9bc3947a47c523f4bd967c",
+    "packages/bs-ethereum/tsconfig.json": "93e09769572b58e642d4990e9552c70a8b85e142",
+    "common/config/rush/npm-shrinkwrap.json": "4994dce94cedd11a678400d92e08741ac7bc9d3f"
+  },
+  "arguments": "tsc --project tsconfig.build.json "
+}

package/bs-ethereum.build.log

@@ -0,0 +1,2 @@
+Invoking: tsc --project tsconfig.build.json 
+

package/dist/BSEthereum.d.ts

@@ -0,0 +1,23 @@
+import { Account, AccountWithDerivationPath, BSCalculableFee, BSWithNameService, BSWithNft, BlockchainDataService, BlockchainService, ExchangeDataService, Network, NftDataService, PartialBy, Token, TransferParam } from '@cityofzion/blockchain-service';
+export declare class BSEthereum<BSCustomName extends string = string> implements BlockchainService, BSWithNft, BSWithNameService, BSCalculableFee {
+    readonly blockchainName: BSCustomName;
+    readonly feeToken: Token;
+    readonly derivationPath: string;
+    blockchainDataService: BlockchainDataService;
+    exchangeDataService: ExchangeDataService;
+    tokens: Token[];
+    nftDataService: NftDataService;
+    network: Network;
+    constructor(blockchainName: BSCustomName, network: PartialBy<Network, 'url'>);
+    setNetwork(param: PartialBy<Network, 'url'>): void;
+    validateAddress(address: string): boolean;
+    validateEncrypted(json: string): boolean;
+    validateKey(key: string): boolean;
+    validateNameServiceDomainFormat(domainName: string): boolean;
+    generateAccountFromMnemonic(mnemonic: string[] | string, index: number): AccountWithDerivationPath;
+    generateAccountFromKey(key: string): Account;
+    decrypt(json: string, password: string): Promise<Account>;
+    transfer({ senderAccount, intent }: TransferParam): Promise<string>;
+    calculateTransferFee({ senderAccount, intent }: TransferParam, details?: boolean | undefined): Promise<string>;
+    resolveNameServiceDomain(domainName: string): Promise<string>;
+}

package/dist/BSEthereum.js

@@ -0,0 +1,178 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSEthereum = void 0;
+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 constants_1 = require("./constants");
+const BitqueryEDSEthereum_1 = require("./BitqueryEDSEthereum");
+const GhostMarketNDSEthereum_1 = require("./GhostMarketNDSEthereum");
+const RpcBDSEthereum_1 = require("./RpcBDSEthereum");
+const BitqueryBDSEthereum_1 = require("./BitqueryBDSEthereum");
+class BSEthereum {
+    constructor(blockchainName, network) {
+        this.blockchainName = blockchainName;
+        this.derivationPath = constants_1.DERIVATION_PATH;
+        this.tokens = constants_1.TOKENS[network.type];
+        this.feeToken = this.tokens.find(token => token.symbol === 'ETH');
+        this.setNetwork(network);
+    }
+    setNetwork(param) {
+        var _a;
+        const network = {
+            type: param.type,
+            url: (_a = param.url) !== null && _a !== void 0 ? _a : constants_1.DEFAULT_URL_BY_NETWORK_TYPE[param.type],
+        };
+        this.network = network;
+        if (network.type === 'custom') {
+            this.blockchainDataService = new RpcBDSEthereum_1.RpcBDSEthereum(network);
+        }
+        else {
+            this.blockchainDataService = new BitqueryBDSEthereum_1.BitqueryBDSEthereum(network);
+        }
+        this.exchangeDataService = new BitqueryEDSEthereum_1.BitqueryEDSEthereum(network.type);
+        this.nftDataService = new GhostMarketNDSEthereum_1.GhostMarketNDSEthereum(network.type);
+    }
+    validateAddress(address) {
+        return ethers_1.ethers.utils.isAddress(address);
+    }
+    validateEncrypted(json) {
+        return ethersJsonWallets.isCrowdsaleWallet(json) || ethersJsonWallets.isKeystoreWallet(json);
+    }
+    validateKey(key) {
+        try {
+            if (!key.startsWith('0x')) {
+                key = '0x' + key;
+            }
+            if (ethersBytes.hexDataLength(key) !== 32)
+                return false;
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    validateNameServiceDomainFormat(domainName) {
+        if (!domainName.endsWith('.eth'))
+            return false;
+        return true;
+    }
+    generateAccountFromMnemonic(mnemonic, index) {
+        const path = this.derivationPath.replace('?', index.toString());
+        const wallet = ethers_1.ethers.Wallet.fromMnemonic(Array.isArray(mnemonic) ? mnemonic.join(' ') : mnemonic, path);
+        return {
+            address: wallet.address,
+            key: wallet.privateKey,
+            type: 'privateKey',
+            derivationPath: path,
+        };
+    }
+    generateAccountFromKey(key) {
+        const wallet = new ethers_1.ethers.Wallet(key);
+        return {
+            address: wallet.address,
+            key,
+            type: 'privateKey',
+        };
+    }
+    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',
+            };
+        });
+    }
+    transfer({ senderAccount, intent }) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = new ethers_1.ethers.providers.JsonRpcProvider(this.network.url);
+            const wallet = new ethers_1.ethers.Wallet(senderAccount.key, provider);
+            let transaction;
+            const decimals = (_a = intent.tokenDecimals) !== null && _a !== void 0 ? _a : 18;
+            const amount = ethersBigNumber.parseFixed(intent.amount, decimals);
+            const isNative = constants_1.NATIVE_ASSETS.some(asset => asset.hash === intent.tokenHash);
+            if (!isNative) {
+                const contract = new ethers_1.ethers.Contract(intent.tokenHash, ['function transfer(address to, uint amount) returns (bool)'], wallet);
+                transaction = yield contract.transfer(intent.receiverAddress, amount);
+            }
+            else {
+                transaction = yield wallet.sendTransaction({
+                    to: intent.receiverAddress,
+                    value: amount,
+                });
+            }
+            const transactionMined = yield transaction.wait();
+            if (!transactionMined)
+                throw new Error('Transaction not mined');
+            return transactionMined.transactionHash;
+        });
+    }
+    calculateTransferFee({ senderAccount, intent }, details) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = new ethers_1.ethers.providers.JsonRpcProvider(this.network.url);
+            const wallet = new ethers_1.ethers.Wallet(senderAccount.key, provider);
+            let estimated;
+            const isNative = constants_1.NATIVE_ASSETS.some(asset => asset.hash === intent.tokenHash);
+            const decimals = (_a = intent.tokenDecimals) !== null && _a !== void 0 ? _a : 18;
+            const amount = ethersBigNumber.parseFixed(intent.amount, decimals);
+            if (!isNative) {
+                const contract = new ethers_1.ethers.Contract(intent.tokenHash, ['function transfer(address to, uint amount) returns (bool)'], wallet);
+                estimated = yield contract.estimateGas.transfer(intent.receiverAddress, amount);
+            }
+            else {
+                estimated = yield wallet.estimateGas({
+                    to: intent.receiverAddress,
+                    value: amount,
+                });
+            }
+            return ethers_1.ethers.utils.formatEther(estimated);
+        });
+    }
+    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;
+        });
+    }
+}
+exports.BSEthereum = BSEthereum;

package/dist/BitqueryBDSEthereum.d.ts

@@ -0,0 +1,13 @@
+import { BalanceResponse, ContractResponse, Token, TransactionsByAddressParams, TransactionsByAddressResponse, TransactionResponse, Network } from '@cityofzion/blockchain-service';
+import { RpcBDSEthereum } from './RpcBDSEthereum';
+export declare class BitqueryBDSEthereum extends RpcBDSEthereum {
+    private readonly client;
+    private readonly networkType;
+    constructor(network: Network);
+    getTransaction(hash: string): Promise<TransactionResponse>;
+    getTransactionsByAddress({ address, page, }: TransactionsByAddressParams): Promise<TransactionsByAddressResponse>;
+    getContract(): Promise<ContractResponse>;
+    getTokenInfo(hash: string): Promise<Token>;
+    getBalance(address: string): Promise<BalanceResponse[]>;
+    private parseTransactionTransfer;
+}

package/dist/BitqueryBDSEthereum.js

@@ -0,0 +1,185 @@
+"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.BitqueryBDSEthereum = void 0;
+const core_1 = require("@urql/core");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const constants_1 = require("./constants");
+const graphql_1 = require("./graphql");
+const RpcBDSEthereum_1 = require("./RpcBDSEthereum");
+class BitqueryBDSEthereum extends RpcBDSEthereum_1.RpcBDSEthereum {
+    constructor(network) {
+        super(network);
+        if (network.type === 'custom')
+            throw new Error('Custom network not supported');
+        this.networkType = network.type;
+        this.client = new core_1.Client({
+            url: constants_1.BITQUERY_URL,
+            exchanges: [core_1.cacheExchange, core_1.fetchExchange],
+            fetch: node_fetch_1.default,
+            fetchOptions: {
+                headers: {
+                    'X-API-KEY': constants_1.BITQUERY_API_KEY,
+                },
+            },
+        });
+    }
+    getTransaction(hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.client
+                .query(graphql_1.bitqueryGetTransactionQuery, {
+                hash,
+                network: constants_1.BITQUERY_NETWORK_BY_NETWORK_TYPE[this.networkType],
+            })
+                .toPromise();
+            if (result.error)
+                throw new Error(result.error.message);
+            if (!result.data || !result.data.ethereum.transfers.length)
+                throw new Error('Transaction not found');
+            const transfers = result.data.ethereum.transfers.map(this.parseTransactionTransfer);
+            const { block: { height, timestamp: { unixtime }, }, transaction: { gasValue, hash: transactionHash }, } = result.data.ethereum.transfers[0];
+            return {
+                block: height,
+                time: unixtime,
+                hash: transactionHash,
+                fee: String(gasValue),
+                transfers,
+                notifications: [],
+            };
+        });
+    }
+    getTransactionsByAddress({ address, page = 1, }) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        return __awaiter(this, void 0, void 0, function* () {
+            const limit = 10;
+            const offset = limit * (page - 1);
+            const result = yield this.client
+                .query(graphql_1.bitqueryGetTransactionsByAddressQuery, {
+                address,
+                limit,
+                offset,
+                network: constants_1.BITQUERY_NETWORK_BY_NETWORK_TYPE[this.networkType],
+            })
+                .toPromise();
+            if (result.error)
+                throw new Error(result.error.message);
+            if (!result.data)
+                throw new Error('Address does not have transactions');
+            const totalCount = ((_a = result.data.ethereum.sentCount.count) !== null && _a !== void 0 ? _a : 0) + ((_b = result.data.ethereum.receiverCount.count) !== null && _b !== void 0 ? _b : 0);
+            const mixedTransfers = [...((_e = (_d = (_c = result === null || result === void 0 ? void 0 : result.data) === null || _c === void 0 ? void 0 : _c.ethereum) === null || _d === void 0 ? void 0 : _d.sent) !== null && _e !== void 0 ? _e : []), ...((_h = (_g = (_f = result === null || result === void 0 ? void 0 : result.data) === null || _f === void 0 ? void 0 : _f.ethereum) === null || _g === void 0 ? void 0 : _g.received) !== null && _h !== void 0 ? _h : [])];
+            const transactions = new Map();
+            mixedTransfers.forEach(transfer => {
+                const transactionTransfer = this.parseTransactionTransfer(transfer);
+                const existingTransaction = transactions.get(transfer.transaction.hash);
+                if (existingTransaction) {
+                    existingTransaction.transfers.push(transactionTransfer);
+                    return;
+                }
+                transactions.set(transfer.transaction.hash, {
+                    block: transfer.block.height,
+                    hash: transfer.transaction.hash,
+                    time: transfer.block.timestamp.unixtime,
+                    fee: String(transfer.transaction.gasValue),
+                    transfers: [transactionTransfer],
+                    notifications: [],
+                });
+            });
+            return {
+                totalCount,
+                limit: limit * 2,
+                transactions: Array.from(transactions.values()),
+            };
+        });
+    }
+    getContract() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error("Bitquery doesn't support contract info");
+        });
+    }
+    getTokenInfo(hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const localToken = constants_1.TOKENS[this.networkType].find(token => token.hash === hash);
+            if (localToken)
+                return localToken;
+            const result = yield this.client
+                .query(graphql_1.bitqueryGetTokenInfoQuery, {
+                hash,
+                network: constants_1.BITQUERY_NETWORK_BY_NETWORK_TYPE[this.networkType],
+            })
+                .toPromise();
+            if (result.error)
+                throw new Error(result.error.message);
+            if (!result.data || result.data.ethereum.smartContractCalls.length <= 0)
+                throw new Error('Token not found');
+            const { address: { address }, currency: { decimals, name, symbol, tokenType }, } = result.data.ethereum.smartContractCalls[0].smartContract;
+            if (tokenType !== 'ERC20')
+                throw new Error('Token is not ERC20');
+            return {
+                hash: address,
+                name,
+                symbol,
+                decimals,
+            };
+        });
+    }
+    getBalance(address) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.client
+                .query(graphql_1.bitqueryGetBalanceQuery, {
+                address,
+                network: constants_1.BITQUERY_NETWORK_BY_NETWORK_TYPE[this.networkType],
+            })
+                .toPromise();
+            if (result.error)
+                throw new Error(result.error.message);
+            const data = (_b = (_a = result.data) === null || _a === void 0 ? void 0 : _a.ethereum.address[0].balances) !== null && _b !== void 0 ? _b : [];
+            const balances = data.map(({ value, currency: { address, decimals, name, symbol } }) => ({
+                amount: value.toString(),
+                token: {
+                    hash: address,
+                    symbol,
+                    name,
+                    decimals,
+                },
+            }));
+            return balances;
+        });
+    }
+    parseTransactionTransfer({ amount, currency: { tokenType, address, decimals, name, symbol }, entityId, sender, receiver, }) {
+        if (tokenType === 'ERC721') {
+            return {
+                from: sender.address,
+                to: receiver.address,
+                tokenId: entityId,
+                contractHash: address,
+                type: 'nft',
+            };
+        }
+        return {
+            from: sender.address,
+            to: receiver.address,
+            contractHash: address,
+            amount: amount.toString(),
+            token: {
+                decimals: decimals,
+                hash: address,
+                name: name,
+                symbol: symbol,
+            },
+            type: 'token',
+        };
+    }
+}
+exports.BitqueryBDSEthereum = BitqueryBDSEthereum;

package/dist/BitqueryEDSEthereum.d.ts

@@ -0,0 +1,8 @@
+import { Currency, ExchangeDataService, NetworkType, TokenPricesResponse } from '@cityofzion/blockchain-service';
+export declare class BitqueryEDSEthereum implements ExchangeDataService {
+    private readonly client;
+    private readonly networkType;
+    constructor(networkType: NetworkType);
+    getTokenPrices(currency: Currency): Promise<TokenPricesResponse[]>;
+    private getCurrencyRatio;
+}

package/dist/BitqueryEDSEthereum.js

@@ -0,0 +1,72 @@
+"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.BitqueryEDSEthereum = void 0;
+const core_1 = require("@urql/core");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const constants_1 = require("./constants");
+const dayjs_1 = __importDefault(require("dayjs"));
+const utc_1 = __importDefault(require("dayjs/plugin/utc"));
+const graphql_1 = require("./graphql");
+dayjs_1.default.extend(utc_1.default);
+class BitqueryEDSEthereum {
+    constructor(networkType) {
+        this.networkType = networkType;
+        this.client = new core_1.Client({
+            url: constants_1.BITQUERY_URL,
+            exchanges: [core_1.cacheExchange, core_1.fetchExchange],
+            fetch: node_fetch_1.default,
+            fetchOptions: {
+                headers: {
+                    'X-API-KEY': constants_1.BITQUERY_API_KEY,
+                },
+            },
+        });
+    }
+    getTokenPrices(currency) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.networkType !== 'mainnet')
+                throw new Error('Exchange is only available on mainnet');
+            const twoDaysAgo = dayjs_1.default.utc().subtract(2, 'day').startOf('date').toISOString();
+            const result = yield this.client
+                .query(graphql_1.bitqueryGetPricesQuery, { after: twoDaysAgo, network: 'ethereum' })
+                .toPromise();
+            if (result.error) {
+                throw new Error(result.error.message);
+            }
+            if (!result.data) {
+                throw new Error('There is no price data');
+            }
+            let currencyRatio = 1;
+            if (currency !== 'USD') {
+                currencyRatio = yield this.getCurrencyRatio(currency);
+            }
+            const prices = result.data.ethereum.dexTrades.map((trade) => ({
+                symbol: trade.baseCurrency.symbol,
+                price: trade.quotePrice * currencyRatio,
+            }));
+            return prices;
+        });
+    }
+    getCurrencyRatio(currency) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const request = yield (0, node_fetch_1.default)(`https://api.flamingo.finance/fiat/exchange-rate?pair=USD_${currency}`, {
+                method: 'GET',
+            });
+            const data = yield request.json();
+            return data;
+        });
+    }
+}
+exports.BitqueryEDSEthereum = BitqueryEDSEthereum;

package/dist/GhostMarketNDSEthereum.d.ts

@@ -0,0 +1,10 @@
+import { NftResponse, NftsResponse, NetworkType, NftDataService, GetNftParam, GetNftsByAddressParams } from '@cityofzion/blockchain-service';
+export declare class GhostMarketNDSEthereum implements NftDataService {
+    private networkType;
+    constructor(networkType: NetworkType);
+    getNftsByAddress({ address, size, cursor, page }: GetNftsByAddressParams): Promise<NftsResponse>;
+    getNft({ contractHash, tokenId }: GetNftParam): Promise<NftResponse>;
+    private treatGhostMarketImage;
+    private getUrlWithParams;
+    private parse;
+}

package/dist/GhostMarketNDSEthereum.js

@@ -0,0 +1,77 @@
+"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.GhostMarketNDSEthereum = void 0;
+const query_string_1 = __importDefault(require("query-string"));
+const constants_1 = require("./constants");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+class GhostMarketNDSEthereum {
+    constructor(networkType) {
+        this.networkType = networkType;
+    }
+    getNftsByAddress({ address, size = 18, cursor, page }) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = this.getUrlWithParams({
+                size,
+                owners: [address],
+                cursor: cursor,
+            });
+            const request = yield (0, node_fetch_1.default)(url, { method: 'GET' });
+            const data = (yield request.json());
+            const nfts = (_a = data.assets) !== null && _a !== void 0 ? _a : [];
+            return { nextCursor: data.next, items: nfts.map(this.parse.bind(this)) };
+        });
+    }
+    getNft({ contractHash, tokenId }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = this.getUrlWithParams({
+                contract: contractHash,
+                tokenIds: [tokenId],
+            });
+            const request = yield (0, node_fetch_1.default)(url, { method: 'GET' });
+            const data = (yield request.json());
+            return this.parse(data.assets[0]);
+        });
+    }
+    treatGhostMarketImage(srcImage) {
+        if (!srcImage) {
+            return;
+        }
+        if (srcImage.startsWith('ipfs://')) {
+            const [, imageId] = srcImage.split('://');
+            return `https://ghostmarket.mypinata.cloud/ipfs/${imageId}`;
+        }
+        return srcImage;
+    }
+    getUrlWithParams(params) {
+        const parameters = query_string_1.default.stringify(Object.assign({ chain: constants_1.GHOSTMARKET_CHAIN_BY_NETWORK_TYPE[this.networkType] }, params), { arrayFormat: 'bracket' });
+        return `${constants_1.GHOSTMARKET_URL_BY_NETWORK_TYPE[this.networkType]}/assets?${parameters}`;
+    }
+    parse(data) {
+        var _a, _b;
+        const nftResponse = {
+            collectionImage: this.treatGhostMarketImage((_a = data.collection) === null || _a === void 0 ? void 0 : _a.logoUrl),
+            id: data.tokenId,
+            contractHash: data.contract.hash,
+            symbol: data.contract.symbol,
+            collectionName: (_b = data.collection) === null || _b === void 0 ? void 0 : _b.name,
+            image: this.treatGhostMarketImage(data.metadata.mediaUri),
+            isSVG: String(data.metadata.mediaType).includes('svg+xml'),
+            name: data.metadata.name,
+        };
+        return nftResponse;
+    }
+}
+exports.GhostMarketNDSEthereum = GhostMarketNDSEthereum;

package/dist/RpcBDSEthereum.d.ts

@@ -0,0 +1,11 @@
+import { BalanceResponse, BlockchainDataService, ContractResponse, Network, Token, TransactionResponse, TransactionsByAddressParams, TransactionsByAddressResponse } from '@cityofzion/blockchain-service';
+export declare class RpcBDSEthereum implements BlockchainDataService {
+    private readonly network;
+    constructor(network: Network);
+    getTransaction(hash: string): Promise<TransactionResponse>;
+    getTransactionsByAddress(_params: TransactionsByAddressParams): Promise<TransactionsByAddressResponse>;
+    getContract(): Promise<ContractResponse>;
+    getTokenInfo(hash: string): Promise<Token>;
+    getBalance(address: string): Promise<BalanceResponse[]>;
+    getBlockHeight(): Promise<number>;
+}

package/dist/RpcBDSEthereum.js

@@ -0,0 +1,88 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcBDSEthereum = void 0;
+const ethers_1 = require("ethers");
+const constants_1 = require("./constants");
+class RpcBDSEthereum {
+    constructor(network) {
+        this.network = network;
+    }
+    getTransaction(hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = new ethers_1.ethers.providers.JsonRpcProvider(this.network.url);
+            const transaction = yield provider.getTransaction(hash);
+            if (!transaction || !transaction.blockHash || !transaction.to)
+                throw new Error('Transaction not found');
+            const block = yield provider.getBlock(transaction.blockHash);
+            if (!block)
+                throw new Error('Block not found');
+            const tokens = constants_1.TOKENS[this.network.type];
+            const token = tokens.find(token => token.symbol === 'ETH');
+            return {
+                block: block.number,
+                time: block.timestamp,
+                hash: transaction.hash,
+                transfers: [
+                    {
+                        type: 'token',
+                        amount: ethers_1.ethers.utils.formatEther(transaction.value),
+                        contractHash: '-',
+                        from: transaction.from,
+                        to: transaction.to,
+                        token,
+                    },
+                ],
+                notifications: [],
+            };
+        });
+    }
+    getTransactionsByAddress(_params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error("RPC doesn't support get transactions history of address");
+        });
+    }
+    getContract() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error("RPC doesn't support contract info");
+        });
+    }
+    getTokenInfo(hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tokens = constants_1.TOKENS[this.network.type];
+            const token = tokens.find(token => token.hash === hash);
+            if (!token)
+                throw new Error('Token not found');
+            return token;
+        });
+    }
+    getBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = new ethers_1.ethers.providers.JsonRpcProvider(this.network.url);
+            const balance = yield provider.getBalance(address);
+            const tokens = constants_1.TOKENS[this.network.type];
+            const token = tokens.find(token => token.symbol === 'ETH');
+            return [
+                {
+                    amount: ethers_1.ethers.utils.formatEther(balance),
+                    token,
+                },
+            ];
+        });
+    }
+    getBlockHeight() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = new ethers_1.ethers.providers.JsonRpcProvider(this.network.url);
+            return yield provider.getBlockNumber();
+        });
+    }
+}
+exports.RpcBDSEthereum = RpcBDSEthereum;

package/dist/assets/tokens/common.json

@@ -0,0 +1,8 @@
+[
+    {
+        "symbol": "ETH",
+        "name": "Ethereum",
+        "hash": "-",
+        "decimals": 16
+    }
+]

package/dist/constants.d.ts

@@ -0,0 +1,16 @@
+import { NetworkType, Token } from '@cityofzion/blockchain-service';
+export type BitqueryNetwork = 'ethereum' | 'goerli';
+export declare const TOKENS: Record<NetworkType, Token[]>;
+export declare const NATIVE_ASSETS: {
+    symbol: string;
+    name: string;
+    hash: string;
+    decimals: number;
+}[];
+export declare const DEFAULT_URL_BY_NETWORK_TYPE: Record<NetworkType, string>;
+export declare const BITQUERY_API_KEY = "BQYMp76Ny15C8ORbI2BOstFUhoMCahLI";
+export declare const BITQUERY_URL = "https://graphql.bitquery.io";
+export declare const BITQUERY_NETWORK_BY_NETWORK_TYPE: Record<Exclude<NetworkType, 'custom'>, BitqueryNetwork>;
+export declare const GHOSTMARKET_URL_BY_NETWORK_TYPE: Partial<Record<NetworkType, string>>;
+export declare const GHOSTMARKET_CHAIN_BY_NETWORK_TYPE: Partial<Record<NetworkType, string>>;
+export declare const DERIVATION_PATH = "m/44'/60'/0'/0/?";

package/dist/constants.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DERIVATION_PATH = exports.GHOSTMARKET_CHAIN_BY_NETWORK_TYPE = exports.GHOSTMARKET_URL_BY_NETWORK_TYPE = exports.BITQUERY_NETWORK_BY_NETWORK_TYPE = exports.BITQUERY_URL = exports.BITQUERY_API_KEY = exports.DEFAULT_URL_BY_NETWORK_TYPE = exports.NATIVE_ASSETS = exports.TOKENS = void 0;
+const common_json_1 = __importDefault(require("./assets/tokens/common.json"));
+exports.TOKENS = {
+    mainnet: [...common_json_1.default],
+    testnet: common_json_1.default,
+    custom: common_json_1.default,
+};
+exports.NATIVE_ASSETS = common_json_1.default;
+exports.DEFAULT_URL_BY_NETWORK_TYPE = {
+    mainnet: 'https://ethereum-mainnet-rpc.allthatnode.com',
+    testnet: 'https://ethereum-goerli-rpc.allthatnode.com',
+    custom: 'http://127.0.0.1:8545',
+};
+exports.BITQUERY_API_KEY = 'BQYMp76Ny15C8ORbI2BOstFUhoMCahLI';
+exports.BITQUERY_URL = 'https://graphql.bitquery.io';
+exports.BITQUERY_NETWORK_BY_NETWORK_TYPE = {
+    mainnet: 'ethereum',
+    testnet: 'goerli',
+};
+exports.GHOSTMARKET_URL_BY_NETWORK_TYPE = {
+    mainnet: 'https://api.ghostmarket.io/api/v2',
+    testnet: 'https://api-testnet.ghostmarket.io/api/v2',
+};
+exports.GHOSTMARKET_CHAIN_BY_NETWORK_TYPE = {
+    mainnet: 'eth',
+    testnet: 'etht',
+};
+exports.DERIVATION_PATH = "m/44'/60'/0'/0/?";

package/dist/graphql.d.ts

@@ -0,0 +1,123 @@
+type BitqueryNetwork = 'ethereum' | 'goerli';
+export type BitqueryTransaction = {
+    block: {
+        timestamp: {
+            unixtime: number;
+        };
+        height: number;
+    };
+    transaction: {
+        gasValue: number;
+        hash: string;
+    };
+    amount: number;
+    currency: {
+        address: string;
+        tokenType: string;
+        decimals: number;
+        symbol: string;
+        name: string;
+    };
+    sender: {
+        address: string;
+    };
+    receiver: {
+        address: string;
+    };
+    entityId: string;
+};
+type BitQueryGetTransactionsByAddressResponse = {
+    ethereum: {
+        sent: BitqueryTransaction[];
+        received: BitqueryTransaction[];
+        sentCount: {
+            count: number;
+        };
+        receiverCount: {
+            count: number;
+        };
+    };
+};
+type BitQueryGetTransactionsByAddressVariables = {
+    address: string;
+    limit: number;
+    offset: number;
+    network: BitqueryNetwork;
+};
+export declare const bitqueryGetTransactionsByAddressQuery: import("@urql/core/dist/urql-core-chunk").TypedDocumentNode<BitQueryGetTransactionsByAddressResponse, BitQueryGetTransactionsByAddressVariables>;
+type BitQueryGetTransactionResponse = {
+    ethereum: {
+        transfers: BitqueryTransaction[];
+    };
+};
+type BitQueryGetTransactionVariables = {
+    hash: string;
+    network: BitqueryNetwork;
+};
+export declare const bitqueryGetTransactionQuery: import("@urql/core/dist/urql-core-chunk").TypedDocumentNode<BitQueryGetTransactionResponse, BitQueryGetTransactionVariables>;
+type BitQueryGetContractResponse = {
+    ethereum: {
+        smartContractCalls: {
+            smartContract: {
+                address: {
+                    address: string;
+                };
+                currency: {
+                    symbol: string;
+                    name: string;
+                    decimals: number;
+                    tokenType: string;
+                };
+            };
+        }[];
+    };
+};
+type BitQueryGetTokenInfoVariables = {
+    hash: string;
+    network: BitqueryNetwork;
+};
+export declare const bitqueryGetTokenInfoQuery: import("@urql/core/dist/urql-core-chunk").TypedDocumentNode<BitQueryGetContractResponse, BitQueryGetTokenInfoVariables>;
+type BitQueryGetBalanceResponse = {
+    ethereum: {
+        address: {
+            balances: {
+                currency: {
+                    address: string;
+                    symbol: string;
+                    name: string;
+                    decimals: number;
+                };
+                value: number;
+            }[] | null;
+        }[];
+    };
+};
+type BitQueryGetBalanceVariables = {
+    address: string;
+    network: BitqueryNetwork;
+};
+export declare const bitqueryGetBalanceQuery: import("@urql/core/dist/urql-core-chunk").TypedDocumentNode<BitQueryGetBalanceResponse, BitQueryGetBalanceVariables>;
+type BitQueryGetTokenPricesResponse = {
+    ethereum: {
+        dexTrades: {
+            baseCurrency: {
+                address: string;
+                symbol: string;
+            };
+            quoteCurrency: {
+                address: string;
+                symbol: string;
+            };
+            date: {
+                date: string;
+            };
+            quotePrice: number;
+        }[];
+    };
+};
+export type BitQueryGetTokenPricesVariables = {
+    after: string;
+    network: BitqueryNetwork;
+};
+export declare const bitqueryGetPricesQuery: import("@urql/core/dist/urql-core-chunk").TypedDocumentNode<BitQueryGetTokenPricesResponse, BitQueryGetTokenPricesVariables>;
+export {};

package/dist/graphql.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bitqueryGetPricesQuery = exports.bitqueryGetBalanceQuery = exports.bitqueryGetTokenInfoQuery = exports.bitqueryGetTransactionQuery = exports.bitqueryGetTransactionsByAddressQuery = void 0;
+const core_1 = require("@urql/core");
+exports.bitqueryGetTransactionsByAddressQuery = (0, core_1.gql) `
+  query getTransactions($address: String!, $limit: Int!, $offset: Int!, $network: EthereumNetwork!) {
+    ethereum(network: $network) {
+      sent: transfers(options: { limit: $limit, offset: $offset }, sender: { is: $address }) {
+        block {
+          timestamp {
+            unixtime
+          }
+          height
+        }
+        amount
+        currency {
+          address
+          tokenType
+          symbol
+          decimals
+          name
+        }
+        sender {
+          address
+        }
+        receiver {
+          address
+        }
+        transaction {
+          gasValue
+          hash
+        }
+        entityId
+      }
+      received: transfers(options: { limit: $limit, offset: $offset }, receiver: { is: $address }) {
+        block {
+          timestamp {
+            unixtime
+          }
+          height
+        }
+        amount
+        currency {
+          address
+          tokenType
+        }
+        sender {
+          address
+        }
+        receiver {
+          address
+        }
+        transaction {
+          gasValue
+          hash
+        }
+        entityId
+      }
+      sentCount: transfers(sender: { is: $address }) {
+        count
+      }
+      receiverCount: transfers(receiver: { is: $address }) {
+        count
+      }
+    }
+  }
+`;
+exports.bitqueryGetTransactionQuery = (0, core_1.gql) `
+  query getTransaction($hash: String!, $network: EthereumNetwork!) {
+    ethereum(network: $network) {
+      transfers(txHash: { is: $hash }) {
+        block {
+          timestamp {
+            unixtime
+          }
+          height
+        }
+        amount
+        currency {
+          address
+          tokenType
+        }
+        sender {
+          address
+        }
+        receiver {
+          address
+        }
+        transaction {
+          gasValue
+          hash
+        }
+        entityId
+      }
+    }
+  }
+`;
+exports.bitqueryGetTokenInfoQuery = (0, core_1.gql) `
+  query getTokenInfo($hash: String!, $network: EthereumNetwork!) {
+    ethereum(network: $network) {
+      smartContractCalls(smartContractAddress: { is: $hash }) {
+        smartContract {
+          address {
+            address
+          }
+          currency {
+            symbol
+            name
+            decimals
+            tokenType
+          }
+        }
+      }
+    }
+  }
+`;
+exports.bitqueryGetBalanceQuery = (0, core_1.gql) `
+  query getBalance($address: String!, $network: EthereumNetwork!) {
+    ethereum(network: $network) {
+      address(address: { is: $address }) {
+        balances {
+          currency {
+            address
+            symbol
+            name
+            decimals
+          }
+          value
+        }
+      }
+    }
+  }
+`;
+exports.bitqueryGetPricesQuery = (0, core_1.gql) `
+  query getPrice($after: ISO8601DateTime!, $network: EthereumNetwork!) {
+    ethereum(network: $network) {
+      dexTrades(
+        options: { limitBy: { each: "baseCurrency.address", limit: 1 }, desc: "date.date" }
+        time: { after: $after }
+      ) {
+        quoteCurrency(quoteCurrency: { is: "0xdac17f958d2ee523a2206206994597c13d831ec7" }) {
+          symbol
+          address
+        }
+        baseCurrency {
+          symbol
+          address
+        }
+        date {
+          date
+        }
+        quotePrice
+      }
+    }
+  }
+`;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './BSEthereum';
+export * from './GhostMarketNDSEthereum';
+export * from './constants';
+export * from './BitqueryBDSEthereum';
+export * from './BitqueryEDSEthereum';
+export * from './RpcBDSEthereum';

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./BSEthereum"), exports);
+__exportStar(require("./GhostMarketNDSEthereum"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./BitqueryBDSEthereum"), exports);
+__exportStar(require("./BitqueryEDSEthereum"), exports);
+__exportStar(require("./RpcBDSEthereum"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-ethereum",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",
@@ -11,7 +11,7 @@
     "test": "jest --config jest.config.ts"
   },
   "dependencies": {
-    "@cityofzion/blockchain-service": "0.7.0",
+    "@cityofzion/blockchain-service": "0.7.1",
     "ethers": "5.7.2",
     "@urql/core": "~4.1.1",
     "graphql": "~16.8.0",