@cityofzion/bs-neo3 0.4.2 → 0.7.1

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,3 +1,7 @@
-import { TokenInfo } from '@cityofzion/blockchain-service';
-export declare const gasInfoNeo3: TokenInfo;
-export declare const neoInfoNeo3: TokenInfo;
+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';