@cityofzion/bs-neox 1.1.2 → 1.2.0

package/dist/constants/BSNeoXConstants.d.ts

@@ -2,12 +2,13 @@ import { Network, NetworkId, Token } from '@cityofzion/blockchain-service';
 export type BSNeoXNetworkId = NetworkId<'47763' | '12227332'>;
 export declare class BSNeoXConstants {
     static NATIVE_ASSET: Token;
+    static NEO_TOKEN: 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 MAINNET_NETWORKS: Network<BSNeoXNetworkId>[];
+    static TESTNET_NETWORKS: Network<BSNeoXNetworkId>[];
     static ALL_NETWORK: Network<BSNeoXNetworkId>[];
     static DEFAULT_NETWORK: Network<BSNeoXNetworkId>;
 }

package/dist/constants/BSNeoXConstants.js

@@ -2,11 +2,23 @@
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSNeoXConstants = void 0;
+const bs_ethereum_1 = require("@cityofzion/bs-ethereum");
 class BSNeoXConstants {
 }
 exports.BSNeoXConstants = BSNeoXConstants;
 _a = BSNeoXConstants;
-BSNeoXConstants.NATIVE_ASSET = { symbol: 'GAS', name: 'GAS', decimals: 18, hash: '-' };
+BSNeoXConstants.NATIVE_ASSET = bs_ethereum_1.BSEthereumTokenHelper.normalizeToken({
+    symbol: 'GAS',
+    name: 'GAS',
+    decimals: 18,
+    hash: '0x',
+});
+BSNeoXConstants.NEO_TOKEN = bs_ethereum_1.BSEthereumTokenHelper.normalizeToken({
+    name: 'NEO',
+    symbol: 'NEO',
+    decimals: 18,
+    hash: '0xc28736dc83f4fd43d6fb832Fd93c3eE7bB26828f',
+});
 BSNeoXConstants.RPC_LIST_BY_NETWORK_ID = {
     '47763': ['https://mainnet-1.rpc.banelabs.org'],
     '12227332': ['https://neoxt4seed1.ngd.network'],
@@ -14,15 +26,20 @@ BSNeoXConstants.RPC_LIST_BY_NETWORK_ID = {
 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 Mainnet',
-    url: _a.RPC_LIST_BY_NETWORK_ID['47763'][0],
-};
-BSNeoXConstants.TESTNET_NETWORK = {
-    id: '12227332',
-    name: 'NeoX Testnet',
-    url: _a.RPC_LIST_BY_NETWORK_ID['12227332'][0],
-};
-BSNeoXConstants.ALL_NETWORK = [_a.MAINNET_NETWORK, _a.TESTNET_NETWORK];
-BSNeoXConstants.DEFAULT_NETWORK = _a.MAINNET_NETWORK;
+BSNeoXConstants.MAINNET_NETWORKS = [
+    {
+        id: '47763',
+        name: 'NeoX Mainnet',
+        url: _a.RPC_LIST_BY_NETWORK_ID['47763'][0],
+    },
+];
+BSNeoXConstants.TESTNET_NETWORKS = [
+    {
+        id: '12227332',
+        name: 'NeoX Testnet',
+        url: _a.RPC_LIST_BY_NETWORK_ID['12227332'][0],
+    },
+];
+BSNeoXConstants.ALL_NETWORK = [..._a.MAINNET_NETWORKS, ..._a.TESTNET_NETWORKS];
+// If tou change this, make sure to update the tests accordingly
+BSNeoXConstants.DEFAULT_NETWORK = _a.MAINNET_NETWORKS[0];

package/dist/helpers/BSNeoXHelper.d.ts

@@ -0,0 +1,5 @@
+import { Network } from '@cityofzion/blockchain-service';
+import { BSNeoXNetworkId } from '../constants/BSNeoXConstants';
+export declare class BSNeoXHelper {
+    static isMainnet(network: Network<BSNeoXNetworkId>): boolean;
+}

package/dist/helpers/BSNeoXHelper.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSNeoXHelper = void 0;
+const BSNeoXConstants_1 = require("../constants/BSNeoXConstants");
+class BSNeoXHelper {
+    static isMainnet(network) {
+        return BSNeoXConstants_1.BSNeoXConstants.MAINNET_NETWORK_IDS.includes(network.id);
+    }
+}
+exports.BSNeoXHelper = BSNeoXHelper;

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

@@ -74,12 +74,12 @@ class BlockscoutBDSNeoX extends bs_ethereum_1.DoraBDSEthereum {
                             to: tokenTransfer.to.hash,
                             type: 'token',
                             contractHash: tokenTransfer.token.address,
-                            token: {
+                            token: bs_ethereum_1.BSEthereumTokenHelper.normalizeToken({
                                 symbol: tokenTransfer.token.symbol,
                                 name: tokenTransfer.token.name,
                                 hash: tokenTransfer.token.address,
                                 decimals: Number(tokenTransfer.total.decimals),
-                            },
+                            }),
                         });
                         continue;
                     }
@@ -145,7 +145,7 @@ class BlockscoutBDSNeoX extends bs_ethereum_1.DoraBDSEthereum {
                             from: item.from.hash,
                             to,
                             type: 'token',
-                            contractHash: item.to.hash,
+                            contractHash: token.hash,
                             token,
                         });
                     }
@@ -231,13 +231,14 @@ class BlockscoutBDSNeoX extends bs_ethereum_1.DoraBDSEthereum {
     }
     getTokenInfo(tokenHash) {
         return __awaiter(this, void 0, void 0, function* () {
-            const normalizedHash = (0, blockchain_service_1.normalizeHash)(tokenHash);
+            const normalizedHash = bs_ethereum_1.BSEthereumTokenHelper.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 cachedToken = this._tokenCache.get(tokenHash);
+            if (cachedToken) {
+                return cachedToken;
             }
             const client = BlockscoutBDSNeoX.getClient(this._network);
             const { data } = yield client.get(`/tokens/${tokenHash}`);
@@ -247,12 +248,14 @@ class BlockscoutBDSNeoX extends bs_ethereum_1.DoraBDSEthereum {
             if (data.type !== 'ERC-20') {
                 throw new Error('Token is not an ERC-20 token');
             }
-            return {
+            const token = bs_ethereum_1.BSEthereumTokenHelper.normalizeToken({
                 decimals: data.decimals ? parseInt(data.decimals) : bs_ethereum_1.BSEthereumConstants.DEFAULT_DECIMALS,
                 hash: tokenHash,
                 name: data.name,
                 symbol: data.symbol,
-            };
+            });
+            this._tokenCache.set(tokenHash, token);
+            return token;
         });
     }
     getBalance(address) {
@@ -278,12 +281,12 @@ class BlockscoutBDSNeoX extends bs_ethereum_1.DoraBDSEthereum {
                     if (balance.token.type !== 'ERC-20') {
                         return;
                     }
-                    const token = {
+                    const token = bs_ethereum_1.BSEthereumTokenHelper.normalizeToken({
                         decimals: balance.token.decimals ? parseInt(balance.token.decimals) : bs_ethereum_1.BSEthereumConstants.DEFAULT_DECIMALS,
-                        hash: (0, blockchain_service_1.normalizeHash)(balance.token.address),
+                        hash: balance.token.address,
                         name: balance.token.symbol,
                         symbol: balance.token.symbol,
-                    };
+                    });
                     balances.push({
                         amount: ethers_1.ethers.utils.formatUnits(balance.value, token.decimals),
                         token,

package/dist/services/neo3neoXBridge/Neo3NeoXBridgeService.d.ts

@@ -0,0 +1,16 @@
+import { INeo3NeoXBridgeService, TNeo3NeoXBridgeServiceBridgeParam, TNeo3NeoXBridgeServiceCalculateMaxAmountParams, TNeo3NeoXBridgeServiceValidatedInputs, TNeo3NeoXBridgeServiceValidateInputParams, TNeo3NeoXBridgeServiceWaitParams } from '@cityofzion/blockchain-service';
+import { BSNeoX } from '../../BSNeoX';
+export declare class Neo3NeoXBridgeService<BSName extends string> implements INeo3NeoXBridgeService<BSName> {
+    #private;
+    readonly BRIDGE_SCRIPT_HASH = "0x1212000000000000000000000000000000000004";
+    readonly BRIDGE_GAS_FEE = 0.1;
+    readonly BRIDGE_MIN_AMOUNT = 1;
+    readonly BRIDGE_NEO_BRIDGE_TRANSACTION_FEE = 0.008;
+    readonly BRIDGE_NEO3_NEO_TOKEN_HASH = "0xef4073a0f2b305a38ec4050e4d3d28bc40ea63f5";
+    constructor(service: BSNeoX<BSName>);
+    calculateMaxAmount({ account, balances, receiverAddress, token, }: TNeo3NeoXBridgeServiceCalculateMaxAmountParams<BSName>): Promise<string>;
+    calculateFee(params: TNeo3NeoXBridgeServiceBridgeParam<BSName>): Promise<string>;
+    bridge(params: TNeo3NeoXBridgeServiceBridgeParam<BSName>): Promise<string>;
+    validateInputs(params: TNeo3NeoXBridgeServiceValidateInputParams<BSName>): Promise<TNeo3NeoXBridgeServiceValidatedInputs>;
+    wait(params: TNeo3NeoXBridgeServiceWaitParams): Promise<boolean>;
+}

package/dist/services/neo3neoXBridge/Neo3NeoXBridgeService.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 __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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Neo3NeoXBridgeService_instances, _Neo3NeoXBridgeService_service, _Neo3NeoXBridgeService_buildGasTransactionParams, _Neo3NeoXBridgeService_buildNeoTransactionParams, _Neo3NeoXBridgeService_buildTransactionParams, _Neo3NeoXBridgeService_validateGas, _Neo3NeoXBridgeService_validateNeo;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Neo3NeoXBridgeService = 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");
+const axios_1 = __importDefault(require("axios"));
+const BlockscoutBDSNeoX_1 = require("../blockchain-data/BlockscoutBDSNeoX");
+const BSNeoXHelper_1 = require("../../helpers/BSNeoXHelper");
+class Neo3NeoXBridgeService {
+    constructor(service) {
+        _Neo3NeoXBridgeService_instances.add(this);
+        this.BRIDGE_SCRIPT_HASH = '0x1212000000000000000000000000000000000004';
+        this.BRIDGE_GAS_FEE = 0.1;
+        this.BRIDGE_MIN_AMOUNT = 1;
+        this.BRIDGE_NEO_BRIDGE_TRANSACTION_FEE = 0.008;
+        this.BRIDGE_NEO3_NEO_TOKEN_HASH = '0xef4073a0f2b305a38ec4050e4d3d28bc40ea63f5';
+        _Neo3NeoXBridgeService_service.set(this, void 0);
+        __classPrivateFieldSet(this, _Neo3NeoXBridgeService_service, service, "f");
+    }
+    calculateMaxAmount({ account, balances, receiverAddress, token, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!BSNeoXHelper_1.BSNeoXHelper.isMainnet(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network))
+                throw new blockchain_service_1.BSError('Bridging to Neo3 is only supported on mainnet', 'UNSUPPORTED_NETWORK');
+            const normalizedSelectedToken = bs_ethereum_1.BSEthereumTokenHelper.normalizeToken(token);
+            const selectedTokenBalance = balances.find(balance => bs_ethereum_1.BSEthereumTokenHelper.normalizeHash(balance.token.hash) === normalizedSelectedToken.hash);
+            if (!selectedTokenBalance) {
+                throw new blockchain_service_1.BSError('Token balance not found', 'TOKEN_BALANCE_NOT_FOUND');
+            }
+            const amountNumber = blockchain_service_1.BSBigNumberHelper.fromNumber(selectedTokenBalance.amount);
+            const receiveAmount = amountNumber.minus(this.BRIDGE_MIN_AMOUNT).toString();
+            const amount = amountNumber.toString();
+            const fee = yield this.calculateFee({
+                account,
+                receiverAddress,
+                validatedInputs: { receiveAmount, token, amount },
+            });
+            const maxAmount = amountNumber.minus(fee).toString();
+            return maxAmount;
+        });
+    }
+    calculateFee(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!BSNeoXHelper_1.BSNeoXHelper.isMainnet(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network))
+                throw new blockchain_service_1.BSError('Bridging to Neo3 is only supported on mainnet', 'UNSUPPORTED_NETWORK');
+            try {
+                const signer = yield __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").generateSigner(params.account);
+                const { gasPrice, approveTransactionParams, bridgeTransactionParam } = yield __classPrivateFieldGet(this, _Neo3NeoXBridgeService_instances, "m", _Neo3NeoXBridgeService_buildTransactionParams).call(this, params);
+                let fee = ethers_1.ethers.utils.parseEther('0');
+                const isGasToken = blockchain_service_1.BSTokenHelper.predicateByHash(params.validatedInputs.token)(BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET);
+                if (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(this.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');
+            }
+        });
+    }
+    bridge(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!BSNeoXHelper_1.BSNeoXHelper.isMainnet(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network))
+                throw new blockchain_service_1.BSError('Bridging to Neo3 is only supported on mainnet', 'UNSUPPORTED_NETWORK');
+            const { account } = params;
+            const signer = yield __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").generateSigner(account);
+            const { approveTransactionParams, bridgeTransactionParam, gasPrice } = yield __classPrivateFieldGet(this, _Neo3NeoXBridgeService_instances, "m", _Neo3NeoXBridgeService_buildTransactionParams).call(this, params);
+            if (approveTransactionParams) {
+                const approveTransaction = yield signer.sendTransaction(approveTransactionParams);
+                yield approveTransaction.wait();
+            }
+            let gasLimit;
+            try {
+                gasLimit = yield signer.estimateGas(bridgeTransactionParam);
+            }
+            catch (_a) {
+                gasLimit = bs_ethereum_1.BSEthereumConstants.DEFAULT_GAS_LIMIT;
+            }
+            const transaction = yield signer.sendTransaction(Object.assign(Object.assign({}, bridgeTransactionParam), { gasLimit, maxPriorityFeePerGas: gasPrice, maxFeePerGas: gasPrice }));
+            return transaction.hash;
+        });
+    }
+    validateInputs(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!BSNeoXHelper_1.BSNeoXHelper.isMainnet(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network))
+                throw new blockchain_service_1.BSError('Bridging to Neo3 is only supported on mainnet', 'UNSUPPORTED_NETWORK');
+            const normalizedSelectedToken = bs_ethereum_1.BSEthereumTokenHelper.normalizeToken(params.token);
+            const isGasToken = normalizedSelectedToken.hash === BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET.hash;
+            const isNeoToken = normalizedSelectedToken.hash === BSNeoXConstants_1.BSNeoXConstants.NEO_TOKEN.hash;
+            if (isGasToken) {
+                return __classPrivateFieldGet(this, _Neo3NeoXBridgeService_instances, "m", _Neo3NeoXBridgeService_validateGas).call(this, params);
+            }
+            else if (isNeoToken) {
+                return __classPrivateFieldGet(this, _Neo3NeoXBridgeService_instances, "m", _Neo3NeoXBridgeService_validateNeo).call(this, params);
+            }
+            else {
+                throw new blockchain_service_1.BSError('Only GAS and NEO tokens are supported for bridging', 'UNSUPPORTED_TOKEN');
+            }
+        });
+    }
+    wait(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!BSNeoXHelper_1.BSNeoXHelper.isMainnet(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network))
+                throw new blockchain_service_1.BSError('Bridging to Neo3 is only supported on mainnet', 'UNSUPPORTED_NETWORK');
+            try {
+                const { transactionHash, validatedInputs } = params;
+                let nonce;
+                const log = yield blockchain_service_1.BSUtilsHelper.retry(() => __awaiter(this, void 0, void 0, function* () {
+                    const client = BlockscoutBDSNeoX_1.BlockscoutBDSNeoX.getClient(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network);
+                    const { data } = yield client.get(`/transactions/${transactionHash}/logs`);
+                    if (!data.items || data.items.length === 0) {
+                        throw new blockchain_service_1.BSError('Transaction logs not found', 'LOGS_NOT_FOUND');
+                    }
+                    return data;
+                }), {
+                    retries: 10,
+                    delay: 30000,
+                });
+                const BridgeInterface = new ethers_1.ethers.utils.Interface(bridge_1.BRIDGE_ABI);
+                const isGasToken = blockchain_service_1.BSTokenHelper.predicateByHash(validatedInputs.token)(BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET);
+                if (isGasToken) {
+                    const item = log.items[0];
+                    const response = BridgeInterface.decodeEventLog('NativeWithdrawal', item.data, item.topics.filter(Boolean));
+                    nonce = response.nonce.toString();
+                }
+                else {
+                    const item = log.items[1];
+                    const response = BridgeInterface.decodeEventLog('TokenWithdrawal', item.data, item.topics.filter(Boolean));
+                    nonce = response.nonce.toString();
+                }
+                if (!nonce) {
+                    throw new Error();
+                }
+                yield blockchain_service_1.BSUtilsHelper.retry(() => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b;
+                    const response = yield axios_1.default.post('https://neofura.ngd.network', {
+                        jsonrpc: '2.0',
+                        method: 'GetBridgeTxByNonce',
+                        params: {
+                            ContractHash: this.BRIDGE_SCRIPT_HASH,
+                            TokenHash: isGasToken ? '' : this.BRIDGE_NEO3_NEO_TOKEN_HASH,
+                            Nonce: Number(nonce),
+                        },
+                        id: 1,
+                    });
+                    if (!((_a = response.data) === null || _a === void 0 ? void 0 : _a.result.Vmstate) || !((_b = response.data) === null || _b === void 0 ? void 0 : _b.result.txid)) {
+                        throw new blockchain_service_1.BSError('Transaction not found', 'TRANSACTION_NOT_FOUND');
+                    }
+                    if (response.data.result.Vmstate !== 'HALT') {
+                        throw new blockchain_service_1.BSError('Transaction is not in a valid state', 'INVALID_TRANSACTION_STATE');
+                    }
+                }), {
+                    retries: 10,
+                    delay: 30000,
+                });
+                return true;
+            }
+            catch (error) {
+                return false;
+            }
+        });
+    }
+}
+exports.Neo3NeoXBridgeService = Neo3NeoXBridgeService;
+_Neo3NeoXBridgeService_service = new WeakMap(), _Neo3NeoXBridgeService_instances = new WeakSet(), _Neo3NeoXBridgeService_buildGasTransactionParams = function _Neo3NeoXBridgeService_buildGasTransactionParams(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const provider = new ethers_1.ethers.providers.JsonRpcProvider(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.url);
+        const gasPrice = yield provider.getGasPrice();
+        const to = '0x' + neon_js_1.wallet.getScriptHashFromAddress(params.receiverAddress);
+        const bridgeContract = new ethers_1.ethers.Contract(this.BRIDGE_SCRIPT_HASH, bridge_1.BRIDGE_ABI);
+        const bridgeFee = ethers_1.ethers.utils.parseUnits(this.BRIDGE_GAS_FEE.toString(), BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET.decimals);
+        const populatedTransaction = yield bridgeContract.populateTransaction.withdrawNative(to, bridgeFee);
+        const bridgeTransactionParam = Object.assign(Object.assign({}, populatedTransaction), { value: ethers_1.ethers.utils.parseUnits(params.validatedInputs.amount, params.validatedInputs.token.decimals), type: 2 });
+        return {
+            bridgeTransactionParam,
+            approveTransactionParams: undefined,
+            gasPrice,
+        };
+    });
+}, _Neo3NeoXBridgeService_buildNeoTransactionParams = function _Neo3NeoXBridgeService_buildNeoTransactionParams(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const provider = new ethers_1.ethers.providers.JsonRpcProvider(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.url);
+        const gasPrice = yield provider.getGasPrice();
+        const to = '0x' + neon_js_1.wallet.getScriptHashFromAddress(params.receiverAddress);
+        const bridgeContract = new ethers_1.ethers.Contract(this.BRIDGE_SCRIPT_HASH, bridge_1.BRIDGE_ABI);
+        const bridgeFee = ethers_1.ethers.utils.parseUnits(this.BRIDGE_GAS_FEE.toString(), BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET.decimals);
+        // We are using 0 as the decimals because the NEO token in Neo3 has 0 decimals
+        const fixedAmount = blockchain_service_1.BSBigNumberHelper.format(params.validatedInputs.amount, { decimals: 0 });
+        const amount = ethers_1.ethers.utils.parseUnits(fixedAmount, params.validatedInputs.token.decimals);
+        const erc20Contract = new ethers_1.ethers.Contract(BSNeoXConstants_1.BSNeoXConstants.NEO_TOKEN.hash, bs_ethereum_1.ERC20_ABI, provider);
+        const allowance = yield erc20Contract.allowance(params.account.address, this.BRIDGE_SCRIPT_HASH);
+        const allowanceNumber = blockchain_service_1.BSBigNumberHelper.fromDecimals(allowance.toString(), BSNeoXConstants_1.BSNeoXConstants.NEO_TOKEN.decimals);
+        let approveTransactionParams;
+        if (allowanceNumber.isLessThan(fixedAmount)) {
+            const populatedApproveTransaction = yield erc20Contract.populateTransaction.approve(this.BRIDGE_SCRIPT_HASH, amount);
+            approveTransactionParams = Object.assign(Object.assign({}, populatedApproveTransaction), { type: 2 });
+        }
+        const populatedTransaction = yield bridgeContract.populateTransaction.withdrawToken(params.validatedInputs.token.hash, to, amount);
+        const bridgeTransactionParam = Object.assign(Object.assign({}, populatedTransaction), { type: 2, value: bridgeFee });
+        return {
+            bridgeTransactionParam,
+            approveTransactionParams,
+            gasPrice,
+        };
+    });
+}, _Neo3NeoXBridgeService_buildTransactionParams = function _Neo3NeoXBridgeService_buildTransactionParams(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const isGasToken = blockchain_service_1.BSTokenHelper.predicateByHash(params.validatedInputs.token)(BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET);
+        if (isGasToken) {
+            return __classPrivateFieldGet(this, _Neo3NeoXBridgeService_instances, "m", _Neo3NeoXBridgeService_buildGasTransactionParams).call(this, params);
+        }
+        return __classPrivateFieldGet(this, _Neo3NeoXBridgeService_instances, "m", _Neo3NeoXBridgeService_buildNeoTransactionParams).call(this, params);
+    });
+}, _Neo3NeoXBridgeService_validateGas = function _Neo3NeoXBridgeService_validateGas({ amount, balances, token, account, receiverAddress, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const gasBalance = balances.find(balance => bs_ethereum_1.BSEthereumTokenHelper.predicateByHash(balance.token)(BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET));
+        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);
+        const validatedInputs = {
+            receiveAmount: amountNumber.minus(this.BRIDGE_GAS_FEE).toString(),
+            token,
+            amount,
+        };
+        if (amountNumber.isLessThan(this.BRIDGE_MIN_AMOUNT + this.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 fee = yield this.calculateFee({
+            account,
+            receiverAddress,
+            validatedInputs,
+        });
+        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 validatedInputs;
+    });
+}, _Neo3NeoXBridgeService_validateNeo = function _Neo3NeoXBridgeService_validateNeo({ amount, balances, token, account, receiverAddress, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const gasBalance = balances.find(balance => bs_ethereum_1.BSEthereumTokenHelper.predicateByHash(balance.token)(BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET));
+        if (!gasBalance) {
+            throw new blockchain_service_1.BSError('GAS is necessary to bridge', 'GAS_BALANCE_NOT_FOUND');
+        }
+        const neoBalance = balances.find(balance => bs_ethereum_1.BSEthereumTokenHelper.predicateByHash(balance.token)(BSNeoXConstants_1.BSNeoXConstants.NEO_TOKEN));
+        if (!neoBalance) {
+            throw new blockchain_service_1.BSError('NEO balance not found', 'NEO_BALANCE_NOT_FOUND');
+        }
+        const amountNumber = blockchain_service_1.BSBigNumberHelper.fromNumber(amount);
+        const gasBalanceNumber = blockchain_service_1.BSBigNumberHelper.fromNumber(gasBalance.amount);
+        const minGasBalanceNumber = blockchain_service_1.BSBigNumberHelper.fromNumber(this.BRIDGE_GAS_FEE);
+        const validatedInputs = { receiveAmount: amount, token, amount };
+        if (amountNumber.isLessThan(this.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');
+        }
+        if (gasBalanceNumber.isLessThan(minGasBalanceNumber)) {
+            throw new blockchain_service_1.BSError('GAS balance is less than bridge fee', 'INSUFFICIENT_GAS_BALANCE_BRIDGE_FEE');
+        }
+        const fee = yield this.calculateFee({
+            account,
+            receiverAddress,
+            validatedInputs,
+        });
+        if (minGasBalanceNumber.plus(fee).isGreaterThan(gasBalanceNumber)) {
+            throw new blockchain_service_1.BSError('GAS balance is less than fees', 'INSUFFICIENT_GAS_BALANCE_FEES');
+        }
+        return validatedInputs;
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-neox",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",
@@ -16,8 +16,8 @@
     "axios": "1.8.2",
     "ethers": "5.7.2",
     "date-fns": "~4.1.0",
-    "@cityofzion/bs-ethereum": "2.12.1",
-    "@cityofzion/blockchain-service": "1.18.1"
+    "@cityofzion/blockchain-service": "1.19.0",
+    "@cityofzion/bs-ethereum": "2.12.3"
   },
   "devDependencies": {
     "@ledgerhq/hw-transport-node-hid": "~6.28.5",