@cityofzion/bs-neox 0.0.1 → 1.1.0

package/dist/BSNeoX.d.ts

@@ -0,0 +1,7 @@
+import { BSEthereum } from '@cityofzion/bs-ethereum';
+import { BSNeoXNetworkId } from './constants/BSNeoXConstants';
+import { GetLedgerTransport, Network } from '@cityofzion/blockchain-service';
+export declare class BSNeoX<BSName extends string = string> extends BSEthereum<BSName, BSNeoXNetworkId> {
+    constructor(name: BSName, network?: Network<BSNeoXNetworkId>, getLedgerTransport?: GetLedgerTransport<BSName>);
+    setNetwork(network: Network<BSNeoXNetworkId>): void;
+}

package/dist/BSNeoX.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSNeoX = void 0;
+const bs_ethereum_1 = require("@cityofzion/bs-ethereum");
+const BSNeoXConstants_1 = require("./constants/BSNeoXConstants");
+const BlockscoutBDSNeoX_1 = require("./services/blockchain-data/BlockscoutBDSNeoX");
+const FlamingoForthewinEDSNeoX_1 = require("./services/exchange-data/FlamingoForthewinEDSNeoX");
+const BlockscoutESNeoX_1 = require("./services/explorer/BlockscoutESNeoX");
+const GhostMarketNDSNeoX_1 = require("./services/nft-data/GhostMarketNDSNeoX");
+class BSNeoX extends bs_ethereum_1.BSEthereum {
+    constructor(name, network, getLedgerTransport) {
+        network = network !== null && network !== void 0 ? network : BSNeoXConstants_1.BSNeoXConstants.DEFAULT_NETWORK;
+        super(name, network, getLedgerTransport);
+        this.tokens = [BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET];
+        this.nativeTokens = [BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET];
+        this.feeToken = BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET;
+    }
+    setNetwork(network) {
+        this.network = network;
+        this.nftDataService = new GhostMarketNDSNeoX_1.GhostMarketNDSNeoX(network);
+        this.explorerService = new BlockscoutESNeoX_1.BlockscoutESNeoX(network);
+        this.exchangeDataService = new FlamingoForthewinEDSNeoX_1.FlamingoForthewinEDSNeoX(network);
+        this.blockchainDataService = new BlockscoutBDSNeoX_1.BlockscoutBDSNeoX(network, this.nftDataService, this.explorerService);
+    }
+}
+exports.BSNeoX = BSNeoX;

package/dist/constants/BSNeoXConstants.d.ts

@@ -0,0 +1,13 @@
+import { Network, NetworkId, Token } from '@cityofzion/blockchain-service';
+export type BSNeoXNetworkId = NetworkId<'47763' | '12227332'>;
+export declare class BSNeoXConstants {
+    static NATIVE_ASSET: Token;
+    static RPC_LIST_BY_NETWORK_ID: Record<BSNeoXNetworkId, string[]>;
+    static MAINNET_NETWORK_IDS: BSNeoXNetworkId[];
+    static TESTNET_NETWORK_IDS: BSNeoXNetworkId[];
+    static ALL_NETWORK_IDS: BSNeoXNetworkId[];
+    static MAINNET_NETWORK: Network<BSNeoXNetworkId>;
+    static TESTNET_NETWORK: Network<BSNeoXNetworkId>;
+    static ALL_NETWORK: Network<BSNeoXNetworkId>[];
+    static DEFAULT_NETWORK: Network<BSNeoXNetworkId>;
+}

package/dist/constants/BSNeoXConstants.js

@@ -0,0 +1,28 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSNeoXConstants = void 0;
+class BSNeoXConstants {
+}
+exports.BSNeoXConstants = BSNeoXConstants;
+_a = BSNeoXConstants;
+BSNeoXConstants.NATIVE_ASSET = { symbol: 'GAS', name: 'GAS', decimals: 18, hash: '-' };
+BSNeoXConstants.RPC_LIST_BY_NETWORK_ID = {
+    '47763': ['https://mainnet-1.rpc.banelabs.org'],
+    '12227332': ['https://neoxt4seed1.ngd.network'],
+};
+BSNeoXConstants.MAINNET_NETWORK_IDS = ['47763'];
+BSNeoXConstants.TESTNET_NETWORK_IDS = ['12227332'];
+BSNeoXConstants.ALL_NETWORK_IDS = [..._a.MAINNET_NETWORK_IDS, ..._a.TESTNET_NETWORK_IDS];
+BSNeoXConstants.MAINNET_NETWORK = {
+    id: '47763',
+    name: 'NeoX Testnet',
+    url: _a.RPC_LIST_BY_NETWORK_ID['47763'][0],
+};
+BSNeoXConstants.TESTNET_NETWORK = {
+    id: '12227332',
+    name: 'NeoX Mainnet',
+    url: _a.RPC_LIST_BY_NETWORK_ID['12227332'][0],
+};
+BSNeoXConstants.ALL_NETWORK = [_a.TESTNET_NETWORK, _a.MAINNET_NETWORK];
+BSNeoXConstants.DEFAULT_NETWORK = _a.MAINNET_NETWORK;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './BSNeoX';
+export * from './constants/BSNeoXConstants';
+export * from './services/blockchain-data/BlockscoutBDSNeoX';
+export * from './services/exchange-data/FlamingoForthewinEDSNeoX';
+export * from './services/explorer/BlockscoutESNeoX';
+export * from './services/nft-data/GhostMarketNDSNeoX';

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./BSNeoX"), exports);
+__exportStar(require("./constants/BSNeoXConstants"), exports);
+__exportStar(require("./services/blockchain-data/BlockscoutBDSNeoX"), exports);
+__exportStar(require("./services/exchange-data/FlamingoForthewinEDSNeoX"), exports);
+__exportStar(require("./services/explorer/BlockscoutESNeoX"), exports);
+__exportStar(require("./services/nft-data/GhostMarketNDSNeoX"), exports);

package/dist/services/blockchain-data/BlockscoutBDSNeoX.d.ts

@@ -0,0 +1,17 @@
+import { BalanceResponse, ContractResponse, ExplorerService, ExportTransactionsByAddressParams, FullTransactionsByAddressParams, FullTransactionsByAddressResponse, Network, NftDataService, Token, TransactionResponse, TransactionsByAddressParams, TransactionsByAddressResponse } from '@cityofzion/blockchain-service';
+import { DoraBDSEthereum } from '@cityofzion/bs-ethereum';
+import { BSNeoXNetworkId } from '../../constants/BSNeoXConstants';
+export declare class BlockscoutBDSNeoX extends DoraBDSEthereum<BSNeoXNetworkId> {
+    static BASE_URL_BY_CHAIN_ID: Partial<Record<BSNeoXNetworkId, string>>;
+    static getClient(network: Network<BSNeoXNetworkId>): import("axios").AxiosInstance;
+    constructor(network: Network<BSNeoXNetworkId>, nftDataService: NftDataService, explorerService: ExplorerService);
+    maxTimeToConfirmTransactionInMs: number;
+    getTransaction(txid: string): Promise<TransactionResponse>;
+    getTransactionsByAddress(params: TransactionsByAddressParams): Promise<TransactionsByAddressResponse>;
+    getFullTransactionsByAddress({ nextCursor, ...params }: FullTransactionsByAddressParams): Promise<FullTransactionsByAddressResponse>;
+    exportFullTransactionsByAddress(params: ExportTransactionsByAddressParams): Promise<string>;
+    getContract(contractHash: string): Promise<ContractResponse>;
+    getTokenInfo(tokenHash: string): Promise<Token>;
+    getBalance(address: string): Promise<BalanceResponse[]>;
+    getBlockHeight(): Promise<number>;
+}

package/dist/services/blockchain-data/BlockscoutBDSNeoX.js

@@ -0,0 +1,314 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockscoutBDSNeoX = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
+const axios_1 = __importDefault(require("axios"));
+const ethers_1 = require("ethers");
+const dora_ts_1 = require("@cityofzion/dora-ts");
+const bs_ethereum_1 = require("@cityofzion/bs-ethereum");
+const BSNeoXConstants_1 = require("../../constants/BSNeoXConstants");
+class BlockscoutBDSNeoX extends bs_ethereum_1.DoraBDSEthereum {
+    static getClient(network) {
+        const baseURL = BlockscoutBDSNeoX.BASE_URL_BY_CHAIN_ID[network.id];
+        if (!baseURL) {
+            throw new Error('Unsupported network');
+        }
+        return axios_1.default.create({
+            baseURL,
+        });
+    }
+    constructor(network, nftDataService, explorerService) {
+        super(network, BSNeoXConstants_1.BSNeoXConstants.ALL_NETWORK_IDS, nftDataService, explorerService);
+        this.maxTimeToConfirmTransactionInMs = 1000 * 60 * 5;
+    }
+    getTransaction(txid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = BlockscoutBDSNeoX.getClient(this._network);
+            const { data } = yield client.get(`/transactions/${txid}`);
+            if (!data || 'message' in data) {
+                throw new Error('Transaction not found');
+            }
+            const nativeToken = BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET;
+            const transfers = [];
+            const hasNativeTokenBeingTransferred = data.value !== '0';
+            if (hasNativeTokenBeingTransferred) {
+                transfers.push({
+                    amount: ethers_1.ethers.utils.formatUnits(data.value, nativeToken.decimals),
+                    from: data.from.hash,
+                    to: data.to.hash,
+                    type: 'token',
+                    contractHash: nativeToken.hash,
+                    token: nativeToken,
+                });
+            }
+            const hasTokenTransfers = data.token_transfers && data.token_transfers.length > 0;
+            if (hasTokenTransfers) {
+                for (const tokenTransfer of data.token_transfers) {
+                    if (tokenTransfer.token.type === 'ERC-20') {
+                        transfers.push({
+                            amount: ethers_1.ethers.utils.formatUnits(tokenTransfer.total.value, tokenTransfer.total.decimals),
+                            from: tokenTransfer.from.hash,
+                            to: tokenTransfer.to.hash,
+                            type: 'token',
+                            contractHash: tokenTransfer.token.address,
+                            token: {
+                                symbol: tokenTransfer.token.symbol,
+                                name: tokenTransfer.token.name,
+                                hash: tokenTransfer.token.address,
+                                decimals: Number(tokenTransfer.total.decimals),
+                            },
+                        });
+                        continue;
+                    }
+                    if (tokenTransfer.token.type === 'ERC-721') {
+                        transfers.push({
+                            tokenId: tokenTransfer.total.token_id,
+                            from: tokenTransfer.from.hash,
+                            to: tokenTransfer.to.hash,
+                            type: 'nft',
+                            contractHash: tokenTransfer.token.address,
+                        });
+                    }
+                }
+            }
+            return {
+                block: data.block,
+                hash: data.hash,
+                fee: ethers_1.ethers.utils.formatUnits(data.fee.value, nativeToken.decimals),
+                time: new Date(data.timestamp).getTime() / 1000,
+                notifications: [],
+                transfers,
+            };
+        });
+    }
+    getTransactionsByAddress(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = BlockscoutBDSNeoX.getClient(this._network);
+            const { data } = yield client.get(`/addresses/${params.address}/transactions`, {
+                params: {
+                    next_page_params: params.nextPageParams,
+                },
+            });
+            if (!data || 'message' in data) {
+                throw new Error('Transactions not found');
+            }
+            const nativeToken = BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET;
+            const transactions = [];
+            const promises = data.items.map((item) => __awaiter(this, void 0, void 0, function* () {
+                const transfers = [];
+                const hasNativeTokenBeingTransferred = item.value !== '0';
+                if (hasNativeTokenBeingTransferred) {
+                    transfers.push({
+                        amount: ethers_1.ethers.utils.formatUnits(item.value, nativeToken.decimals),
+                        from: item.from.hash,
+                        to: item.to.hash,
+                        type: 'token',
+                        contractHash: nativeToken.hash,
+                        token: nativeToken,
+                    });
+                }
+                if (item.raw_input) {
+                    try {
+                        const ERC20Interface = new ethers_1.ethers.utils.Interface(bs_ethereum_1.ERC20_ABI);
+                        const result = ERC20Interface.decodeFunctionData('transfer', item.raw_input);
+                        if (!result)
+                            throw new Error('Invalid ERC20 transfer');
+                        const contractHash = item.to.hash;
+                        const token = yield this.getTokenInfo(contractHash);
+                        const to = result[0];
+                        const value = result[1];
+                        transfers.push({
+                            amount: ethers_1.ethers.utils.formatUnits(value, token.decimals),
+                            from: item.from.hash,
+                            to,
+                            type: 'token',
+                            contractHash: item.to.hash,
+                            token,
+                        });
+                    }
+                    catch (error) {
+                        /* empty */
+                    }
+                }
+                transactions.push({
+                    block: item.block,
+                    hash: item.hash,
+                    fee: ethers_1.ethers.utils.formatUnits(item.fee.value, nativeToken.decimals),
+                    time: new Date(item.timestamp).getTime() / 1000,
+                    notifications: [],
+                    transfers,
+                });
+            }));
+            yield Promise.allSettled(promises);
+            return {
+                transactions,
+                nextPageParams: data.next_page_params,
+            };
+        });
+    }
+    getFullTransactionsByAddress(_a) {
+        var _b;
+        var { nextCursor } = _a, params = __rest(_a, ["nextCursor"]);
+        return __awaiter(this, void 0, void 0, function* () {
+            this._validateGetFullTransactionsByAddressParams(params);
+            const response = yield dora_ts_1.api.NeoXREST.getFullTransactionsByAddress({
+                address: params.address,
+                timestampFrom: params.dateFrom,
+                timestampTo: params.dateTo,
+                network: BSNeoXConstants_1.BSNeoXConstants.TESTNET_NETWORK_IDS.includes(this._network.id) ? 'testnet' : 'mainnet',
+                cursor: nextCursor,
+                pageLimit: (_b = params.pageSize) !== null && _b !== void 0 ? _b : 50,
+            });
+            return yield this._transformFullTransactionsByAddressResponse(response);
+        });
+    }
+    exportFullTransactionsByAddress(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._validateFullTransactionsByAddressParams(params);
+            return yield dora_ts_1.api.NeoXREST.exportFullTransactionsByAddress({
+                address: params.address,
+                timestampFrom: params.dateFrom,
+                timestampTo: params.dateTo,
+                network: BSNeoXConstants_1.BSNeoXConstants.TESTNET_NETWORK_IDS.includes(this._network.id) ? 'testnet' : 'mainnet',
+            });
+        });
+    }
+    getContract(contractHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const client = BlockscoutBDSNeoX.getClient(this._network);
+                const { data } = yield client.get(`/smart-contracts/${contractHash}`);
+                if (!data || 'message' in data) {
+                    throw new Error('Contract not found');
+                }
+                const methods = [];
+                data.abi.forEach(abi => {
+                    var _a, _b;
+                    if (abi.type !== 'function')
+                        return;
+                    const parameters = (_a = abi.inputs) === null || _a === void 0 ? void 0 : _a.map(param => ({
+                        name: param.name,
+                        type: param.type,
+                    }));
+                    methods.push({
+                        name: (_b = abi.name) !== null && _b !== void 0 ? _b : '',
+                        parameters: parameters !== null && parameters !== void 0 ? parameters : [],
+                    });
+                });
+                return {
+                    hash: contractHash,
+                    name: data.name,
+                    methods,
+                };
+            }
+            catch (error) {
+                throw new Error('Contract not found or not supported');
+            }
+        });
+    }
+    getTokenInfo(tokenHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const normalizedHash = (0, blockchain_service_1.normalizeHash)(tokenHash);
+            const nativeAsset = BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET;
+            if (nativeAsset.hash === normalizedHash) {
+                return nativeAsset;
+            }
+            if (this._tokenCache.has(tokenHash)) {
+                return this._tokenCache.get(tokenHash);
+            }
+            const client = BlockscoutBDSNeoX.getClient(this._network);
+            const { data } = yield client.get(`/tokens/${tokenHash}`);
+            if (!data || 'message' in data) {
+                throw new Error('Token not found');
+            }
+            if (data.type !== 'ERC-20') {
+                throw new Error('Token is not an ERC-20 token');
+            }
+            return {
+                decimals: data.decimals ? parseInt(data.decimals) : bs_ethereum_1.BSEthereumConstants.DEFAULT_DECIMALS,
+                hash: tokenHash,
+                name: data.name,
+                symbol: data.symbol,
+            };
+        });
+    }
+    getBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = BlockscoutBDSNeoX.getClient(this._network);
+            const { data: nativeBalance } = yield client.get(`/addresses/${address}`);
+            if (!nativeBalance || 'message' in nativeBalance) {
+                throw new Error('Native balance not found');
+            }
+            const nativeToken = BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET;
+            const balances = [
+                {
+                    amount: ethers_1.ethers.utils.formatUnits(nativeBalance.coin_balance, nativeToken.decimals),
+                    token: nativeToken,
+                },
+            ];
+            const { data: erc20Balances } = yield client.get(`/addresses/${address}/token-balances`);
+            if (!erc20Balances || 'message' in erc20Balances) {
+                throw new Error('ERC20 balance not found');
+            }
+            erc20Balances.forEach(balance => {
+                try {
+                    if (balance.token.type !== 'ERC-20') {
+                        return;
+                    }
+                    const token = {
+                        decimals: balance.token.decimals ? parseInt(balance.token.decimals) : bs_ethereum_1.BSEthereumConstants.DEFAULT_DECIMALS,
+                        hash: (0, blockchain_service_1.normalizeHash)(balance.token.address),
+                        name: balance.token.symbol,
+                        symbol: balance.token.symbol,
+                    };
+                    balances.push({
+                        amount: ethers_1.ethers.utils.formatUnits(balance.value, token.decimals),
+                        token,
+                    });
+                }
+                catch (_a) {
+                    /* empty */
+                }
+            });
+            return balances;
+        });
+    }
+    getBlockHeight() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = BlockscoutBDSNeoX.getClient(this._network);
+            const { data } = yield client.get('/blocks');
+            if (!data || 'message' in data) {
+                throw new Error('Block not found');
+            }
+            return data.items[0].height;
+        });
+    }
+}
+exports.BlockscoutBDSNeoX = BlockscoutBDSNeoX;
+BlockscoutBDSNeoX.BASE_URL_BY_CHAIN_ID = {
+    '47763': `${blockchain_service_1.BSCommonConstants.DORA_URL}/api/neox/mainnet`,
+    '12227332': 'https://dora-stage.coz.io/api/neox/testnet',
+};

package/dist/services/exchange-data/FlamingoForthewinEDSNeoX.d.ts

@@ -0,0 +1,8 @@
+import { ExchangeDataService, FlamingoForthewinEDS, GetTokenPriceHistoryParams, GetTokenPricesParams, Network, TokenPricesResponse } from '@cityofzion/blockchain-service';
+import { BSNeoXNetworkId } from '../../constants/BSNeoXConstants';
+export declare class FlamingoForthewinEDSNeoX extends FlamingoForthewinEDS implements ExchangeDataService {
+    #private;
+    constructor(network: Network<BSNeoXNetworkId>);
+    getTokenPrices({ tokens }: GetTokenPricesParams): Promise<TokenPricesResponse[]>;
+    getTokenPriceHistory(params: GetTokenPriceHistoryParams): Promise<import("@cityofzion/blockchain-service").TokenPricesHistoryResponse[]>;
+}

package/dist/services/exchange-data/FlamingoForthewinEDSNeoX.js

@@ -0,0 +1,68 @@
+"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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _FlamingoForthewinEDSNeoX_instances, _FlamingoForthewinEDSNeoX_network, _FlamingoForthewinEDSNeoX_validate;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlamingoForthewinEDSNeoX = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
+const BSNeoXConstants_1 = require("../../constants/BSNeoXConstants");
+class FlamingoForthewinEDSNeoX extends blockchain_service_1.FlamingoForthewinEDS {
+    constructor(network) {
+        super();
+        _FlamingoForthewinEDSNeoX_instances.add(this);
+        _FlamingoForthewinEDSNeoX_network.set(this, void 0);
+        __classPrivateFieldSet(this, _FlamingoForthewinEDSNeoX_network, network, "f");
+    }
+    getTokenPrices({ tokens }) {
+        const _super = Object.create(null, {
+            getTokenPrices: { get: () => super.getTokenPrices }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldGet(this, _FlamingoForthewinEDSNeoX_instances, "m", _FlamingoForthewinEDSNeoX_validate).call(this);
+            const gasToken = tokens.find(({ symbol }) => symbol === 'GAS');
+            const neoToken = tokens.find(({ symbol }) => symbol === 'NEO');
+            if (!gasToken && !neoToken)
+                return [];
+            return yield _super.getTokenPrices.call(this, {
+                tokens: tokens.filter(({ symbol }) => symbol === 'GAS' || symbol === 'NEO'),
+            });
+        });
+    }
+    getTokenPriceHistory(params) {
+        const _super = Object.create(null, {
+            getTokenPriceHistory: { get: () => super.getTokenPriceHistory }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldGet(this, _FlamingoForthewinEDSNeoX_instances, "m", _FlamingoForthewinEDSNeoX_validate).call(this);
+            const { symbol } = params.token;
+            if (symbol !== 'GAS' && symbol !== 'NEO')
+                throw new Error('Invalid token, it should be GAS or NEO');
+            return yield _super.getTokenPriceHistory.call(this, params);
+        });
+    }
+}
+exports.FlamingoForthewinEDSNeoX = FlamingoForthewinEDSNeoX;
+_FlamingoForthewinEDSNeoX_network = new WeakMap(), _FlamingoForthewinEDSNeoX_instances = new WeakSet(), _FlamingoForthewinEDSNeoX_validate = function _FlamingoForthewinEDSNeoX_validate() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!BSNeoXConstants_1.BSNeoXConstants.MAINNET_NETWORK_IDS.includes(__classPrivateFieldGet(this, _FlamingoForthewinEDSNeoX_network, "f").id))
+            throw new Error('Exchange is only available on Neo X Mainnet');
+    });
+};

package/dist/services/explorer/BlockscoutESNeoX.d.ts

@@ -0,0 +1,6 @@
+import { Network } from '@cityofzion/blockchain-service';
+import { BlockscoutESEthereum } from '@cityofzion/bs-ethereum';
+import { BSNeoXNetworkId } from '../../constants/BSNeoXConstants';
+export declare class BlockscoutESNeoX extends BlockscoutESEthereum<BSNeoXNetworkId> {
+    constructor(network: Network<BSNeoXNetworkId>);
+}

package/dist/services/explorer/BlockscoutESNeoX.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockscoutESNeoX = void 0;
+const bs_ethereum_1 = require("@cityofzion/bs-ethereum");
+class BlockscoutESNeoX extends bs_ethereum_1.BlockscoutESEthereum {
+    constructor(network) {
+        super(network, {
+            '47763': 'https://xexplorer.neo.org',
+            '12227332': 'https://xt4scan.ngd.network',
+        });
+    }
+}
+exports.BlockscoutESNeoX = BlockscoutESNeoX;

package/dist/services/extended/BridgeNeoXService.d.ts

@@ -0,0 +1,34 @@
+import { Account, BalanceResponse, Token } from '@cityofzion/blockchain-service';
+import { BSNeoX } from '../../BSNeoX';
+export type TValidateBridgeToNeo3Param<BSName extends string> = {
+    account: Account<BSName>;
+    neo3Address: string;
+    amount: string;
+    token: Token;
+    balances: BalanceResponse[];
+};
+export type TValidateBridgeToNeo3 = {
+    amount: string;
+    receiveAmount: string;
+    token: Token;
+    isGasToken?: boolean;
+    isNeoToken?: boolean;
+};
+export type TBridgeToNeo3Param<BSName extends string> = {
+    account: Account<BSName>;
+    neo3Address: string;
+    validateResult: TValidateBridgeToNeo3;
+};
+export type TCalculateMaxAmountToBridgeToNeo3Param<BSName extends string> = {
+    account: Account<BSName>;
+    neo3Address: string;
+    token: Token;
+    balances: BalanceResponse[];
+};
+export declare class BridgeNeoXService<BSName extends string> {
+    #private;
+    constructor(service: BSNeoX<BSName>);
+    calculateBridgeToNeo3Fee(params: TBridgeToNeo3Param<BSName>): Promise<string>;
+    validateBridgeToNeo3({ amount, balances, token, account, neo3Address, }: TValidateBridgeToNeo3Param<BSName>): Promise<TValidateBridgeToNeo3>;
+    calculateMaxAmountToBridgeToNeoX({ account, balances, neo3Address, token, }: TCalculateMaxAmountToBridgeToNeo3Param<BSName>): Promise<any>;
+}

package/dist/services/extended/BridgeNeoXService.js

@@ -0,0 +1,177 @@
+"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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _BridgeNeoXService_instances, _BridgeNeoXService_service, _BridgeNeoXService_buildBridgeParams;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BridgeNeoXService = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
+const BSNeoXConstants_1 = require("../../constants/BSNeoXConstants");
+const ethers_1 = require("ethers");
+const neon_js_1 = require("@cityofzion/neon-js");
+const bridge_1 = require("../../assets/abis/bridge");
+const bs_ethereum_1 = require("@cityofzion/bs-ethereum");
+class BridgeNeoXService {
+    constructor(service) {
+        _BridgeNeoXService_instances.add(this);
+        _BridgeNeoXService_service.set(this, void 0);
+        __classPrivateFieldSet(this, _BridgeNeoXService_service, service, "f");
+    }
+    calculateBridgeToNeo3Fee(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const signer = yield __classPrivateFieldGet(this, _BridgeNeoXService_service, "f").generateSigner(params.account);
+                const { gasPrice, approveTransactionParams, bridgeTransactionParam } = yield __classPrivateFieldGet(this, _BridgeNeoXService_instances, "m", _BridgeNeoXService_buildBridgeParams).call(this, params);
+                let fee = ethers_1.ethers.utils.parseEther('0');
+                if (params.validateResult.isGasToken) {
+                    const estimated = yield signer.estimateGas(bridgeTransactionParam);
+                    fee = gasPrice.mul(estimated);
+                }
+                else {
+                    let approvedEstimated = ethers_1.ethers.utils.parseEther('0');
+                    if (approveTransactionParams) {
+                        approvedEstimated = yield signer.estimateGas(approveTransactionParams);
+                    }
+                    // We can't estimate the gas for the bridge transaction because it requires the approve transaction to be done first
+                    // if not the gas estimation of bridge transaction will fail so we add a fixed value
+                    const neoBridgeFee = ethers_1.ethers.utils.parseUnits(BSNeoXConstants_1.BSNeoXConstants.BRIDGE_NEO_BRIDGE_TRANSACTION_FEE.toString(), BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET.decimals);
+                    fee = gasPrice.mul(approvedEstimated).add(neoBridgeFee);
+                }
+                return ethers_1.ethers.utils.formatEther(fee);
+            }
+            catch (error) {
+                throw new blockchain_service_1.BSError(error.message, 'FEE_CALCULATION_ERROR');
+            }
+        });
+    }
+    validateBridgeToNeo3({ amount, balances, token, account, neo3Address, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const normalizedSelectedToken = blockchain_service_1.BSTokenHelper.normalizeToken(token);
+            const isGasToken = normalizedSelectedToken.hash === BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET.hash;
+            const isNeoToken = normalizedSelectedToken.hash === BSNeoXConstants_1.BSNeoXConstants.NEO_TOKEN.hash;
+            if (!isGasToken && !isNeoToken) {
+                throw new blockchain_service_1.BSError('Only GAS and NEO tokens are supported for bridging', 'UNSUPPORTED_TOKEN');
+            }
+            const gasBalance = balances.find(balance => blockchain_service_1.BSTokenHelper.normalizeHash(balance.token.hash) === BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET.hash);
+            if (!gasBalance) {
+                throw new blockchain_service_1.BSError('GAS is necessary to bridge', 'GAS_BALANCE_NOT_FOUND');
+            }
+            const amountNumber = blockchain_service_1.BSBigNumberHelper.fromNumber(amount);
+            const gasBalanceNumber = blockchain_service_1.BSBigNumberHelper.fromNumber(gasBalance.amount);
+            if (isGasToken) {
+                const receiveAmount = amountNumber.minus(BSNeoXConstants_1.BSNeoXConstants.BRIDGE_GAS_FEE).toString();
+                if (amountNumber.isLessThan(BSNeoXConstants_1.BSNeoXConstants.BRIDGE_MIN_AMOUNT + BSNeoXConstants_1.BSNeoXConstants.BRIDGE_GAS_FEE)) {
+                    throw new blockchain_service_1.BSError('Amount is less than the minimum amount plus bridge fee', 'AMOUNT_TOO_LOW');
+                }
+                if (amountNumber.isGreaterThan(gasBalanceNumber)) {
+                    throw new blockchain_service_1.BSError('Amount is greater than your balance', 'INSUFFICIENT_GAS_BALANCE');
+                }
+                const validateResult = { receiveAmount, token, isGasToken, isNeoToken, amount };
+                const fee = yield this.calculateBridgeToNeo3Fee({
+                    account,
+                    neo3Address,
+                    validateResult,
+                });
+                if (amountNumber.plus(fee).isGreaterThan(gasBalanceNumber)) {
+                    throw new blockchain_service_1.BSError('Amount is greater than your balance plus fee', 'INSUFFICIENT_GAS_BALANCE_FEE');
+                }
+                return validateResult;
+            }
+            const neoBalance = balances.find(balance => blockchain_service_1.BSTokenHelper.normalizeHash(balance.token.hash) === BSNeoXConstants_1.BSNeoXConstants.NEO_TOKEN.hash);
+            if (!neoBalance) {
+                throw new blockchain_service_1.BSError('NEO balance not found', 'NEO_BALANCE_NOT_FOUND');
+            }
+            if (amountNumber.isLessThan(BSNeoXConstants_1.BSNeoXConstants.BRIDGE_MIN_AMOUNT)) {
+                throw new blockchain_service_1.BSError('Amount is less than the minimum amount', 'AMOUNT_TOO_LOW');
+            }
+            if (amountNumber.isGreaterThan(neoBalance.amount)) {
+                throw new blockchain_service_1.BSError('Amount is greater than your balance', 'INSUFFICIENT_NEO_BALANCE');
+            }
+            const minGasBalanceNumber = blockchain_service_1.BSBigNumberHelper.fromNumber(BSNeoXConstants_1.BSNeoXConstants.BRIDGE_GAS_FEE);
+            if (gasBalanceNumber.isLessThan(minGasBalanceNumber)) {
+                throw new blockchain_service_1.BSError('GAS balance is less than bridge fee', 'INSUFFICIENT_GAS_BALANCE_BRIDGE_FEE');
+            }
+            const receiveAmount = amount;
+            const validateResult = { receiveAmount, token, isNeoToken, amount };
+            const fee = yield this.calculateBridgeToNeo3Fee({
+                account,
+                neo3Address,
+                validateResult,
+            });
+            if (minGasBalanceNumber.plus(blockchain_service_1.BSBigNumberHelper.fromNumber(fee)).isGreaterThan(gasBalanceNumber)) {
+                throw new blockchain_service_1.BSError('GAS balance is less than fees', 'INSUFFICIENT_GAS_BALANCE_FEES');
+            }
+            return validateResult;
+        });
+    }
+    calculateMaxAmountToBridgeToNeoX({ account, balances, neo3Address, token, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const normalizedSelectedToken = blockchain_service_1.BSTokenHelper.normalizeToken(token);
+            const selectedTokenBalance = balances.find(balance => blockchain_service_1.BSTokenHelper.normalizeHash(balance.token.hash) === normalizedSelectedToken.hash);
+            if (!selectedTokenBalance) {
+                throw new blockchain_service_1.BSError('Token balance not found', 'TOKEN_BALANCE_NOT_FOUND');
+            }
+            const selectedTokenBalanceNumber = blockchain_service_1.BSBigNumberHelper.fromNumber(selectedTokenBalance.amount);
+            const amount = blockchain_service_1.BSBigNumberHelper.fromNumber(BSNeoXConstants_1.BSNeoXConstants.BRIDGE_MIN_AMOUNT).toString();
+            const receiveAmount = selectedTokenBalanceNumber.minus(amount).toString();
+            const isGasToken = normalizedSelectedToken.hash === BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET.hash;
+            const isNeoToken = normalizedSelectedToken.hash === BSNeoXConstants_1.BSNeoXConstants.NEO_TOKEN.hash;
+            const fee = yield this.calculateBridgeToNeo3Fee({
+                account,
+                neo3Address,
+                validateResult: { receiveAmount, token, isGasToken, isNeoToken, amount },
+            });
+            const maxAmount = selectedTokenBalanceNumber.minus(blockchain_service_1.BSBigNumberHelper.fromNumber(fee)).toString();
+            return maxAmount;
+        });
+    }
+}
+exports.BridgeNeoXService = BridgeNeoXService;
+_BridgeNeoXService_service = new WeakMap(), _BridgeNeoXService_instances = new WeakSet(), _BridgeNeoXService_buildBridgeParams = function _BridgeNeoXService_buildBridgeParams(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { validateResult } = params;
+        const provider = new ethers_1.ethers.providers.JsonRpcProvider(__classPrivateFieldGet(this, _BridgeNeoXService_service, "f").network.url);
+        const gasPrice = yield provider.getGasPrice();
+        let bridgeTransactionParam;
+        let approveTransactionParams;
+        const to = '0x' + neon_js_1.wallet.getScriptHashFromAddress(params.neo3Address);
+        const bridgeContract = new ethers_1.ethers.Contract(BSNeoXConstants_1.BSNeoXConstants.BRIDGE_SCRIPT_HASH, bridge_1.BRIDGE_ABI);
+        const bridgeFee = ethers_1.ethers.utils.parseUnits(BSNeoXConstants_1.BSNeoXConstants.BRIDGE_GAS_FEE.toString(), BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET.decimals);
+        if (validateResult.isGasToken) {
+            const populatedTransaction = yield bridgeContract.populateTransaction.withdrawNative(to, bridgeFee);
+            bridgeTransactionParam = Object.assign(Object.assign({}, populatedTransaction), { value: ethers_1.ethers.utils.parseUnits(validateResult.amount, params.validateResult.token.decimals), type: 2 });
+        }
+        else {
+            const amount = ethers_1.ethers.utils.parseUnits(blockchain_service_1.BSBigNumberHelper.format(params.validateResult.amount, 0), params.validateResult.token.decimals);
+            const erc20Contract = new ethers_1.ethers.Contract(BSNeoXConstants_1.BSNeoXConstants.NEO_TOKEN.hash, bs_ethereum_1.ERC20_ABI);
+            const populatedApproveTransaction = yield erc20Contract.populateTransaction.approve(BSNeoXConstants_1.BSNeoXConstants.BRIDGE_SCRIPT_HASH, amount);
+            approveTransactionParams = Object.assign(Object.assign({}, populatedApproveTransaction), { type: 2 });
+            const populatedTransaction = yield bridgeContract.populateTransaction.withdrawToken(validateResult.token.hash, to, 
+            // We are using 0 as the decimals because the NEO token in Neo3 has 0 decimals
+            amount);
+            bridgeTransactionParam = Object.assign(Object.assign({}, populatedTransaction), { type: 2, value: bridgeFee });
+        }
+        return {
+            bridgeTransactionParam,
+            approveTransactionParams,
+            gasPrice,
+        };
+    });
+};

package/dist/services/nft-data/GhostMarketNDSNeoX.d.ts

@@ -0,0 +1,6 @@
+import { GhostMarketNDSEthereum } from '@cityofzion/bs-ethereum';
+import { BSNeoXNetworkId } from '../../constants/BSNeoXConstants';
+import { Network } from '@cityofzion/blockchain-service';
+export declare class GhostMarketNDSNeoX extends GhostMarketNDSEthereum<BSNeoXNetworkId> {
+    constructor(network: Network<BSNeoXNetworkId>);
+}

package/dist/services/nft-data/GhostMarketNDSNeoX.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GhostMarketNDSNeoX = void 0;
+const bs_ethereum_1 = require("@cityofzion/bs-ethereum");
+class GhostMarketNDSNeoX extends bs_ethereum_1.GhostMarketNDSEthereum {
+    constructor(network) {
+        super(network, {
+            '47763': 'neox',
+        });
+    }
+}
+exports.GhostMarketNDSNeoX = GhostMarketNDSNeoX;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-neox",
-  "version": "0.0.1",
+  "version": "1.1.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",
@@ -9,21 +9,15 @@
   "files": [
     "/dist"
   ],
-  "scripts": {
-    "build": "tsc --project tsconfig.build.json",
-    "test": "jest --config jest.config.ts",
-    "lint": "eslint .",
-    "format": "eslint --fix"
-  },
   "dependencies": {
-    "@cityofzion/blockchain-service": "workspace:*",
-    "@cityofzion/bs-ethereum": "workspace:*",
     "@cityofzion/dora-ts": "0.5.0",
     "@cityofzion/neon-js": "5.7.0",
     "@ledgerhq/hw-transport": "~6.30.5",
     "axios": "1.8.2",
     "ethers": "5.7.2",
-    "date-fns": "~4.1.0"
+    "date-fns": "~4.1.0",
+    "@cityofzion/bs-ethereum": "2.12.0",
+    "@cityofzion/blockchain-service": "1.18.0"
   },
   "devDependencies": {
     "@ledgerhq/hw-transport-node-hid": "~6.28.5",
@@ -36,5 +30,11 @@
     "ts-jest": "29.1.1",
     "ts-node": "10.9.1",
     "typescript": "4.9.5"
+  },
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "test": "jest --config jest.config.ts",
+    "lint": "eslint .",
+    "format": "eslint --fix"
   }
-}
+}