@cityofzion/bs-neo-legacy 0.7.0 → 0.7.2

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": "483e2ada6eba13805941d12c50530b395b3f6ca9",
+    "packages/bs-neo-legacy/src/BSNeoLegacy.ts": "ce59dc999823497ba0f79ec31afb81aec1d29351",
+    "packages/bs-neo-legacy/src/CryptoCompareEDSNeoLegacy.ts": "7cbe7bf0e39f100edd329a9211006c3c1994a1c2",
+    "packages/bs-neo-legacy/src/DoraBDSNeoLegacy.ts": "d716619bf8b8331cd3025abc7fa1ccda6386a461",
+    "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": "c7f58d681afa54f5c08d809a1ace9947b56fb633"
+  },
+  "arguments": "tsc  --project tsconfig.build.json "
+}

package/bs-neo-legacy.build.log

@@ -1,6 +1,2 @@
-Invoking: tsc && typedoc src/index.ts 
-./src/BSNeoLegacy.ts:87:8 - warning TransactionIntentResponse is referenced by BSNeoLegacy.setTypeIntents.setTypeIntents but not included in the documentation.
+Invoking: tsc  --project tsconfig.build.json 
 
-87            type TransactionIntentResponse = IntentTransactionParam & { type: 'native' | 'nep5' }
-
-Documentation generated at ./docs

package/dist/BSNeoLegacy.d.ts

@@ -1,36 +1,23 @@
-import { Account, BDSClaimable, BlockchainDataService, BlockchainService, CalculateTransferFeeResponse, ClaimResponse, Claimable, Exchange, SendTransactionParam, Token } from '@cityofzion/blockchain-service';
-export declare class BSNeoLegacy<BSCustomName extends string = string> implements BlockchainService, Claimable {
-    dataService: BlockchainDataService & BDSClaimable;
-    blockchainName: BSCustomName;
-    derivationPath: string;
-    feeToken: {
-        hash: string;
-        symbol: string;
-        decimals: number;
-    };
-    exchange: Exchange;
-    tokenClaim: {
-        hash: string;
-        symbol: string;
-        decimals: number;
-    };
+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 keychain;
-    private nativeAssets;
-    constructor(blockchainName: BSCustomName);
-    sendTransaction(param: SendTransactionParam): Promise<string>;
-    private buildNativeTransaction;
-    private buildNep5Transaction;
-    private setTypeIntents;
-    private isNativeTransaction;
-    generateMnemonic(): string;
-    generateWif(mnemonic: string, index: number): string;
-    generateAccount(mnemonic: string, index: number): Account;
-    generateAccountFromWif(wif: string): string;
-    decryptKey(encryptedKey: string, password: string): Promise<Account>;
+    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;
-    calculateTransferFee(): Promise<CalculateTransferFeeResponse>;
-    claim(account: Account): Promise<ClaimResponse>;
+    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

@@ -1,27 +1,4 @@
 "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) {
@@ -42,175 +19,152 @@ 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 AsteroidSDK = __importStar(require("@moonlight-io/asteroid-sdk-js"));
 const neon_js_1 = require("@cityofzion/neon-js");
-const explorer_1 = require("./explorer");
 const constants_1 = require("./constants");
-const [gasToken, 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.derivationPath = "m/44'/888'/0'/0/?";
-        this.tokenClaim = neoToken;
-        this.tokens = tokens_json_1.default;
-        this.keychain = new AsteroidSDK.Keychain();
-        this.nativeAssets = constants_1.nativeAssetsNeoLegacy;
+    constructor(blockchainName, network) {
+        if (network.type === 'custom')
+            throw new Error('Custom network is not supported for NEO Legacy');
         this.blockchainName = blockchainName;
-    }
-    sendTransaction(param) {
+        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;
-        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 result = isNativeTransaction ? yield transactionOperations.native() : yield transactionOperations.nep5();
-            if (!result.tx)
-                throw new Error("Failed to send transaction");
-            return result.tx.hash;
-        });
+        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);
     }
-    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)];
-            }
-        });
-        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);
+    validateAddress(address) {
+        return neon_js_1.wallet.isAddress(address);
     }
-    generateMnemonic() {
-        var _a;
-        this.keychain.generateMnemonic(128);
-        const list = (_a = this.keychain.mnemonic) === null || _a === void 0 ? void 0 : _a.toString();
-        if (!list)
-            throw new Error("Failed to generate mnemonic");
-        return list;
+    validateEncrypted(key) {
+        return neon_js_1.wallet.isNEP2(key);
     }
-    generateWif(mnemonic, index) {
-        this.keychain.importMnemonic(mnemonic);
-        const childKey = this.keychain.generateChildKey('neo', this.derivationPath.replace('?', index.toString()));
-        return childKey.getWIF();
+    validateKey(key) {
+        return neon_js_1.wallet.isWIF(key) || neon_js_1.wallet.isPrivateKey(key);
     }
-    generateAccount(mnemonic, index) {
-        const wif = this.generateWif(mnemonic, index);
-        const { address } = new neon_js_1.wallet.Account(wif);
-        const result = { address, wif };
-        return result;
+    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 };
     }
-    generateAccountFromWif(wif) {
-        return new neon_js_1.wallet.Account(wif).address;
+    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 };
     }
-    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);
         });
     }
-    validateAddress(address) {
-        return neon_js_1.wallet.isAddress(address);
-    }
-    validateEncryptedKey(encryptedKey) {
-        return neon_js_1.wallet.isNEP2(encryptedKey);
-    }
-    validateWif(wif) {
-        return neon_js_1.wallet.isWIF(wif);
-    }
-    calculateTransferFee() {
-        throw new Error(`Doesn't have fee to make a transaction on ${this.blockchainName}`);
+    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 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;
+                }
+                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;
+            if (!response.tx)
+                throw new Error('Failed to claim');
+            return response.tx.hash;
         });
     }
 }

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>;
+}

package/dist/DoraBDSNeoLegacy.js

@@ -0,0 +1,162 @@
+"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.DoraBDSNeoLegacy = void 0;
+const dora_ts_1 = require("@cityofzion/dora-ts");
+const constants_1 = require("./constants");
+const neon_js_1 = require("@cityofzion/neon-js");
+class DoraBDSNeoLegacy {
+    constructor(network, feeToken, claimToken) {
+        this.tokenCache = new Map();
+        if (network.type === 'custom')
+            throw new Error('Custom network is not supported for NEO Legacy');
+        this.network = network;
+        this.claimToken = claimToken;
+        this.feeToken = feeToken;
+    }
+    getTransaction(hash) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield dora_ts_1.api.NeoLegacyREST.transaction(hash, this.network.type);
+            if (!data || 'error' in data)
+                throw new Error(`Transaction ${hash} not found`);
+            const vout = (_a = data.vout) !== null && _a !== void 0 ? _a : [];
+            const promises = vout.map((transfer, _index, array) => __awaiter(this, void 0, void 0, function* () {
+                var _d;
+                const token = yield this.getTokenInfo(transfer.asset);
+                return {
+                    amount: String(transfer.value),
+                    from: (_d = array[array.length - 1]) === null || _d === void 0 ? void 0 : _d.address,
+                    contractHash: transfer.asset,
+                    to: transfer.address,
+                    type: 'token',
+                    token,
+                };
+            }));
+            const transfers = yield Promise.all(promises);
+            return {
+                hash: data.txid,
+                block: data.block,
+                fee: (Number((_b = data.sys_fee) !== null && _b !== void 0 ? _b : 0) + Number((_c = data.net_fee) !== null && _c !== void 0 ? _c : 0)).toFixed(this.feeToken.decimals),
+                time: Number(data.time),
+                notifications: [],
+                transfers,
+            };
+        });
+    }
+    getTransactionsByAddress({ address, page = 1, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield dora_ts_1.api.NeoLegacyREST.getAddressAbstracts(address, page, this.network.type);
+            const transactions = new Map();
+            const promises = data.entries.map((entry) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                if (entry.address_from !== address && entry.address_to !== address)
+                    return;
+                const token = yield this.getTokenInfo(entry.asset);
+                const transfer = {
+                    amount: String(entry.amount),
+                    from: (_a = entry.address_from) !== null && _a !== void 0 ? _a : 'Mint',
+                    to: (_b = entry.address_to) !== null && _b !== void 0 ? _b : 'Burn',
+                    type: 'token',
+                    contractHash: entry.asset,
+                    token,
+                };
+                const existingTransaction = transactions.get(entry.txid);
+                if (existingTransaction) {
+                    existingTransaction.transfers.push(transfer);
+                    return;
+                }
+                transactions.set(entry.txid, {
+                    block: entry.block_height,
+                    hash: entry.txid,
+                    time: entry.time,
+                    transfers: [transfer],
+                    notifications: [],
+                });
+            }));
+            yield Promise.all(promises);
+            return {
+                totalCount: data.total_entries,
+                limit: data.page_size,
+                transactions: Array.from(transactions.values()),
+            };
+        });
+    }
+    getContract(contractHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield dora_ts_1.api.NeoLegacyREST.contract(contractHash, this.network.type);
+            if (!response || 'error' in response)
+                throw new Error(`Contract ${contractHash} not found`);
+            return {
+                hash: response.hash,
+                name: response.name,
+                methods: [],
+            };
+        });
+    }
+    getTokenInfo(tokenHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const localToken = constants_1.TOKENS[this.network.type].find(token => token.hash === tokenHash);
+            if (localToken)
+                return localToken;
+            if (this.tokenCache.has(tokenHash)) {
+                return this.tokenCache.get(tokenHash);
+            }
+            const data = yield dora_ts_1.api.NeoLegacyREST.asset(tokenHash, this.network.type);
+            if (!data || 'error' in data)
+                throw new Error(`Token ${tokenHash} not found`);
+            const token = {
+                decimals: data.decimals,
+                symbol: data.symbol,
+                hash: data.scripthash,
+                name: data.name,
+            };
+            this.tokenCache.set(tokenHash, token);
+            return token;
+        });
+    }
+    getBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield dora_ts_1.api.NeoLegacyREST.balance(address, this.network.type);
+            const promises = data.map((balance) => __awaiter(this, void 0, void 0, function* () {
+                let token = {
+                    hash: balance.asset,
+                    name: balance.asset_name,
+                    symbol: balance.symbol,
+                    decimals: 8,
+                };
+                try {
+                    token = yield this.getTokenInfo(balance.asset);
+                }
+                catch (_a) { }
+                return {
+                    amount: Number(balance.balance).toFixed(token.decimals),
+                    token,
+                };
+            }));
+            const result = yield Promise.all(promises);
+            return result;
+        });
+    }
+    getUnclaimed(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { unclaimed } = yield dora_ts_1.api.NeoLegacyREST.getUnclaimed(address, this.network.type);
+            return (unclaimed / Math.pow(10, this.claimToken.decimals)).toFixed(this.claimToken.decimals);
+        });
+    }
+    getBlockHeight() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rpcClient = new neon_js_1.rpc.RPCClient(this.network.url);
+            return yield rpcClient.getBlockCount();
+        });
+    }
+}
+exports.DoraBDSNeoLegacy = DoraBDSNeoLegacy;