@cityofzion/bs-neo3 0.7.0 → 0.7.2

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

@@ -1,20 +1,25 @@
 {
   "files": {
-    "packages/bs-neo3/package.json": "a239a2b9bf9ca2018c2e40f47bef83b52f048760",
-    "packages/bs-neo3/src/BDSNeo3.ts": "6de6c505219ad5404357ba195b9b59b368fc574f",
-    "packages/bs-neo3/src/BSNeo3.ts": "39c473d9be67c3cd0ccf253fd037d1c9ea881027",
-    "packages/bs-neo3/src/assets/blockchain_icon_neo.png": "3b3c8c019cc3ab191648acd69b07663006abf495",
-    "packages/bs-neo3/src/assets/blockchain_icon_neo_white.png": "feaec214f1374496e428254d8d014a8aa39b7067",
-    "packages/bs-neo3/src/assets/tokens.json": "33d65a4a123ae414a95b0caf031c6d62eb715349",
-    "packages/bs-neo3/src/constants.ts": "39993e77862b88d771441980cf39a091ae5dee3a",
-    "packages/bs-neo3/src/exceptions.ts": "c7b6401d197e363dca8241b92a4304c227e7800f",
-    "packages/bs-neo3/src/explorer/dora/DoraNeo3Responses.ts": "6ccd07c95af63d966ef370ae8861cb37783cc4da",
-    "packages/bs-neo3/src/explorer/dora/DoraNeo3Routes.ts": "b6b4b85492e1a9611f0f88c2d9836371f1fba20b",
-    "packages/bs-neo3/src/explorer/index.ts": "4e892cff669a805bf2f9cc29554bdfc4e43af6c1",
-    "packages/bs-neo3/src/index.ts": "53f10ade66205f959dca69e06c4d2b73d045424a",
-    "packages/bs-neo3/tsconfig.json": "9c0d05b4a1620310c7310c1d18e7b1afb1977ff9",
-    "packages/bs-neo3/yarn.lock": "5bb25dd89095cbb23ce0906458c1234eb7da3ba2",
-    "packages/bs-neo3/.rush/temp/shrinkwrap-deps.json": "44f504325b8dc37c61401f680f09cbf5fe4786ab"
+    "packages/bs-neo3/jest.config.ts": "d944475db93cbe41a9339187fd94b9962e411c43",
+    "packages/bs-neo3/jest.setup.ts": "9a1976a32050616d4d2ee95b1aa21041bc4daca3",
+    "packages/bs-neo3/package.json": "bba7849ac64221394efc7a7b35a9ad6ac81a7c08",
+    "packages/bs-neo3/src/BSNeo3.ts": "ac98a87cfd542ac1fdd1b2166ba2acb78a274126",
+    "packages/bs-neo3/src/DoraBDSNeo3.ts": "f94ef94afe666bc0991f5dd8e880d8fec8ade099",
+    "packages/bs-neo3/src/FlamingoEDSNeo3.ts": "f5fbb9ff405b02079c31493ae251aaea5defb77d",
+    "packages/bs-neo3/src/GhostMarketNDSNeo3.ts": "d7db2a624cf099fe550fa4a906f6127ca4815cac",
+    "packages/bs-neo3/src/RpcBDSNeo3.ts": "a548f689b39b42ce00452b1fb8f772b6ebbf7683",
+    "packages/bs-neo3/src/__tests__/BDSNeo3.spec.ts": "14bd204f3d4546c81b6ea37e16f3fe6e70102dd1",
+    "packages/bs-neo3/src/__tests__/BSNeo3.spec.ts": "edf56afc2efaa15d252eaaca0325cee364191699",
+    "packages/bs-neo3/src/__tests__/FlamingoEDSNeo3.spec.ts": "17e3b6f4dee4cb2222f3b4b1aed9d9a68ea037c0",
+    "packages/bs-neo3/src/__tests__/GhostMarketNDSNeo3.spec.ts": "1d583380b60112fb99426b4bf140c92898177b1e",
+    "packages/bs-neo3/src/__tests__/utils/sleep.ts": "c1eb515dad9f5c11eef5d5e77c85db4c3c8196a8",
+    "packages/bs-neo3/src/assets/tokens/common.json": "04691656019ba9234129b749553aa75828e77ef8",
+    "packages/bs-neo3/src/assets/tokens/mainnet.json": "f43f1a67f07c0b85977cf17dae825ae7fbb8eb21",
+    "packages/bs-neo3/src/constants.ts": "233a2c83f1829629865ace6fbf9c66cd39489c51",
+    "packages/bs-neo3/src/index.ts": "bad314a9ba14b57075684c9b823a934863bac6b2",
+    "packages/bs-neo3/tsconfig.build.json": "4dc23fb9c4c5e4d19a9bc3947a47c523f4bd967c",
+    "packages/bs-neo3/tsconfig.json": "77cf2b789e9c665b62792f9992cc81ae86296ef7",
+    "common/config/rush/npm-shrinkwrap.json": "c7f58d681afa54f5c08d809a1ace9947b56fb633"
   },
-  "arguments": "tsc && typedoc src/index.ts "
+  "arguments": "tsc --project tsconfig.build.json "
 }

package/bs-neo3.build.log

@@ -1,2 +1,2 @@
-Invoking: tsc && typedoc src/index.ts 
-Documentation generated at ./docs
+Invoking: tsc --project tsconfig.build.json 
+

package/dist/BSNeo3.d.ts

@@ -1,40 +1,27 @@
-import { BlockchainDataService, BlockchainService, SendTransactionParam, Claimable, Account, Exchange, BDSClaimable, Token, NeoNameService, NNSRecordTypes, CalculateTransferFeeResponse } from '@cityofzion/blockchain-service';
-export declare class BSNeo3<BSCustomName extends string = string> implements BlockchainService, Claimable, NeoNameService {
-    blockchainName: BSCustomName;
-    dataService: BlockchainDataService & BDSClaimable;
-    derivationPath: string;
-    feeToken: {
-        hash: string;
-        symbol: string;
-        decimals: number;
-    };
-    exchange: Exchange;
-    tokenClaim: {
-        hash: string;
-        symbol: string;
-        decimals: number;
-    };
+import { BlockchainDataService, BlockchainService, BSClaimable, Account, ExchangeDataService, BDSClaimable, Token, BSWithNameService, Network, PartialBy, TransferParam, BSCalculableFee, NftDataService, BSWithNft, AccountWithDerivationPath } from '@cityofzion/blockchain-service';
+export declare class BSNeo3<BSCustomName extends string = string> implements BlockchainService, BSClaimable, BSWithNameService, BSCalculableFee, BSWithNft {
+    readonly blockchainName: BSCustomName;
+    readonly feeToken: Token;
+    readonly claimToken: Token;
+    readonly burnToken: Token;
+    readonly derivationPath: string;
+    blockchainDataService: BlockchainDataService & BDSClaimable;
+    nftDataService: NftDataService;
+    exchangeDataService: ExchangeDataService;
     tokens: Token[];
-    private keychain;
-    constructor(blockchainName: BSCustomName);
-    sendTransaction(param: SendTransactionParam): Promise<string>;
-    private buildTransfer;
-    private signTransfer;
-    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;
+    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(param: SendTransactionParam): Promise<CalculateTransferFeeResponse>;
-    claim(account: Account): Promise<{
-        txid: string;
-        symbol: string;
-        hash: string;
-    }>;
-    getNNSRecord(domainName: string, type: NNSRecordTypes): Promise<any>;
-    getOwnerOfNNS(domainName: string): Promise<any>;
-    validateNNSFormat(domainName: string): boolean;
+    validateEncrypted(encryptedKey: string): boolean;
+    validateKey(key: string): boolean;
+    validateNameServiceDomainFormat(domainName: string): boolean;
+    generateAccountFromMnemonic(mnemonic: string[] | string, index: number): AccountWithDerivationPath;
+    generateAccountFromKey(key: string): Account;
+    decrypt(encryptedKey: string, password: string): Promise<Account>;
+    calculateTransferFee(param: TransferParam): Promise<string>;
+    transfer(param: TransferParam): Promise<string>;
+    claim(account: Account): Promise<string>;
+    resolveNameServiceDomain(domainName: string): Promise<any>;
+    private buildTransferInvocation;
 }

package/dist/BSNeo3.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) {
@@ -31,220 +8,175 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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.BSNeo3 = void 0;
-const blockchain_service_1 = require("@cityofzion/blockchain-service");
 const neon_js_1 = require("@cityofzion/neon-js");
-const AsteroidSDK = __importStar(require("@moonlight-io/asteroid-sdk-js"));
-const constants_1 = require("./constants");
-const exceptions_1 = require("./exceptions");
-const explorer_1 = require("./explorer");
-const tokens_json_1 = __importDefault(require("./assets/tokens.json"));
 const neon_invoker_1 = require("@cityofzion/neon-invoker");
 const neon_parser_1 = require("@cityofzion/neon-parser");
 const neo3_parser_1 = require("@cityofzion/neo3-parser");
-const NEO_NS_HASH = "0x50ac1c37690cc2cfc594472833cf57505d5f46de";
+const RpcBDSNeo3_1 = require("./RpcBDSNeo3");
+const DoraBDSNeo3_1 = require("./DoraBDSNeo3");
+const constants_1 = require("./constants");
+const FlamingoEDSNeo3_1 = require("./FlamingoEDSNeo3");
+const GhostMarketNDSNeo3_1 = require("./GhostMarketNDSNeo3");
+const bs_asteroid_sdk_1 = require("@cityofzion/bs-asteroid-sdk");
 class BSNeo3 {
-    constructor(blockchainName) {
-        this.dataService = explorer_1.explorerOptions.dora;
-        this.derivationPath = "m/44'/888'/0'/0/?";
-        this.feeToken = constants_1.gasInfoNeo3;
-        this.exchange = blockchain_service_1.exchangeOptions.flamingo;
-        this.tokenClaim = constants_1.neoInfoNeo3;
-        this.tokens = tokens_json_1.default;
-        this.keychain = new AsteroidSDK.Keychain();
+    constructor(blockchainName, network) {
         this.blockchainName = blockchainName;
-    }
-    sendTransaction(param) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const { senderAccount, transactionIntents } = param;
-                const node = yield this.dataService.getHigherNode();
-                const facade = yield neon_js_1.api.NetworkFacade.fromConfig({ node: node.url });
-                const intents = this.buildTransfer(transactionIntents, senderAccount);
-                const signing = this.signTransfer(senderAccount);
-                const result = yield facade.transferToken(intents, signing);
-                return result;
-            }
-            catch (error) {
-                throw error;
-            }
-        });
-    }
-    buildTransfer(transactionIntents, account) {
-        const intents = [];
-        const neoAccount = new neon_js_1.wallet.Account(account.wif);
-        for (const transactionIntent of transactionIntents) {
-            const { amount, receiverAddress, tokenHash } = transactionIntent;
-            intents.push({
-                to: receiverAddress,
-                contractHash: tokenHash,
-                from: neoAccount,
-                decimalAmt: amount,
-            });
-        }
-        return intents;
-    }
-    signTransfer(account) {
-        const neoAccount = new neon_js_1.wallet.Account(account.address);
-        const result = {
-            signingCallback: neon_js_1.api.signWithAccount(neoAccount)
+        this.tokens = constants_1.TOKENS[network.type];
+        this.derivationPath = constants_1.DERIVATION_PATH;
+        this.feeToken = this.tokens.find(token => token.symbol === 'GAS');
+        this.burnToken = this.tokens.find(token => token.symbol === 'NEO');
+        this.claimToken = this.tokens.find(token => token.symbol === 'GAS');
+        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],
         };
-        return result;
+        this.network = network;
+        if (network.type === 'custom') {
+            this.blockchainDataService = new RpcBDSNeo3_1.RPCBDSNeo3(network, this.feeToken, this.claimToken);
+        }
+        else {
+            this.blockchainDataService = new DoraBDSNeo3_1.DoraBDSNeo3(network, this.feeToken, this.claimToken);
+        }
+        this.exchangeDataService = new FlamingoEDSNeo3_1.FlamingoEDSNeo3(network.type);
+        this.nftDataService = new GhostMarketNDSNeo3_1.GhostMarketNDSNeo3(network.type);
     }
-    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;
+    validateAddress(address) {
+        return neon_js_1.wallet.isAddress(address, 53);
     }
-    generateWif(mnemonic, index) {
-        this.keychain.importMnemonic(mnemonic);
-        const childKey = this.keychain.generateChildKey('neo', this.derivationPath.replace('?', index.toString()));
-        return childKey.getWIF();
+    validateEncrypted(encryptedKey) {
+        return neon_js_1.wallet.isNEP2(encryptedKey);
     }
-    generateAccount(mnemonic, index) {
-        const wif = this.generateWif(mnemonic, index);
-        const { address } = new neon_js_1.wallet.Account(wif);
-        return { address, wif };
+    validateKey(key) {
+        return neon_js_1.wallet.isWIF(key) || neon_js_1.wallet.isPrivateKey(key);
     }
-    generateAccountFromWif(wif) {
-        const { address } = new neon_js_1.wallet.Account(wif);
-        return address;
+    validateNameServiceDomainFormat(domainName) {
+        if (!domainName.endsWith('.neo'))
+            return false;
+        return true;
     }
-    decryptKey(encryptedKey, password) {
+    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 };
+    }
+    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 };
+    }
+    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);
-            return { address, wif };
+            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.decryptNeo3(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(param) {
         return __awaiter(this, void 0, void 0, function* () {
-            const node = yield this.dataService.getHigherNode();
-            const url = node.url;
-            const rpcClient = new neon_js_1.rpc.NeoServerRpcClient(url);
-            const intents = this.buildTransfer(param.transactionIntents, param.senderAccount);
-            const txBuilder = new neon_js_1.api.TransactionBuilder();
-            for (const intent of intents) {
-                if (intent.decimalAmt) {
-                    const [tokenInfo] = yield neon_js_1.api.getTokenInfos([intent.contractHash], rpcClient);
-                    const amt = neon_js_1.u.BigInteger.fromDecimal(intent.decimalAmt, tokenInfo.decimals);
-                    txBuilder.addNep17Transfer(intent.from, intent.to, intent.contractHash, amt);
-                }
-            }
-            const txn = txBuilder.build();
-            const accountScriptHash = neon_js_1.wallet.getScriptHashFromAddress(param.senderAccount.address);
-            const invokeFunctionResponse = yield rpcClient.invokeScript(neon_js_1.u.HexString.fromHex(txn.script), [
-                {
-                    account: accountScriptHash,
-                    scopes: String(neon_js_1.tx.WitnessScope.CalledByEntry)
-                }
-            ]);
-            const systemFee = neon_js_1.u.BigInteger.fromNumber(invokeFunctionResponse.gasconsumed).toDecimal(constants_1.gasInfoNeo3.decimals);
-            const networkFeeResponse = yield rpcClient.calculateNetworkFee(txn);
-            const networkFee = (Number(networkFeeResponse) / Math.pow(10, constants_1.gasInfoNeo3.decimals));
-            const sumFee = Number(systemFee) + networkFee;
-            const result = {
-                result: sumFee,
-                details: {
-                    networkFee: networkFee.toString(),
-                    systemFee
-                }
-            };
-            return result;
+            const account = new neon_js_1.wallet.Account(param.senderAccount.key);
+            const invoker = yield neon_invoker_1.NeonInvoker.init({
+                rpcAddress: this.network.url,
+                account,
+            });
+            const invocations = this.buildTransferInvocation(param, account);
+            const { networkFee, systemFee } = yield invoker.calculateFee({
+                invocations,
+                signers: [],
+            });
+            return networkFee.add(systemFee).toDecimal(this.feeToken.decimals);
         });
     }
-    //Claimable interface implementation
-    claim(account) {
+    transfer(param) {
         return __awaiter(this, void 0, void 0, function* () {
-            const balance = yield this.dataService.getBalance(account.address);
-            const neoHash = constants_1.neoInfoNeo3.hash;
-            const neoBalance = balance.find(balance => balance.hash === neoHash);
-            const gasBalance = balance.find(balance => balance.hash === constants_1.gasInfoNeo3.hash);
-            const neoAccount = new neon_js_1.wallet.Account(account.wif);
-            if (!neoBalance || !gasBalance)
-                throw new Error(`Problem to claim`);
-            const dataToClaim = {
-                transactionIntents: [{ amount: neoBalance.amount, receiverAddress: account.address, tokenHash: neoBalance.hash }],
-                senderAccount: account
-            };
-            const feeToClaim = yield this.calculateTransferFee(dataToClaim);
-            if (gasBalance.amount < feeToClaim.result) {
-                exceptions_1.claimGasExceptions.InsuficientGas(String(gasBalance.amount), String(feeToClaim.result));
-            }
-            const url = (yield this.dataService.getHigherNode()).url;
-            const facade = yield neon_js_1.api.NetworkFacade.fromConfig({ node: url });
-            const signing = this.signTransfer(account);
-            const txid = yield facade.claimGas(neoAccount, signing);
-            const result = {
-                hash: constants_1.gasInfoNeo3.hash,
-                symbol: constants_1.gasInfoNeo3.symbol,
-                txid
-            };
-            return result;
+            const account = new neon_js_1.wallet.Account(param.senderAccount.key);
+            const invoker = yield neon_invoker_1.NeonInvoker.init({
+                rpcAddress: this.network.url,
+                account,
+            });
+            const invocations = this.buildTransferInvocation(param, account);
+            const transactionHash = yield invoker.invokeFunction({
+                invocations,
+                signers: [],
+            });
+            return transactionHash;
         });
     }
-    // Gets the record of a second-level domain or its subdomains with the specific type.
-    getNNSRecord(domainName, type) {
-        var _a;
+    claim(account) {
         return __awaiter(this, void 0, void 0, function* () {
-            const higherNode = yield this.dataService.getHigherNode();
-            const parser = neon_parser_1.NeonParser;
-            const invoker = yield neon_invoker_1.NeonInvoker.init(higherNode.url);
-            const response = yield invoker.testInvoke({
-                invocations: [{
-                        scriptHash: NEO_NS_HASH,
-                        operation: "getRecord",
-                        args: [{ type: "String", value: domainName }, { type: "Integer", value: type }]
-                    }]
+            const neoAccount = new neon_js_1.wallet.Account(account.key);
+            const facade = yield neon_js_1.api.NetworkFacade.fromConfig({ node: this.network.url });
+            const transactionHash = yield facade.claimGas(neoAccount, {
+                signingCallback: neon_js_1.api.signWithAccount(neoAccount),
             });
-            if (response.stack.length === 0) {
-                throw new Error((_a = response.exception) !== null && _a !== void 0 ? _a : 'unrecognized response');
-            }
-            const parsed = parser.parseRpcResponse(response.stack[0]);
-            return parsed;
+            return transactionHash;
         });
     }
-    getOwnerOfNNS(domainName) {
+    resolveNameServiceDomain(domainName) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const higherNode = yield this.dataService.getHigherNode();
             const parser = neon_parser_1.NeonParser;
-            const invoker = yield neon_invoker_1.NeonInvoker.init(higherNode.url);
+            const invoker = yield neon_invoker_1.NeonInvoker.init({ rpcAddress: this.network.url });
             const response = yield invoker.testInvoke({
-                invocations: [{
-                        scriptHash: NEO_NS_HASH,
-                        operation: "ownerOf",
-                        args: [{ type: "String", value: domainName }]
-                    }]
+                invocations: [
+                    {
+                        scriptHash: constants_1.NEO_NS_HASH,
+                        operation: 'ownerOf',
+                        args: [{ type: 'String', value: domainName }],
+                    },
+                ],
             });
             if (response.stack.length === 0) {
                 throw new Error((_a = response.exception) !== null && _a !== void 0 ? _a : 'unrecognized response');
             }
-            const parsed = parser.parseRpcResponse(response.stack[0], { type: neo3_parser_1.ABI_TYPES.HASH160.name });
-            const address = parser.accountInputToAddress(parsed.replace("0x", ""));
+            const parsed = parser.parseRpcResponse(response.stack[0], {
+                type: neo3_parser_1.ABI_TYPES.HASH160.name,
+            });
+            const address = parser.accountInputToAddress(parsed.replace('0x', ''));
             return address;
         });
     }
-    validateNNSFormat(domainName) {
-        if (!domainName.endsWith('.neo'))
-            return false;
-        return true;
+    buildTransferInvocation({ intent, tipIntent }, account) {
+        const intents = [intent, ...(tipIntent ? [tipIntent] : [])];
+        const invocations = intents.map(intent => {
+            return {
+                operation: 'transfer',
+                scriptHash: intent.tokenHash,
+                args: [
+                    { type: 'Hash160', value: account.address },
+                    { type: 'Hash160', value: intent.receiverAddress },
+                    {
+                        type: 'Integer',
+                        value: intent.tokenDecimals
+                            ? neon_js_1.u.BigInteger.fromDecimal(intent.amount, intent.tokenDecimals).toString()
+                            : intent.amount,
+                    },
+                    { type: 'Any', value: '' },
+                ],
+            };
+        });
+        return invocations;
     }
 }
 exports.BSNeo3 = BSNeo3;

package/dist/DoraBDSNeo3.d.ts

@@ -0,0 +1,12 @@
+import { BalanceResponse, ContractResponse, TransactionsByAddressParams, TransactionsByAddressResponse, TransactionResponse, Network, Token } from '@cityofzion/blockchain-service';
+import { RPCBDSNeo3 } from './RpcBDSNeo3';
+export declare class DoraBDSNeo3 extends RPCBDSNeo3 {
+    readonly network: Network;
+    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[]>;
+    private convertByteStringToAddress;
+}

package/dist/DoraBDSNeo3.js

@@ -0,0 +1,169 @@
+"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.DoraBDSNeo3 = void 0;
+const neon_js_1 = require("@cityofzion/neon-js");
+const api_1 = require("@cityofzion/dora-ts/dist/api");
+const RpcBDSNeo3_1 = require("./RpcBDSNeo3");
+const constants_1 = require("./constants");
+const NeoRest = new api_1.NeoRESTApi({
+    doraUrl: 'https://dora.coz.io',
+    endpoint: '/api/v2/neo3',
+});
+class DoraBDSNeo3 extends RpcBDSNeo3_1.RPCBDSNeo3 {
+    constructor(network, feeToken, claimToken) {
+        if (network.type === 'custom') {
+            throw new Error('DoraBDSNeo3 does not support custom networks');
+        }
+        super(network, feeToken, claimToken);
+        this.network = network;
+    }
+    getTransaction(hash) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield NeoRest.transaction(hash, this.network.type);
+                return {
+                    block: data.block,
+                    time: Number(data.time),
+                    hash: data.hash,
+                    fee: neon_js_1.u.BigInteger.fromNumber((_a = data.netfee) !== null && _a !== void 0 ? _a : 0)
+                        .add(neon_js_1.u.BigInteger.fromNumber((_b = data.sysfee) !== null && _b !== void 0 ? _b : 0))
+                        .toDecimal(this.feeToken.decimals),
+                    notifications: [],
+                    transfers: [],
+                };
+            }
+            catch (_c) {
+                throw new Error(`Transaction not found: ${hash}`);
+            }
+        });
+    }
+    getTransactionsByAddress({ address, page = 1, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield NeoRest.addressTXFull(address, page, this.network.type);
+            const transactions = yield Promise.all(data.items.map((item) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const filteredTransfers = item.notifications.filter(item => item.event_name === 'Transfer' && (item.state.value.length === 3 || item.state.value.length === 4));
+                const transferPromises = filteredTransfers.map(({ contract: contractHash, state: { value: properties } }) => __awaiter(this, void 0, void 0, function* () {
+                    var _c;
+                    const isAsset = properties.length === 3;
+                    const from = properties[0].value;
+                    const to = properties[1].value;
+                    const convertedFrom = from ? this.convertByteStringToAddress(from) : 'Mint';
+                    const convertedTo = to ? this.convertByteStringToAddress(to) : 'Burn';
+                    if (isAsset) {
+                        const token = yield this.getTokenInfo(contractHash);
+                        const [, , { value: amount }] = properties;
+                        return {
+                            amount: neon_js_1.u.BigInteger.fromNumber(amount).toDecimal((_c = token.decimals) !== null && _c !== void 0 ? _c : 0),
+                            from: convertedFrom,
+                            to: convertedTo,
+                            contractHash,
+                            type: 'token',
+                            token,
+                        };
+                    }
+                    return {
+                        from: convertedFrom,
+                        to: convertedTo,
+                        tokenId: properties[3].value,
+                        contractHash,
+                        type: 'nft',
+                    };
+                }));
+                const transfers = yield Promise.all(transferPromises);
+                const notifications = item.notifications.map(notification => ({
+                    eventName: notification.event_name,
+                    state: notification.state,
+                }));
+                return {
+                    block: item.block,
+                    time: Number(item.time),
+                    hash: item.hash,
+                    fee: neon_js_1.u.BigInteger.fromNumber((_a = item.netfee) !== null && _a !== void 0 ? _a : 0)
+                        .add(neon_js_1.u.BigInteger.fromNumber((_b = item.sysfee) !== null && _b !== void 0 ? _b : 0))
+                        .toDecimal(this.feeToken.decimals),
+                    transfers,
+                    notifications,
+                };
+            })));
+            return {
+                totalCount: data.totalCount,
+                transactions,
+                limit: 15,
+            };
+        });
+    }
+    getContract(contractHash) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield NeoRest.contract(contractHash, this.network.type);
+                return {
+                    hash: data.hash,
+                    methods: (_b = (_a = data.manifest.abi) === null || _a === void 0 ? void 0 : _a.methods) !== null && _b !== void 0 ? _b : [],
+                    name: data.manifest.name,
+                };
+            }
+            catch (_c) {
+                throw new Error(`Contract not found: ${contractHash}`);
+            }
+        });
+    }
+    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);
+            }
+            try {
+                const { decimals, symbol, name, scripthash } = yield NeoRest.asset(tokenHash, this.network.type);
+                const token = {
+                    decimals: Number(decimals),
+                    symbol,
+                    name,
+                    hash: scripthash,
+                };
+                this.tokenCache.set(tokenHash, token);
+                return token;
+            }
+            catch (_a) {
+                throw new Error(`Token not found: ${tokenHash}`);
+            }
+        });
+    }
+    getBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield NeoRest.balance(address, this.network.type);
+            const promises = response.map((balance) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const token = yield this.getTokenInfo(balance.asset);
+                    return {
+                        amount: neon_js_1.u.BigInteger.fromNumber(balance.balance).toDecimal(token.decimals),
+                        token,
+                    };
+                }
+                catch (_a) { }
+            }));
+            const balances = yield Promise.all(promises);
+            const filteredBalances = balances.filter(balance => balance !== undefined);
+            return filteredBalances;
+        });
+    }
+    convertByteStringToAddress(byteString) {
+        const account = new neon_js_1.wallet.Account(neon_js_1.u.reverseHex(neon_js_1.u.HexString.fromBase64(byteString).toString()));
+        return account.address;
+    }
+}
+exports.DoraBDSNeo3 = DoraBDSNeo3;

package/dist/FlamingoEDSNeo3.d.ts

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

package/dist/FlamingoEDSNeo3.js

@@ -0,0 +1,44 @@
+"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.FlamingoEDSNeo3 = void 0;
+const axios_1 = __importDefault(require("axios"));
+class FlamingoEDSNeo3 {
+    constructor(networkType) {
+        this.networkType = networkType;
+        this.axiosInstance = axios_1.default.create({ baseURL: 'https://api.flamingo.finance' });
+    }
+    getTokenPrices(currency) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.networkType !== 'mainnet')
+                throw new Error('Exchange is only available on mainnet');
+            const { data: prices } = yield this.axiosInstance.get('/token-info/prices');
+            let currencyRatio = 1;
+            if (currency !== 'USD') {
+                currencyRatio = yield this.getCurrencyRatio(currency);
+            }
+            return prices.map(price => ({
+                price: price.usd_price * currencyRatio,
+                symbol: price.symbol,
+            }));
+        });
+    }
+    getCurrencyRatio(currency) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axiosInstance.get(`/fiat/exchange-rate?pair=USD_${currency}`);
+            return data;
+        });
+    }
+}
+exports.FlamingoEDSNeo3 = FlamingoEDSNeo3;

package/dist/GhostMarketNDSNeo3.d.ts

@@ -0,0 +1,10 @@
+import { NftResponse, NftsResponse, NetworkType, NftDataService, GetNftParam, GetNftsByAddressParams } from '@cityofzion/blockchain-service';
+export declare class GhostMarketNDSNeo3 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/GhostMarketNDSNeo3.js

@@ -0,0 +1,75 @@
+"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.GhostMarketNDSNeo3 = void 0;
+const query_string_1 = __importDefault(require("query-string"));
+const axios_1 = __importDefault(require("axios"));
+const constants_1 = require("./constants");
+class GhostMarketNDSNeo3 {
+    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 { data } = yield axios_1.default.get(url);
+            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 { data } = yield axios_1.default.get(url);
+            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.GhostMarketNDSNeo3 = GhostMarketNDSNeo3;

package/dist/RpcBDSNeo3.d.ts

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

package/dist/RpcBDSNeo3.js

@@ -0,0 +1,152 @@
+"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.RPCBDSNeo3 = void 0;
+const neon_core_1 = require("@cityofzion/neon-core");
+const neon_invoker_1 = require("@cityofzion/neon-invoker");
+const constants_1 = require("./constants");
+class RPCBDSNeo3 {
+    constructor(network, feeToken, claimToken) {
+        this.tokenCache = new Map();
+        this.network = network;
+        this.feeToken = feeToken;
+        this.claimToken = claimToken;
+    }
+    getTransaction(hash) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const rpcClient = new neon_core_1.rpc.RPCClient(this.network.url);
+                const response = yield rpcClient.getRawTransaction(hash, true);
+                return {
+                    hash: response.hash,
+                    block: response.validuntilblock,
+                    fee: neon_core_1.u.BigInteger.fromNumber((_a = response.netfee) !== null && _a !== void 0 ? _a : 0)
+                        .add(neon_core_1.u.BigInteger.fromNumber((_b = response.sysfee) !== null && _b !== void 0 ? _b : 0))
+                        .toDecimal(this.feeToken.decimals),
+                    notifications: [],
+                    transfers: [],
+                    time: response.blocktime,
+                };
+            }
+            catch (_c) {
+                throw new Error(`Transaction not found: ${hash}`);
+            }
+        });
+    }
+    getTransactionsByAddress(_params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Method not supported.');
+        });
+    }
+    getContract(contractHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const rpcClient = new neon_core_1.rpc.RPCClient(this.network.url);
+                const contractState = yield rpcClient.getContractState(contractHash);
+                const methods = contractState.manifest.abi.methods.map(method => ({
+                    name: method.name,
+                    parameters: method.parameters.map(parameter => ({
+                        name: parameter.name,
+                        type: parameter.type,
+                    })),
+                }));
+                return {
+                    hash: contractState.hash,
+                    name: contractState.manifest.name,
+                    methods,
+                };
+            }
+            catch (_a) {
+                throw new Error(`Contract not found: ${contractHash}`);
+            }
+        });
+    }
+    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);
+            }
+            try {
+                const rpcClient = new neon_core_1.rpc.RPCClient(this.network.url);
+                const contractState = yield rpcClient.getContractState(tokenHash);
+                const invoker = yield neon_invoker_1.NeonInvoker.init({
+                    rpcAddress: this.network.url,
+                });
+                const response = yield invoker.testInvoke({
+                    invocations: [
+                        {
+                            scriptHash: tokenHash,
+                            operation: 'decimals',
+                            args: [],
+                        },
+                        { scriptHash: tokenHash, operation: 'symbol', args: [] },
+                    ],
+                });
+                const decimals = Number(response.stack[0].value);
+                const symbol = neon_core_1.u.base642utf8(response.stack[1].value);
+                const token = {
+                    name: contractState.manifest.name,
+                    symbol,
+                    hash: contractState.hash,
+                    decimals,
+                };
+                this.tokenCache.set(tokenHash, token);
+                return token;
+            }
+            catch (_a) {
+                throw new Error(`Token not found: ${tokenHash}`);
+            }
+        });
+    }
+    getBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rpcClient = new neon_core_1.rpc.RPCClient(this.network.url);
+            const response = yield rpcClient.getNep17Balances(address);
+            const promises = response.balance.map((balance) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                let token = {
+                    hash: balance.assethash,
+                    name: '-',
+                    symbol: '-',
+                    decimals: 8,
+                };
+                try {
+                    token = yield this.getTokenInfo(balance.assethash);
+                }
+                catch (_b) { }
+                return {
+                    amount: neon_core_1.u.BigInteger.fromNumber(balance.amount).toDecimal((_a = token === null || token === void 0 ? void 0 : token.decimals) !== null && _a !== void 0 ? _a : 8),
+                    token,
+                };
+            }));
+            const balances = yield Promise.all(promises);
+            return balances;
+        });
+    }
+    getBlockHeight() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rpcClient = new neon_core_1.rpc.RPCClient(this.network.url);
+            return yield rpcClient.getBlockCount();
+        });
+    }
+    getUnclaimed(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rpcClient = new neon_core_1.rpc.RPCClient(this.network.url);
+            const response = yield rpcClient.getUnclaimedGas(address);
+            return neon_core_1.u.BigInteger.fromNumber(response).toDecimal(this.claimToken.decimals);
+        });
+    }
+}
+exports.RPCBDSNeo3 = RPCBDSNeo3;

package/dist/assets/tokens/common.json

@@ -0,0 +1,14 @@
+[
+    {
+        "symbol": "GAS",
+        "name": "GASToken",
+        "hash": "d2a4cff31913016155e38e474a2c06d08be276cf",
+        "decimals": 8
+    },
+    {
+        "symbol": "NEO",
+        "name": "NeoToken",
+        "hash": "ef4073a0f2b305a38ec4050e4d3d28bc40ea63f5",
+        "decimals": 0
+    }
+]

package/dist/assets/tokens/mainnet.json

@@ -0,0 +1,116 @@
+[
+    {
+        "symbol": "LRB",
+        "name": "LyrebirdToken",
+        "hash": "0x8c07b4c9f5bc170a3922eac4f5bb7ef17b0acc8b",
+        "decimals": 8
+    },
+    {
+        "symbol": "USDL",
+        "name": "LyrebirdUSDToken",
+        "hash": "0xa8c51aa0c177187aeed3db88bdfa908ccbc9b1a5",
+        "decimals": 8
+    },
+    {
+        "symbol": "FLM",
+        "name": "FLM",
+        "hash": "0xf0151f528127558851b39c2cd8aa47da7418ab28",
+        "decimals": 8
+    },
+    {
+        "symbol": "fCAKE",
+        "name": "fCAKE",
+        "hash": "0xe65b462b90516012826f8a9c4c285d8c750e3a77",
+        "decimals": 18
+    },
+    {
+        "symbol": "WING",
+        "name": "WING",
+        "hash": "0xeeccd60ed722111f8400434dac3ba42c14d8beb1",
+        "decimals": 9
+    },
+    {
+        "symbol": "fWETH",
+        "name": "fWETH",
+        "hash": "0xc14b601252aa5dfa6166cf35fe5ccd2e35f3fdf5",
+        "decimals": 18
+    },
+    {
+        "symbol": "fWBTC",
+        "name": "fWBTC",
+        "hash": "0xd6abe115ecb75e1fa0b42f5e85934ce8c1ae2893",
+        "decimals": 8
+    },
+    {
+        "symbol": "SWTH",
+        "name": "SWTHToken",
+        "hash": "0x78e1330db47634afdb5ea455302ba2d12b8d549f",
+        "decimals": 8
+    },
+    {
+        "symbol": "pONT",
+        "name": "pONT",
+        "hash": "0x8122bc2212ec971690a044b37a6f52a9349b702b",
+        "decimals": 9
+    },
+    {
+        "symbol": "fUSDT",
+        "name": "fUSDT",
+        "hash": "0xcd48b160c1bbc9d74997b803b9a7ad50a4bef020",
+        "decimals": 6
+    },
+    {
+        "symbol": "FLUND",
+        "name": "FLUND",
+        "hash": "0xa9603a59e21d29e37ac39cf1b5f5abf5006b22a3",
+        "decimals": 8
+    },
+    {
+        "symbol": "GM",
+        "name": "GhostMarketToken",
+        "hash": "0x9b049f1283515eef1d3f6ac610e1595ed25ca3e9",
+        "decimals": 8
+    },
+    {
+        "symbol": "NUDES",
+        "name": "Nudes",
+        "hash": "0x340720c7107ef5721e44ed2ea8e314cce5c130fa",
+        "decimals": 8
+    },
+    {
+        "symbol": "CANDY",
+        "name": "NeoCandy",
+        "hash": "0x88da18a5bca86ec8206d9b4960a7d0c4355a432f",
+        "decimals": 9
+    },
+    {
+        "symbol": "DOGER",
+        "name": "DogeRift",
+        "hash": "0x322b5a366ca724801a1aa01e669b5f3d7f8c7f6f",
+        "decimals": 8
+    },
+    {
+        "symbol": "DOGEF",
+        "name": "DogeFood",
+        "hash": "0xa3291b66f70d4687fc0e41977d8acb0699f235ae",
+        "decimals": 8
+    },
+    {
+        "symbol": "SOM",
+        "name": "Som",
+        "hash": "0x2d4c6cf0417209a7eb410160344e224e74f87195",
+        "decimals": 8
+    },
+    {
+        "symbol": "LAMBO",
+        "name": "BoomerFund",
+        "hash": "0xafdd6abedf066ff8c5fbc868cc89f80eac467142",
+        "decimals": 8
+    },
+    {
+        "symbol": "bNEO",
+        "hash": "0x48c40d4666f93408be1bef038b6722404d9a4c2a",
+        "decimals": 8,
+        "name": "BurgerNEO"
+    }
+]

package/dist/constants.d.ts

@@ -1,10 +1,7 @@
-export declare const gasInfoNeo3: {
-    hash: string;
-    symbol: string;
-    decimals: number;
-};
-export declare const neoInfoNeo3: {
-    hash: string;
-    symbol: string;
-    decimals: number;
-};
+import { NetworkType, Token } from '@cityofzion/blockchain-service';
+export declare const TOKENS: Record<NetworkType, Token[]>;
+export declare const NEO_NS_HASH = "0x50ac1c37690cc2cfc594472833cf57505d5f46de";
+export declare const DEFAULT_URL_BY_NETWORK_TYPE: Record<NetworkType, string>;
+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'/888'/0'/0/?";

package/dist/constants.js

@@ -1,13 +1,28 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.neoInfoNeo3 = exports.gasInfoNeo3 = void 0;
-exports.gasInfoNeo3 = {
-    hash: '0xd2a4cff31913016155e38e474a2c06d08be276cf',
-    symbol: 'GAS',
-    decimals: 8
+exports.DERIVATION_PATH = exports.GHOSTMARKET_CHAIN_BY_NETWORK_TYPE = exports.GHOSTMARKET_URL_BY_NETWORK_TYPE = exports.DEFAULT_URL_BY_NETWORK_TYPE = exports.NEO_NS_HASH = exports.TOKENS = void 0;
+const common_json_1 = __importDefault(require("./assets/tokens/common.json"));
+const mainnet_json_1 = __importDefault(require("./assets/tokens/mainnet.json"));
+exports.TOKENS = {
+    mainnet: [...common_json_1.default, ...mainnet_json_1.default],
+    testnet: common_json_1.default,
+    custom: common_json_1.default,
+};
+exports.NEO_NS_HASH = '0x50ac1c37690cc2cfc594472833cf57505d5f46de';
+exports.DEFAULT_URL_BY_NETWORK_TYPE = {
+    mainnet: 'https://mainnet1.neo.coz.io:443',
+    testnet: 'https://testnet1.neo.coz.io:443',
+    custom: 'http://127.0.0.1:50012',
+};
+exports.GHOSTMARKET_URL_BY_NETWORK_TYPE = {
+    mainnet: 'https://api.ghostmarket.io/api/v2',
+    testnet: 'https://api-testnet.ghostmarket.io/api/v2',
 };
-exports.neoInfoNeo3 = {
-    hash: '0xef4073a0f2b305a38ec4050e4d3d28bc40ea63f5',
-    symbol: 'NEO',
-    decimals: 0
+exports.GHOSTMARKET_CHAIN_BY_NETWORK_TYPE = {
+    mainnet: 'n3',
+    testnet: 'n3t',
 };
+exports.DERIVATION_PATH = "m/44'/888'/0'/0/?";

package/dist/index.d.ts

@@ -1,4 +1,6 @@
-export * from './BDSNeo3';
+export * from './DoraBDSNeo3';
+export * from './RpcBDSNeo3';
 export * from './BSNeo3';
 export * from './constants';
-export * from './explorer';
+export * from './FlamingoEDSNeo3';
+export * from './GhostMarketNDSNeo3';

package/dist/index.js

@@ -14,7 +14,9 @@ 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("./BDSNeo3"), exports);
+__exportStar(require("./DoraBDSNeo3"), exports);
+__exportStar(require("./RpcBDSNeo3"), exports);
 __exportStar(require("./BSNeo3"), exports);
 __exportStar(require("./constants"), exports);
-__exportStar(require("./explorer"), exports);
+__exportStar(require("./FlamingoEDSNeo3"), exports);
+__exportStar(require("./GhostMarketNDSNeo3"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-neo3",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",
@@ -17,8 +17,8 @@
     "@cityofzion/neo3-invoker": "1.6.0",
     "@cityofzion/neon-parser": "1.6.2",
     "@cityofzion/neo3-parser": "1.6.0",
-    "@cityofzion/blockchain-service": "0.7.0",
-    "@cityofzion/bs-asteroid-sdk": "0.7.0",
+    "@cityofzion/blockchain-service": "0.7.2",
+    "@cityofzion/bs-asteroid-sdk": "0.7.2",
     "@cityofzion/dora-ts": "0.0.11",
     "query-string": "7.1.3"
   },