@cityofzion/bs-neo-legacy 0.4.2 → 0.7.1

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

@@ -0,0 +1,21 @@
+{
+  "files": {
+    "packages/bs-neo-legacy/jest.config.ts": "d944475db93cbe41a9339187fd94b9962e411c43",
+    "packages/bs-neo-legacy/jest.setup.ts": "9a1976a32050616d4d2ee95b1aa21041bc4daca3",
+    "packages/bs-neo-legacy/package.json": "c0b7d3d28174c6ce4652a442ad6b9485ee49f45c",
+    "packages/bs-neo-legacy/src/BSNeoLegacy.ts": "ce59dc999823497ba0f79ec31afb81aec1d29351",
+    "packages/bs-neo-legacy/src/CryptoCompareEDSNeoLegacy.ts": "7cbe7bf0e39f100edd329a9211006c3c1994a1c2",
+    "packages/bs-neo-legacy/src/DoraBDSNeoLegacy.ts": "3ac617c879987ae8106cb212c36523909fffe79d",
+    "packages/bs-neo-legacy/src/__tests__/BDSNeoLegacy.spec.ts": "04210ed3cc8b8afbc824417be87eac06d1f875fd",
+    "packages/bs-neo-legacy/src/__tests__/BSNeoLegacy.spec.ts": "b2cff48a43db986fc02fdefbfd66a5cd4d70a5d9",
+    "packages/bs-neo-legacy/src/__tests__/CryptoCompareExchange.spec.ts": "0aeb2e77cf1d3eabc7534d2b9cbc26e93240852d",
+    "packages/bs-neo-legacy/src/assets/tokens/common.json": "81b0a9bb3e6c1b5bb41f57e6b1fc403ce1ac1489",
+    "packages/bs-neo-legacy/src/assets/tokens/mainnet.json": "e1194b98d7a91a8494760d597a90c02e00880972",
+    "packages/bs-neo-legacy/src/constants.ts": "82e36146cf6cf3c16bc7b7ec4fd3e4089c745bd5",
+    "packages/bs-neo-legacy/src/index.ts": "247e7d072502350e685e11497aeedc89b7c921d5",
+    "packages/bs-neo-legacy/tsconfig.build.json": "4dc23fb9c4c5e4d19a9bc3947a47c523f4bd967c",
+    "packages/bs-neo-legacy/tsconfig.json": "77cf2b789e9c665b62792f9992cc81ae86296ef7",
+    "common/config/rush/npm-shrinkwrap.json": "4994dce94cedd11a678400d92e08741ac7bc9d3f"
+  },
+  "arguments": "tsc  --project tsconfig.build.json "
+}

package/.rush/temp/shrinkwrap-deps.json

@@ -1,6 +1,6 @@
 {
-  "../../packages/bs-neo-legacy": "../../packages/bs-neo-legacy:HkvBj9ja9tB6vd7+Cu0p4TMieRu2PNACZVDxqAU1VgY=:",
-  "/@cityofzion/blockchain-service/0.3.2": "sha512-C84+HmZpgh5ThD0YhvVWH8arAPx7q9FKOLkct5k76v/kkDqb7s0h7xH99Yw01+BjZYOktOcTRJo31ao4QtQGdw==",
+  "../../packages/bs-neo-legacy": "../../packages/bs-neo-legacy:IOE6x0Jg1o1QcNEwF2rtSNHgOZi7/+bAniT1hAF6CJI=:",
+  "/@cityofzion/blockchain-service/0.3.0": "sha512-Qe/lVI8tCAAVZZNeBglZEFrqS9khjihc5jkiiEobi6CY4l1z6uFj/xSGQ7Nnz2QlTNQ8DjUqN05iDjKuy+4LLA==",
   "/@cityofzion/dora-ts/0.0.11": "sha512-LJWGU29BHPTHkt0i/OwhNdMfUGM/rgAa4rqlDwBy95spxSoUHGSoAtOD5k4aSVKmLFwq77ghNna0Lpc7lEuHBA==",
   "/@cityofzion/neon-api/4.9.0_@cityofzion+neon-core@4.9.0": "sha512-8eN3N3sGgd4L7qFaFATKr94kA/65626eo6hB7fHL+S8OGCVCrrl3tfh8GAOv50vLxd2YyoDu9pBY/0NPKY8tsQ==",
   "/@cityofzion/neon-core/4.9.0": "sha512-z4UgEIjAS9E2QP6HSTzri02DFY++nYmfzbspi1818mvnTst6Lf8bDNYYxG/686wdYN2dEF3RuccMXraw2Bm31g==",

package/bs-neo-legacy.build.log

@@ -1,87 +1,2 @@
-Invoking: tsc && typedoc 
+Invoking: tsc  --project tsconfig.build.json 
 
-C:/Workspace/blockchain-services/packages/blockchain-service/dist/interfaces.d.ts:140:0 - warning BlockchainDataService is referenced by BDSNeoLegacy but not included in the documentation.
-
-140    export interface BlockchainDataService {
-
-C:/Workspace/blockchain-services/packages/blockchain-service/dist/interfaces.d.ts:137:0 - warning BDSClaimable is referenced by BDSNeoLegacy but not included in the documentation.
-
-137    export interface BDSClaimable {
-
-C:/Workspace/blockchain-services/packages/blockchain-service/dist/interfaces.d.ts:60:0 - warning BlockchainService is referenced by BSNeoLegacy but not included in the documentation.
-
-60    export interface BlockchainService<BSCustomName extends string = string> {
-
-C:/Workspace/blockchain-services/packages/blockchain-service/dist/interfaces.d.ts:30:0 - warning Claimable is referenced by BSNeoLegacy but not included in the documentation.
-
-30    export interface Claimable {
-
-C:/Workspace/blockchain-services/packages/blockchain-service/dist/interfaces.d.ts:126:0 - warning BlockchainNetwork is referenced by BDSNeoLegacy.network but not included in the documentation.
-
-126    export type BlockchainNetwork = "mainnet" | "testnet" | "privatenet";
-
-C:/Workspace/blockchain-services/packages/blockchain-service/dist/interfaces.d.ts:156:0 - warning Exchange is referenced by BSNeoLegacy.exchange but not included in the documentation.
-
-156    export interface Exchange {
-
-C:/Workspace/blockchain-services/packages/blockchain-service/dist/interfaces.d.ts:11:0 - warning TokenInfo is referenced by BSNeoLegacy.feeToken but not included in the documentation.
-
-11    export type TokenInfo = {
-
-C:/Workspace/blockchain-services/packages/blockchain-service/dist/interfaces.d.ts:46:0 - warning Token is referenced by BSNeoLegacy.tokens but not included in the documentation.
-
-46    export type Token = {
-
-C:/Workspace/blockchain-services/packages/blockchain-service/dist/interfaces.d.ts:118:0 - warning ConsensusNodeResponse is referenced by BDSNeoLegacy.getAllNodes.getAllNodes but not included in the documentation.
-
-118    export type ConsensusNodeResponse = {
-
-C:/Workspace/blockchain-services/packages/blockchain-service/dist/interfaces.d.ts:127:0 - warning BalanceResponse is referenced by BDSNeoLegacy.getBalance.getBalance but not included in the documentation.
-
-127    export type BalanceResponse = {
-
-C:/Workspace/blockchain-services/packages/blockchain-service/dist/interfaces.d.ts:113:0 - warning ContractResponse is referenced by BDSNeoLegacy.getContract.getContract but not included in the documentation.
-
-113    export type ContractResponse = {
-
-C:/Workspace/blockchain-services/packages/blockchain-service/dist/interfaces.d.ts:105:0 - warning TransactionHistoryResponse is referenced by BDSNeoLegacy.getHistoryTransactions.getHistoryTransactions but not included in the documentation.
-
-105    export type TransactionHistoryResponse = {
-
-C:/Workspace/blockchain-services/packages/blockchain-service/dist/interfaces.d.ts:122:0 - warning TokenInfoResponse is referenced by BDSNeoLegacy.getTokenInfo.getTokenInfo but not included in the documentation.
-
-122    export type TokenInfoResponse = {
-
-C:/Workspace/blockchain-services/packages/blockchain-service/dist/interfaces.d.ts:84:0 - warning TransactionResponse is referenced by BDSNeoLegacy.getTransaction.getTransaction but not included in the documentation.
-
-84    export type TransactionResponse = {
-
-C:/Workspace/blockchain-services/packages/blockchain-service/dist/interfaces.d.ts:133:0 - warning UnclaimedResponse is referenced by BDSNeoLegacy.getUnclaimed.getUnclaimed but not included in the documentation.
-
-133    export type UnclaimedResponse = {
-
-C:/Workspace/blockchain-services/packages/blockchain-service/dist/interfaces.d.ts:56:0 - warning CalculateTransferFeeResponse is referenced by BSNeoLegacy.calculateTransferFee.calculateTransferFee but not included in the documentation.
-
-56    export type CalculateTransferFeeResponse = {
-
-C:/Workspace/blockchain-services/packages/blockchain-service/dist/interfaces.d.ts:25:0 - warning ClaimResponse is referenced by BSNeoLegacy.claim.claim but not included in the documentation.
-
-25    export type ClaimResponse = {
-
-C:/Workspace/blockchain-services/packages/blockchain-service/dist/interfaces.d.ts:52:0 - warning Account is referenced by BSNeoLegacy.decryptKey.decryptKey but not included in the documentation.
-
-52    export type Account = {
-
-./src/BSNeoLegacy.ts:149:8 - warning TransactionIntentResponse is referenced by BSNeoLegacy.setTypeIntents.setTypeIntents but not included in the documentation.
-
-149            type TransactionIntentResponse = IntentTransactionParam & { type: 'native' | 'nep5' }
-
-C:/Workspace/blockchain-services/packages/blockchain-service/dist/interfaces.d.ts:6:0 - warning IntentTransactionParam is referenced by BSNeoLegacy.buildNativeTransaction.buildNativeTransaction.transactionIntents but not included in the documentation.
-
-6    export type IntentTransactionParam = {
-
-C:/Workspace/blockchain-services/packages/blockchain-service/dist/interfaces.d.ts:1:0 - warning SendTransactionParam is referenced by BSNeoLegacy.sendTransaction.sendTransaction.param but not included in the documentation.
-
-1    export type SendTransactionParam = {
-
-Documentation generated at ./docs

package/dist/BSNeoLegacy.d.ts

@@ -1,26 +1,23 @@
-import { Account, BDSClaimable, BlockchainDataService, BlockchainService, CalculateTransferFeeResponse, ClaimResponse, Claimable, Exchange, SendTransactionParam, Token, TokenInfo } from '@cityofzion/blockchain-service';
-export declare class BSNeoLegacy<BSCustomName extends string = string> implements BlockchainService, Claimable {
-    dataService: BlockchainDataService & BDSClaimable;
-    blockchainName: BSCustomName;
-    feeToken: TokenInfo;
-    exchange: Exchange;
-    tokenClaim: TokenInfo;
+import { Account, BDSClaimable, BlockchainDataService, BlockchainService, BSClaimable, ExchangeDataService, Token, Network, PartialBy, TransferParam, AccountWithDerivationPath } from '@cityofzion/blockchain-service';
+export declare class BSNeoLegacy<BSCustomName extends string = string> implements BlockchainService, BSClaimable {
+    readonly blockchainName: BSCustomName;
+    readonly feeToken: Token;
+    readonly claimToken: Token;
+    readonly burnToken: Token;
+    readonly derivationPath: string;
+    blockchainDataService: BlockchainDataService & BDSClaimable;
+    exchangeDataService: ExchangeDataService;
     tokens: Token[];
-    private nativeAssets;
-    private derivationPath;
-    constructor(blockchainName: BSCustomName);
+    network: Network;
+    legacyNetwork: string;
+    constructor(blockchainName: BSCustomName, network: PartialBy<Network, 'url'>);
+    setNetwork(param: PartialBy<Network, 'url'>): void;
     validateAddress(address: string): boolean;
-    validateEncryptedKey(encryptedKey: string): boolean;
-    validateWif(wif: string): boolean;
-    generateMnemonic(): string[];
-    generateAccount(mnemonic: string[], index: number): Account;
-    generateAccountFromWif(wif: string): Account;
-    decryptKey(encryptedKey: string, password: string): Promise<Account>;
-    calculateTransferFee(): Promise<CalculateTransferFeeResponse>;
-    sendTransaction(param: SendTransactionParam): Promise<string>;
-    claim(account: Account): Promise<ClaimResponse>;
-    private buildNativeTransaction;
-    private buildNep5Transaction;
-    private setTypeIntents;
-    private isNativeTransaction;
+    validateEncrypted(key: string): boolean;
+    validateKey(key: string): boolean;
+    generateAccountFromMnemonic(mnemonic: string[] | string, index: number): AccountWithDerivationPath;
+    generateAccountFromKey(key: string): Account;
+    decrypt(encryptedKey: string, password: string): Promise<Account>;
+    transfer({ intent: transferIntent, senderAccount, tipIntent, ...params }: TransferParam): Promise<string>;
+    claim(account: Account): Promise<string>;
 }

package/dist/BSNeoLegacy.js

@@ -19,170 +19,153 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSNeoLegacy = void 0;
-const blockchain_service_1 = require("@cityofzion/blockchain-service");
 const neon_js_1 = require("@cityofzion/neon-js");
-const explorer_1 = require("./explorer");
 const constants_1 = require("./constants");
-const [, neoToken] = constants_1.nativeAssetsNeoLegacy;
-const tokens_json_1 = __importDefault(require("./asset/tokens.json"));
+const DoraBDSNeoLegacy_1 = require("./DoraBDSNeoLegacy");
+const CryptoCompareEDSNeoLegacy_1 = require("./CryptoCompareEDSNeoLegacy");
+const bs_asteroid_sdk_1 = require("@cityofzion/bs-asteroid-sdk");
 class BSNeoLegacy {
-    constructor(blockchainName) {
-        this.dataService = explorer_1.explorerNeoLegacyOption.dora;
-        this.tokenClaim = neoToken;
-        this.tokens = tokens_json_1.default;
-        this.nativeAssets = constants_1.nativeAssetsNeoLegacy;
-        this.derivationPath = "m/44'/888'/0'/0/?";
+    constructor(blockchainName, network) {
+        if (network.type === 'custom')
+            throw new Error('Custom network is not supported for NEO Legacy');
         this.blockchainName = blockchainName;
+        this.legacyNetwork = constants_1.LEGACY_NETWORK_BY_NETWORK_TYPE[network.type];
+        this.derivationPath = constants_1.DERIVATION_PATH;
+        this.tokens = constants_1.TOKENS[network.type];
+        this.claimToken = this.tokens.find(token => token.symbol === 'GAS');
+        this.burnToken = this.tokens.find(token => token.symbol === 'NEO');
+        this.feeToken = this.tokens.find(token => token.symbol === 'GAS');
+        this.setNetwork(network);
+    }
+    setNetwork(param) {
+        var _a;
+        if (param.type === 'custom')
+            throw new Error('Custom network is not supported for NEO Legacy');
+        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;
+        this.blockchainDataService = new DoraBDSNeoLegacy_1.DoraBDSNeoLegacy(network, this.feeToken, this.claimToken);
+        this.exchangeDataService = new CryptoCompareEDSNeoLegacy_1.CryptoCompareEDSNeoLegacy(network.type);
     }
     validateAddress(address) {
         return neon_js_1.wallet.isAddress(address);
     }
-    validateEncryptedKey(encryptedKey) {
-        return neon_js_1.wallet.isNEP2(encryptedKey);
+    validateEncrypted(key) {
+        return neon_js_1.wallet.isNEP2(key);
     }
-    validateWif(wif) {
-        return neon_js_1.wallet.isWIF(wif);
+    validateKey(key) {
+        return neon_js_1.wallet.isWIF(key) || neon_js_1.wallet.isPrivateKey(key);
     }
-    generateMnemonic() {
-        blockchain_service_1.keychain.generateMnemonic(128);
-        if (!blockchain_service_1.keychain.mnemonic)
-            throw new Error("Failed to generate mnemonic");
-        return blockchain_service_1.keychain.mnemonic.toString().split(' ');
+    generateAccountFromMnemonic(mnemonic, index) {
+        bs_asteroid_sdk_1.keychain.importMnemonic(Array.isArray(mnemonic) ? mnemonic.join(' ') : mnemonic);
+        const path = this.derivationPath.replace('?', index.toString());
+        const childKey = bs_asteroid_sdk_1.keychain.generateChildKey('neo', path);
+        const key = childKey.getWIF();
+        const { address } = new neon_js_1.wallet.Account(key);
+        return { address, key, type: 'wif', derivationPath: path };
     }
-    generateAccount(mnemonic, index) {
-        blockchain_service_1.keychain.importMnemonic(mnemonic.join(' '));
-        const childKey = blockchain_service_1.keychain.generateChildKey("neo", this.derivationPath.replace('?', index.toString()));
-        const wif = childKey.getWIF();
-        const { address } = new neon_js_1.wallet.Account(wif);
-        return { address, wif };
+    generateAccountFromKey(key) {
+        const type = neon_js_1.wallet.isWIF(key) ? 'wif' : neon_js_1.wallet.isPrivateKey(key) ? 'privateKey' : undefined;
+        if (!type)
+            throw new Error('Invalid key');
+        const { address } = new neon_js_1.wallet.Account(key);
+        return { address, key, type };
     }
-    generateAccountFromWif(wif) {
-        const { address } = new neon_js_1.wallet.Account(wif);
-        return { address, wif };
-    }
-    decryptKey(encryptedKey, password) {
+    decrypt(encryptedKey, password) {
         return __awaiter(this, void 0, void 0, function* () {
-            const wif = yield neon_js_1.wallet.decrypt(encryptedKey, password);
-            const { address } = new neon_js_1.wallet.Account(wif);
-            const result = { address, wif };
-            return result;
+            let BsReactNativeDecrypt;
+            try {
+                const { NativeModules } = require('react-native');
+                BsReactNativeDecrypt = NativeModules.BsReactNativeDecrypt;
+            }
+            catch (_a) {
+                const key = yield neon_js_1.wallet.decrypt(encryptedKey, password);
+                return this.generateAccountFromKey(key);
+            }
+            if (!BsReactNativeDecrypt) {
+                throw new Error('@CityOfZion/bs-react-native-decrypt is not installed');
+            }
+            const privateKey = yield BsReactNativeDecrypt.decryptNeoLegacy(encryptedKey, password);
+            return this.generateAccountFromKey(privateKey);
         });
     }
-    calculateTransferFee() {
-        throw new Error(`Doesn't have fee to make a transaction on ${this.blockchainName}`);
-    }
-    sendTransaction(param) {
-        var _a;
+    transfer(_a) {
+        var _b, _c;
+        var { intent: transferIntent, senderAccount, tipIntent } = _a, params = __rest(_a, ["intent", "senderAccount", "tipIntent"]);
         return __awaiter(this, void 0, void 0, function* () {
-            const url = (yield this.dataService.getHigherNode()).url;
-            const apiProvider = new neon_js_1.api.neoscan.instance("MainNet");
-            const account = new neon_js_1.wallet.Account(param.senderAccount.wif);
-            const intentsWithTye = this.setTypeIntents(param.transactionIntents);
-            const isNativeTransaction = intentsWithTye.every(intent => intent.type === 'native');
-            const priorityFee = (_a = param.priorityFee) !== null && _a !== void 0 ? _a : 0;
-            const [gasAsset] = this.nativeAssets;
-            const gasBalance = (yield this.dataService.getBalance(param.senderAccount.address)).find(balance => balance.hash === gasAsset.hash);
-            if ((gasBalance === null || gasBalance === void 0 ? void 0 : gasBalance.amount) < priorityFee)
-                throw new Error("Don't have funds to pay the transaction");
-            const transactionOperations = {
-                native: () => {
-                    return neon_js_1.api.sendAsset({
-                        account,
-                        api: apiProvider,
-                        url,
-                        intents: this.buildNativeTransaction(param.transactionIntents),
-                        fees: priorityFee
-                    });
-                },
-                nep5: () => {
-                    const extraIntentsNep5 = intentsWithTye.filter(it => it.type === 'native').map(it => {
-                        const { type } = it, rest = __rest(it, ["type"]);
-                        return rest;
-                    });
-                    return neon_js_1.api.doInvoke({
-                        intents: extraIntentsNep5.length > 0 ? this.buildNativeTransaction(extraIntentsNep5) : undefined,
-                        account,
-                        api: apiProvider,
-                        script: this.buildNep5Transaction(param.transactionIntents, param.senderAccount).str,
-                        url,
-                        fees: priorityFee
-                    });
+            const apiProvider = new neon_js_1.api.neoCli.instance(this.network.url);
+            const account = new neon_js_1.wallet.Account(senderAccount.key);
+            const priorityFee = Number((_b = params.priorityFee) !== null && _b !== void 0 ? _b : 0);
+            const nativeIntents = [];
+            const nep5ScriptBuilder = new neon_js_1.sc.ScriptBuilder();
+            const intents = [transferIntent, ...(tipIntent ? [tipIntent] : [])];
+            for (const intent of intents) {
+                const tokenHashFixed = intent.tokenHash.replace('0x', '');
+                const nativeAsset = constants_1.NATIVE_ASSETS.find(asset => asset.hash === tokenHashFixed);
+                if (nativeAsset) {
+                    nativeIntents.push(...neon_js_1.api.makeIntent({ [nativeAsset.symbol]: Number(intent.amount) }, intent.receiverAddress));
+                    continue;
                 }
-            };
-            const result = isNativeTransaction ? yield transactionOperations.native() : yield transactionOperations.nep5();
-            if (!result.tx)
-                throw new Error("Failed to send transaction");
-            return result.tx.hash;
+                nep5ScriptBuilder.emitAppCall(tokenHashFixed, 'transfer', [
+                    neon_js_1.u.reverseHex(neon_js_1.wallet.getScriptHashFromAddress(account.address)),
+                    neon_js_1.u.reverseHex(neon_js_1.wallet.getScriptHashFromAddress(intent.receiverAddress)),
+                    neon_js_1.sc.ContractParam.integer(new neon_js_1.u.Fixed8(intent.amount)
+                        .div(Math.pow(10, 8 - ((_c = intent.tokenDecimals) !== null && _c !== void 0 ? _c : 8)))
+                        .toRawNumber()
+                        .toString()),
+                ]);
+            }
+            let response;
+            if (nep5ScriptBuilder.isEmpty()) {
+                response = yield neon_js_1.api.sendAsset({
+                    account,
+                    api: apiProvider,
+                    url: this.network.url,
+                    intents: nativeIntents,
+                    fees: priorityFee,
+                });
+            }
+            else {
+                response = yield neon_js_1.api.doInvoke({
+                    intents: nativeIntents.length > 0 ? nativeIntents : undefined,
+                    account,
+                    api: apiProvider,
+                    script: nep5ScriptBuilder.str,
+                    url: this.network.url,
+                    fees: priorityFee,
+                });
+            }
+            if (!response.tx)
+                throw new Error('Failed to send transaction');
+            return response.tx.hash;
         });
     }
-    //Implementation Claim interface
     claim(account) {
         return __awaiter(this, void 0, void 0, function* () {
-            const neoAccount = new neon_js_1.wallet.Account(account.wif);
-            const balances = yield this.dataService.getBalance(account.address);
-            const neoBalance = balances.find(balance => balance.symbol === 'NEO');
-            const apiProvider = new neon_js_1.api.neoscan.instance("MainNet");
-            const neoNativeAsset = this.nativeAssets.find(nativeAsset => nativeAsset.symbol === (neoBalance === null || neoBalance === void 0 ? void 0 : neoBalance.symbol));
-            if (!neoNativeAsset || !neoBalance)
-                throw new Error("Neo it's necessary to do a claim");
-            const hasClaim = yield this.dataService.getUnclaimed(account.address);
-            if (hasClaim.unclaimed <= 0)
+            const neoAccount = new neon_js_1.wallet.Account(account.key);
+            const balances = yield this.blockchainDataService.getBalance(account.address);
+            const neoBalance = balances.find(balance => balance.token.symbol === 'NEO');
+            if (!neoBalance)
+                throw new Error('It is necessary to have NEO to claim');
+            const unclaimed = yield this.blockchainDataService.getUnclaimed(account.address);
+            if (Number(unclaimed) <= 0)
                 throw new Error(`Doesn't have gas to claim`);
-            const url = (yield this.dataService.getHigherNode()).url;
-            const claims = yield neon_js_1.api.neoCli.getClaims(url, account.address);
-            const claimGasResponse = yield neon_js_1.api.claimGas({
+            const apiProvider = new neon_js_1.api.neoCli.instance(this.legacyNetwork);
+            const claims = yield apiProvider.getClaims(account.address);
+            const response = yield neon_js_1.api.claimGas({
                 claims,
                 api: apiProvider,
                 account: neoAccount,
-                url
+                url: this.network.url,
             });
-            const result = {
-                txid: claimGasResponse.response.txid,
-                hash: constants_1.unclaimedTokenNeoLegacy.hash,
-                symbol: constants_1.unclaimedTokenNeoLegacy.symbol
-            };
-            return result;
-        });
-    }
-    buildNativeTransaction(transactionIntents) {
-        let intents = [];
-        transactionIntents.forEach(transaction => {
-            const nativeAsset = this.nativeAssets.find(asset => asset.hash === transaction.tokenHash);
-            if (nativeAsset) {
-                intents = [...intents, ...neon_js_1.api.makeIntent({ [nativeAsset.symbol]: transaction.amount }, transaction.receiverAddress)];
-            }
+            if (!response.tx)
+                throw new Error('Failed to claim');
+            return response.tx.hash;
         });
-        return intents;
-    }
-    buildNep5Transaction(transactionIntents, senderAccount) {
-        const sb = new neon_js_1.sc.ScriptBuilder();
-        transactionIntents.forEach(transaction => {
-            if (!this.isNativeTransaction(transaction)) {
-                const senderHash = neon_js_1.u.reverseHex(neon_js_1.wallet.getScriptHashFromAddress(senderAccount.address));
-                const receiveHash = neon_js_1.u.reverseHex(neon_js_1.wallet.getScriptHashFromAddress(transaction.receiverAddress));
-                const adjustedAmount = new neon_js_1.u.Fixed8(transaction.amount).toRawNumber();
-                sb.emitAppCall(transaction.tokenHash.replace('0x', ''), "transfer", [
-                    senderHash,
-                    receiveHash,
-                    neon_js_1.sc.ContractParam.integer(adjustedAmount.toString())
-                ]);
-            }
-        });
-        return sb;
-    }
-    setTypeIntents(transactionIntents) {
-        const intents = transactionIntents.map(transaction => {
-            return Object.assign(Object.assign({}, transaction), { type: this.isNativeTransaction(transaction) ? 'native' : 'nep5' });
-        });
-        return intents;
-    }
-    isNativeTransaction(transactionParam) {
-        return this.nativeAssets.some(asset => asset.hash === transactionParam.tokenHash);
     }
 }
 exports.BSNeoLegacy = BSNeoLegacy;

package/dist/CryptoCompareEDSNeoLegacy.d.ts

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

package/dist/CryptoCompareEDSNeoLegacy.js

@@ -0,0 +1,41 @@
+"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.CryptoCompareEDSNeoLegacy = void 0;
+const axios_1 = __importDefault(require("axios"));
+const constants_1 = require("./constants");
+class CryptoCompareEDSNeoLegacy {
+    constructor(network) {
+        this.networkType = network;
+        this.axiosInstance = axios_1.default.create({ baseURL: 'https://min-api.cryptocompare.com' });
+    }
+    getTokenPrices(currency) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.networkType !== 'mainnet')
+                throw new Error('Exchange is only available on mainnet');
+            const tokenSymbols = constants_1.TOKENS[this.networkType].map(token => token.symbol);
+            const { data: prices } = yield this.axiosInstance.get('/data/pricemultifull', {
+                params: {
+                    fsyms: tokenSymbols.join(','),
+                    tsyms: currency,
+                },
+            });
+            return Object.entries(prices.RAW).map(([symbol, price]) => ({
+                symbol,
+                price: price[currency].PRICE,
+            }));
+        });
+    }
+}
+exports.CryptoCompareEDSNeoLegacy = CryptoCompareEDSNeoLegacy;

package/dist/DoraBDSNeoLegacy.d.ts

@@ -0,0 +1,15 @@
+import { BalanceResponse, BlockchainDataService, ContractResponse, TransactionsByAddressParams, TransactionsByAddressResponse, TransactionResponse, BDSClaimable, Token, Network } from '@cityofzion/blockchain-service';
+export declare class DoraBDSNeoLegacy implements BlockchainDataService, BDSClaimable {
+    readonly network: Network;
+    private readonly claimToken;
+    private readonly feeToken;
+    private readonly tokenCache;
+    constructor(network: Network, feeToken: Token, claimToken: Token);
+    getTransaction(hash: string): Promise<TransactionResponse>;
+    getTransactionsByAddress({ address, page, }: TransactionsByAddressParams): Promise<TransactionsByAddressResponse>;
+    getContract(contractHash: string): Promise<ContractResponse>;
+    getTokenInfo(tokenHash: string): Promise<Token>;
+    getBalance(address: string): Promise<BalanceResponse[]>;
+    getUnclaimed(address: string): Promise<string>;
+    getBlockHeight(): Promise<number>;
+}