@cityofzion/bs-neox 1.2.3 → 1.2.4

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

@@ -1,16 +1,14 @@
-import { INeo3NeoXBridgeService, TNeo3NeoXBridgeServiceBridgeParam, TNeo3NeoXBridgeServiceCalculateMaxAmountParams, TNeo3NeoXBridgeServiceValidatedInputs, TNeo3NeoXBridgeServiceValidateInputParams, TNeo3NeoXBridgeServiceWaitParams } from '@cityofzion/blockchain-service';
+import { INeo3NeoXBridgeService, TBridgeToken, TNeo3NeoXBridgeServiceBridgeParam, TNeo3NeoXBridgeServiceConstants, TNeo3NeoXBridgeServiceGetApprovalParam, TNeo3NeoXBridgeServiceGetNonceParams, TNeo3NeoXBridgeServiceGetTransactionHashByNonceParams } 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";
+    readonly BRIDGE_BASE_CONFIRMATION_URL = "https://xexplorer.neo.org:8877/api/v1/transactions/deposits";
+    tokens: TBridgeToken[];
     constructor(service: BSNeoX<BSName>);
-    calculateMaxAmount({ account, balances, receiverAddress, token, }: TNeo3NeoXBridgeServiceCalculateMaxAmountParams<BSName>): Promise<string>;
-    calculateFee(params: TNeo3NeoXBridgeServiceBridgeParam<BSName>): Promise<string>;
+    getBridgeConstants(token: TBridgeToken): Promise<TNeo3NeoXBridgeServiceConstants>;
+    getApprovalFee(params: TNeo3NeoXBridgeServiceGetApprovalParam<BSName>): Promise<string>;
     bridge(params: TNeo3NeoXBridgeServiceBridgeParam<BSName>): Promise<string>;
-    validateInputs(params: TNeo3NeoXBridgeServiceValidateInputParams<BSName>): Promise<TNeo3NeoXBridgeServiceValidatedInputs>;
-    wait(params: TNeo3NeoXBridgeServiceWaitParams): Promise<boolean>;
+    getNonce(params: TNeo3NeoXBridgeServiceGetNonceParams): Promise<string | null>;
+    getTransactionHashByNonce(params: TNeo3NeoXBridgeServiceGetTransactionHashByNonceParams): Promise<string | null>;
 }

package/dist/services/neo3neoXBridge/Neo3NeoXBridgeService.js

@@ -22,7 +22,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 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;
+var _Neo3NeoXBridgeService_instances, _Neo3NeoXBridgeService_service, _Neo3NeoXBridgeService_buildApproveTransactionParam;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Neo3NeoXBridgeService = void 0;
 const blockchain_service_1 = require("@cityofzion/blockchain-service");
@@ -38,61 +38,62 @@ 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';
+        this.BRIDGE_BASE_CONFIRMATION_URL = 'https://xexplorer.neo.org:8877/api/v1/transactions/deposits';
         _Neo3NeoXBridgeService_service.set(this, void 0);
         __classPrivateFieldSet(this, _Neo3NeoXBridgeService_service, service, "f");
+        this.tokens = [
+            Object.assign(Object.assign({}, BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET), { multichainId: 'gas' }),
+            Object.assign(Object.assign({}, BSNeoXConstants_1.BSNeoXConstants.NEO_TOKEN), { multichainId: 'neo' }),
+        ];
     }
-    calculateMaxAmount({ account, balances, receiverAddress, token, }) {
+    getBridgeConstants(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');
+            try {
+                const provider = new ethers_1.ethers.providers.JsonRpcProvider(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.url);
+                const bridgeContract = new ethers_1.ethers.Contract(this.BRIDGE_SCRIPT_HASH, bridge_1.BRIDGE_ABI, provider);
+                const isNativeToken = blockchain_service_1.BSTokenHelper.predicateByHash(token)(BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET);
+                const response = isNativeToken
+                    ? yield bridgeContract.nativeBridge()
+                    : yield bridgeContract.tokenBridges(token.hash);
+                const bridgeFeeBn = blockchain_service_1.BSBigNumberHelper.fromDecimals(response.config.fee.toString(), BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET.decimals);
+                const minAmountBn = blockchain_service_1.BSBigNumberHelper.fromDecimals(response.config.minAmount.toString(), token.decimals);
+                const maxAmountBn = blockchain_service_1.BSBigNumberHelper.fromDecimals(response.config.maxAmount.toString(), token.decimals);
+                const bridgeFee = blockchain_service_1.BSBigNumberHelper.format(bridgeFeeBn, { decimals: BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET.decimals });
+                const bridgeMinAmount = blockchain_service_1.BSBigNumberHelper.format(minAmountBn, { decimals: token.decimals });
+                const bridgeMaxAmount = blockchain_service_1.BSBigNumberHelper.format(maxAmountBn, { decimals: token.decimals });
+                return {
+                    bridgeFee,
+                    bridgeMaxAmount,
+                    bridgeMinAmount,
+                };
+            }
+            catch (error) {
+                throw new blockchain_service_1.BSError('Failed to get bridge constants', 'BRIDGE_CONSTANTS_ERROR', error);
             }
-            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) {
+    getApprovalFee(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);
+                const isNativeToken = blockchain_service_1.BSTokenHelper.predicateByHash(params.token)(BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET);
+                if (isNativeToken) {
+                    throw new blockchain_service_1.BSError('No allowance fee for native token', 'NO_ALLOWANCE_FEE');
                 }
-                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);
+                const populatedApproveTransaction = yield __classPrivateFieldGet(this, _Neo3NeoXBridgeService_instances, "m", _Neo3NeoXBridgeService_buildApproveTransactionParam).call(this, params);
+                if (!populatedApproveTransaction) {
+                    throw new blockchain_service_1.BSError('Allowance is already sufficient', 'ALLOWANCE_ALREADY_SUFFICIENT');
                 }
-                return ethers_1.ethers.utils.formatEther(fee);
+                const signer = yield __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").generateSigner(params.account);
+                const approvedEstimated = yield signer.estimateGas(Object.assign(Object.assign({}, populatedApproveTransaction), { type: 2 }));
+                const provider = new ethers_1.ethers.providers.JsonRpcProvider(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.url);
+                const gasPrice = yield provider.getGasPrice();
+                return ethers_1.ethers.utils.formatEther(gasPrice.mul(approvedEstimated));
             }
             catch (error) {
-                throw new blockchain_service_1.BSError(error.message, 'FEE_CALCULATION_ERROR');
+                if (error instanceof blockchain_service_1.BSError) {
+                    throw error;
+                }
+                throw new blockchain_service_1.BSError('Failed to get allowance fee', 'ALLOWANCE_FEE_ERROR', error);
             }
         });
     }
@@ -102,10 +103,27 @@ class Neo3NeoXBridgeService {
                 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();
+            const bridgeContract = new ethers_1.ethers.Contract(this.BRIDGE_SCRIPT_HASH, bridge_1.BRIDGE_ABI);
+            const to = '0x' + neon_js_1.wallet.getScriptHashFromAddress(params.receiverAddress);
+            const bridgeFee = ethers_1.ethers.utils.parseUnits(params.bridgeFee, BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET.decimals);
+            const isNativeToken = blockchain_service_1.BSTokenHelper.predicateByHash(params.token)(BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET);
+            let bridgeTransactionParam = {
+                type: 2,
+            };
+            if (isNativeToken) {
+                const populatedTransaction = yield bridgeContract.populateTransaction.withdrawNative(to, bridgeFee);
+                bridgeTransactionParam = Object.assign(Object.assign(Object.assign({}, bridgeTransactionParam), populatedTransaction), { value: ethers_1.ethers.utils.parseUnits(params.amount, params.token.decimals) });
+            }
+            else {
+                const approveTransactionParam = yield __classPrivateFieldGet(this, _Neo3NeoXBridgeService_instances, "m", _Neo3NeoXBridgeService_buildApproveTransactionParam).call(this, params);
+                if (approveTransactionParam) {
+                    const approveTransaction = yield signer.sendTransaction(approveTransactionParam);
+                    yield approveTransaction.wait();
+                }
+                const fixedAmount = blockchain_service_1.BSBigNumberHelper.format(params.amount, { decimals: 0 });
+                const amount = ethers_1.ethers.utils.parseUnits(fixedAmount, params.token.decimals);
+                const populatedTransaction = yield bridgeContract.populateTransaction.withdrawToken(params.token.hash, to, amount);
+                bridgeTransactionParam = Object.assign(Object.assign(Object.assign({}, bridgeTransactionParam), populatedTransaction), { value: bridgeFee });
             }
             let gasLimit;
             try {
@@ -114,201 +132,80 @@ class Neo3NeoXBridgeService {
             catch (_a) {
                 gasLimit = bs_ethereum_1.BSEthereumConstants.DEFAULT_GAS_LIMIT;
             }
+            const gasPrice = yield signer.getGasPrice();
             const transaction = yield signer.sendTransaction(Object.assign(Object.assign({}, bridgeTransactionParam), { gasLimit, maxPriorityFeePerGas: gasPrice, maxFeePerGas: gasPrice }));
             return transaction.hash;
         });
     }
-    validateInputs(params) {
+    getNonce(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);
+            let data;
+            try {
+                const client = BlockscoutBDSNeoX_1.BlockscoutBDSNeoX.getClient(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network);
+                const response = yield client.get(`/transactions/${params.transactionHash}/logs`);
+                data = response.data;
             }
-            else if (isNeoToken) {
-                return __classPrivateFieldGet(this, _Neo3NeoXBridgeService_instances, "m", _Neo3NeoXBridgeService_validateNeo).call(this, params);
+            catch (error) {
+                throw new blockchain_service_1.BSError('Transaction logs not found', 'LOGS_NOT_FOUND', error);
             }
-            else {
-                throw new blockchain_service_1.BSError('Only GAS and NEO tokens are supported for bridging', 'UNSUPPORTED_TOKEN');
+            if (!data.items || data.items.length === 0) {
+                throw new blockchain_service_1.BSError('Transaction logs not found', 'LOGS_NOT_FOUND');
+            }
+            try {
+                const BridgeInterface = new ethers_1.ethers.utils.Interface(bridge_1.BRIDGE_ABI);
+                const isNativeToken = blockchain_service_1.BSTokenHelper.predicateByHash(params.token)(BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET);
+                if (isNativeToken) {
+                    const item = data.items[0];
+                    const parsedLog = BridgeInterface.parseLog({ data: item.data, topics: item.topics.filter(Boolean) });
+                    return parsedLog.args.nonce ? parsedLog.args.nonce.toString() : null;
+                }
+                const item = data.items[1];
+                const parsedLog = BridgeInterface.parseLog({ data: item.data, topics: item.topics.filter(Boolean) });
+                return parsedLog.args.nonce ? parsedLog.args.nonce.toString() : null;
+            }
+            catch (error) {
+                return null;
             }
         });
     }
-    wait(params) {
+    getTransactionHashByNonce(params) {
+        var _a, _b;
         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();
+                let url;
+                const isNativeToken = blockchain_service_1.BSTokenHelper.predicateByHash(params.token)(BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET);
+                if (isNativeToken) {
+                    url = `${this.BRIDGE_BASE_CONFIRMATION_URL}/${params.nonce}`;
                 }
                 else {
-                    const item = log.items[1];
-                    const response = BridgeInterface.decodeEventLog('TokenWithdrawal', item.data, item.topics.filter(Boolean));
-                    nonce = response.nonce.toString();
+                    url = `${this.BRIDGE_BASE_CONFIRMATION_URL}/${BSNeoXConstants_1.BSNeoXConstants.NEO_TOKEN.hash}/${params.nonce}`;
                 }
-                if (!nonce) {
-                    throw new Error();
+                const response = yield axios_1.default.get(url);
+                if (!((_a = response.data) === null || _a === void 0 ? void 0 : _a.txid)) {
+                    throw new blockchain_service_1.BSError('Transaction not found', 'TRANSACTION_NOT_FOUND');
                 }
-                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;
+                return (_b = response.data) === null || _b === void 0 ? void 0 : _b.txid;
             }
             catch (error) {
-                return false;
+                throw new blockchain_service_1.BSError('Transaction not found', 'TRANSACTION_NOT_FOUND', error);
             }
         });
     }
 }
 exports.Neo3NeoXBridgeService = Neo3NeoXBridgeService;
-_Neo3NeoXBridgeService_service = new WeakMap(), _Neo3NeoXBridgeService_instances = new WeakSet(), _Neo3NeoXBridgeService_buildGasTransactionParams = function _Neo3NeoXBridgeService_buildGasTransactionParams(params) {
+_Neo3NeoXBridgeService_service = new WeakMap(), _Neo3NeoXBridgeService_instances = new WeakSet(), _Neo3NeoXBridgeService_buildApproveTransactionParam = function _Neo3NeoXBridgeService_buildApproveTransactionParam(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 erc20Contract = new ethers_1.ethers.Contract(params.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');
+        // We are using 0 as the decimals because the NEO token in Neo3 has 0 decimals
+        const fixedAmount = blockchain_service_1.BSBigNumberHelper.format(params.amount, { decimals: 0 });
+        if (allowanceNumber.isGreaterThanOrEqualTo(fixedAmount)) {
+            return null;
         }
-        return validatedInputs;
+        const amount = ethers_1.ethers.utils.parseUnits(fixedAmount, params.token.decimals);
+        const populatedApproveTransaction = yield erc20Contract.populateTransaction.approve(this.BRIDGE_SCRIPT_HASH, amount);
+        return populatedApproveTransaction;
     });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-neox",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",
@@ -11,19 +11,20 @@
   ],
   "dependencies": {
     "@cityofzion/dora-ts": "0.5.1",
-    "@cityofzion/neon-js": "5.7.0",
-    "@ledgerhq/hw-transport": "~6.30.5",
+    "@cityofzion/neon-js": "~5.7.0",
+    "@ledgerhq/hw-transport": "~6.31.8",
     "axios": "1.8.2",
     "ethers": "5.7.2",
     "date-fns": "~4.1.0",
-    "@cityofzion/blockchain-service": "1.19.1",
-    "@cityofzion/bs-ethereum": "2.12.6"
+    "@cityofzion/blockchain-service": "1.19.2",
+    "@cityofzion/bs-ethereum": "2.12.7"
   },
   "devDependencies": {
-    "@ledgerhq/hw-transport-node-hid": "~6.28.5",
+    "@ledgerhq/hw-transport-node-hid": "~6.29.9",
     "@types/jest": "29.5.3",
     "@typescript-eslint/eslint-plugin": "^6.5.0",
     "@typescript-eslint/parser": "^6.5.0",
+    "bignumber.js": "~9.3.0",
     "dotenv": "16.3.1",
     "eslint": "^8.48.0",
     "jest": "29.6.2",