@cityofzion/bs-neox 3.1.16 → 3.1.18

package/dist/BSNeoX.js

@@ -36,7 +36,7 @@ class BSNeoX extends bs_ethereum_1.BSEthereum {
             throw new Error('Invalid chainId');
         }
         transactionParams.chainId = chainId;
-        const nonce = await signer.getTransactionCount('pending');
+        const nonce = await signer.getNonce('pending');
         if (isNaN(nonce)) {
             throw new Error('Invalid nonce');
         }
@@ -104,10 +104,12 @@ class BSNeoX extends bs_ethereum_1.BSEthereum {
         }
         newParams.maxPriorityFeePerGas = gasPriceBn.toString();
         newParams.maxFeePerGas = gasPriceBn.toString();
-        const [secondTransactionResponse, secondTransactionError] = await blockchain_service_1.BSUtilsHelper.tryCatch(() => signer.sendTransaction(newParams));
-        const transactionHash = secondTransactionResponse?.hash || secondTransactionError?.returnedHash;
-        if (!transactionHash)
-            throw secondTransactionError || new Error('Transaction error');
+        const provider = new ethers_1.JsonRpcProvider(this.network.url);
+        const signedTransaction = await signer.signTransaction(newParams);
+        const transactionHash = await provider.send('eth_sendRawTransaction', [signedTransaction]);
+        if (!transactionHash) {
+            throw new blockchain_service_1.BSError('Transaction error', 'TRANSACTION_ERROR');
+        }
         const fee = gasPriceBn.multipliedBy(newParams.gasLimit).toHuman().toFormatted();
         return { transactionHash, fee };
     }
@@ -130,7 +132,7 @@ class BSNeoX extends bs_ethereum_1.BSEthereum {
         this.fullTransactionsDataService = new BlockscoutFullTransactionsDataService_1.BlockscoutFullTransactionsDataService(this);
     }
     async transfer({ senderAccount, intents, }) {
-        const signer = await this._generateSigner(senderAccount);
+        const signer = await this._getSigner(senderAccount);
         const { address } = senderAccount;
         const addressUrl = this.explorerService.buildAddressUrl(address);
         const transactions = [];

package/dist/constants/BSNeoXConstants.d.ts

@@ -2,6 +2,7 @@ import type { TBSNetwork, TBSToken } from '@cityofzion/blockchain-service';
 import type { TBSNeoXNetworkId } from '../types';
 export declare class BSNeoXConstants {
     static readonly NATIVE_ASSET: TBSToken;
+    static readonly NDMEME_TOKEN: TBSToken;
     static readonly ANTI_MEV_RPC_LIST_BY_NETWORK_ID: Record<TBSNeoXNetworkId, string[]>;
     static readonly RPC_LIST_BY_NETWORK_ID: Record<TBSNeoXNetworkId, string[]>;
     static readonly MAINNET_NETWORK: TBSNetwork<TBSNeoXNetworkId>;

package/dist/constants/BSNeoXConstants.js

@@ -12,6 +12,12 @@ BSNeoXConstants.NATIVE_ASSET = {
     decimals: 18,
     hash: '-',
 };
+BSNeoXConstants.NDMEME_TOKEN = {
+    symbol: 'NDMEME',
+    name: 'NDMEME',
+    hash: '0xe816dee05cf6d0f2a57eb4c489241d8326b5d106',
+    decimals: 18,
+};
 BSNeoXConstants.ANTI_MEV_RPC_LIST_BY_NETWORK_ID = {
     '47763': ['https://mainnet-5.rpc.banelabs.org'],
     '12227332': ['https://neoxt4seed5.ngd.network'],

package/dist/helpers/BSNeoXHelper.d.ts

@@ -7,4 +7,5 @@ export declare class BSNeoXHelper {
         decimals: number;
         hash: string;
     };
+    static getNdmemeToken(network: TBSNetwork<TBSNeoXNetworkId>): import("@cityofzion/blockchain-service").TBSToken;
 }

package/dist/helpers/BSNeoXHelper.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSNeoXHelper = void 0;
 const blockchain_service_1 = require("@cityofzion/blockchain-service");
+const BSNeoXConstants_1 = require("../constants/BSNeoXConstants");
 class BSNeoXHelper {
     static getNeoToken(network) {
         if (network.type === 'custom') {
@@ -13,5 +14,11 @@ class BSNeoXHelper {
         }
         return { name: 'NEO', symbol: 'NEO', decimals: 18, hash };
     }
+    static getNdmemeToken(network) {
+        if (network.type !== 'mainnet') {
+            return { ...BSNeoXConstants_1.BSNeoXConstants.NDMEME_TOKEN, hash: '-' };
+        }
+        return BSNeoXConstants_1.BSNeoXConstants.NDMEME_TOKEN;
+    }
 }
 exports.BSNeoXHelper = BSNeoXHelper;

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

@@ -101,7 +101,6 @@ class BlockscoutBDSNeoX extends bs_ethereum_1.RpcBDSEthereum {
             });
             await Promise.allSettled(promises);
         }
-        const data = this._service.neo3NeoXBridgeService._getDataFromBlockscoutTransaction(response);
         const txId = response.hash;
         return {
             blockchain: this._service.name,
@@ -115,7 +114,6 @@ class BlockscoutBDSNeoX extends bs_ethereum_1.RpcBDSEthereum {
                 .toFormatted(),
             view: 'default',
             events,
-            data,
         };
     }
     async getTransactionsByAddress(params) {
@@ -152,7 +150,7 @@ class BlockscoutBDSNeoX extends bs_ethereum_1.RpcBDSEthereum {
             const rawInput = item.raw_input;
             if (rawInput) {
                 try {
-                    const ERC20Interface = new ethers_1.ethers.utils.Interface(bs_ethereum_1.ERC20_ABI);
+                    const ERC20Interface = new ethers_1.Interface(bs_ethereum_1.ERC20_ABI);
                     const result = ERC20Interface.decodeFunctionData('transfer', rawInput);
                     if (!result)
                         throw new Error('Invalid ERC20 transfer');
@@ -179,7 +177,6 @@ class BlockscoutBDSNeoX extends bs_ethereum_1.RpcBDSEthereum {
                     /* empty */
                 }
             }
-            const data = this._service.neo3NeoXBridgeService._getDataFromBlockscoutTransaction(item);
             const txId = item.hash;
             const transaction = {
                 blockchain: this._service.name,
@@ -192,7 +189,6 @@ class BlockscoutBDSNeoX extends bs_ethereum_1.RpcBDSEthereum {
                 networkFeeAmount: new blockchain_service_1.BSBigUnitAmount(item.fee.value, this._service.feeToken.decimals).toHuman().toFormatted(),
                 view: 'default',
                 events,
-                data,
             };
             transactions.splice(index, 0, transaction);
         });

package/dist/services/full-transactions-data/BlockscoutFullTransactionsDataService.js

@@ -92,25 +92,29 @@ class BlockscoutFullTransactionsDataService {
                     tokenUrl: token ? __classPrivateFieldGet(this, _BlockscoutFullTransactionsDataService_service, "f").explorerService.buildContractUrl(token.hash) : undefined,
                     token,
                 });
-                const eventData = 'data' in item ? item.data : undefined;
-                const bridgeData = eventData?.bridgeData;
-                if (bridgeData) {
-                    const tokenToUse = bridgeData.method === 'withdrawNative'
-                        ? __classPrivateFieldGet(this, _BlockscoutFullTransactionsDataService_service, "f").neo3NeoXBridgeService.gasToken
-                        : __classPrivateFieldGet(this, _BlockscoutFullTransactionsDataService_service, "f").neo3NeoXBridgeService.neoToken;
+            });
+            await Promise.allSettled(eventPromises);
+            const itemData = 'data' in item ? item.data : undefined;
+            const bridgeData = itemData?.bridgeData;
+            if (bridgeData) {
+                const bridgeService = __classPrivateFieldGet(this, _BlockscoutFullTransactionsDataService_service, "f").neo3NeoXBridgeService;
+                const tokenService = __classPrivateFieldGet(this, _BlockscoutFullTransactionsDataService_service, "f").tokenService;
+                const tokenToUse = !bridgeData.neoXTokenHash
+                    ? bridgeService.gasToken
+                    : bridgeService.tokens.find(token => tokenService.predicateByHash(bridgeData.neoXTokenHash, token));
+                if (tokenToUse) {
                     newItem = {
                         ...newItem,
                         data: {
                             neo3NeoxBridge: {
                                 amount: new blockchain_service_1.BSBigHumanAmount(bridgeData.amount, tokenToUse.decimals).toFormatted(),
                                 tokenToUse,
-                                receiverAddress: bridgeData.receiverBridgeAddress,
+                                receiverAddress: bridgeData.receiverAddress,
                             },
                         },
                     };
                 }
-            });
-            await Promise.allSettled(eventPromises);
+            }
             transactions.splice(index, 0, newItem);
         });
         await Promise.allSettled(itemPromises);

package/dist/services/neo3-neox-bridge/Neo3NeoXBridgeService.d.ts

@@ -1,13 +1,14 @@
 import { INeo3NeoXBridgeService, TBridgeToken, TNeo3NeoXBridgeServiceBridgeParam, TNeo3NeoXBridgeServiceConstants, TNeo3NeoXBridgeServiceGetApprovalParam, TNeo3NeoXBridgeServiceGetNonceParams, TNeo3NeoXBridgeServiceGetTransactionHashByNonceParams, type TNeo3NeoXBridgeTransactionData, type TTransactionBase } from '@cityofzion/blockchain-service';
-import type { IBSNeoX, TBSNeoXName, TBlockscoutBDSNeoXTransactionApiResponse } from '../../types';
+import type { IBSNeoX, TBSNeoXName } from '../../types';
 export declare class Neo3NeoXBridgeService implements INeo3NeoXBridgeService<TBSNeoXName> {
     #private;
     static readonly BRIDGE_SCRIPT_HASH = "0x1212000000000000000000000000000000000004";
     static readonly BRIDGE_BASE_CONFIRMATION_URL = "https://xexplorer.neo.org:8877/api/v1/transactions/deposits";
     readonly gasToken: TBridgeToken<TBSNeoXName>;
     readonly neoToken: TBridgeToken<TBSNeoXName>;
+    readonly ndmemeToken: TBridgeToken<TBSNeoXName>;
+    readonly tokens: TBridgeToken<TBSNeoXName>[];
     constructor(service: IBSNeoX);
-    _getDataFromBlockscoutTransaction(response: TBlockscoutBDSNeoXTransactionApiResponse): TNeo3NeoXBridgeTransactionData<TBSNeoXName> | undefined;
     getBridgeConstants(token: TBridgeToken<TBSNeoXName>): Promise<TNeo3NeoXBridgeServiceConstants>;
     getApprovalFee(params: TNeo3NeoXBridgeServiceGetApprovalParam<TBSNeoXName>): Promise<string>;
     bridge(params: TNeo3NeoXBridgeServiceBridgeParam<TBSNeoXName>): Promise<string>;

package/dist/services/neo3-neox-bridge/Neo3NeoXBridgeService.js

@@ -31,38 +31,19 @@ class Neo3NeoXBridgeService {
         _Neo3NeoXBridgeService_service.set(this, void 0);
         __classPrivateFieldSet(this, _Neo3NeoXBridgeService_service, service, "f");
         const neoToken = BSNeoXHelper_1.BSNeoXHelper.getNeoToken(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network);
+        const ndmemeToken = BSNeoXHelper_1.BSNeoXHelper.getNdmemeToken(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network);
         this.gasToken = { ...BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET, blockchain: service.name, multichainId: 'gas' };
         this.neoToken = { ...neoToken, blockchain: service.name, multichainId: 'neo' };
-    }
-    _getDataFromBlockscoutTransaction(response) {
-        if (response.to.hash.toLowerCase() !== _a.BRIDGE_SCRIPT_HASH.toLowerCase()) {
-            return undefined;
-        }
-        const BridgeInterface = new ethers_1.ethers.utils.Interface(bridge_1.BRIDGE_ABI);
-        const input = BridgeInterface.parseTransaction({ data: response.raw_input });
-        const { wallet } = bs_neo3_1.BSNeo3NeonJsSingletonHelper.getInstance();
-        const to = input.args._to;
-        const receiverAddress = wallet.getAddressFromScriptHash(to.startsWith('0x') ? to.slice(2) : to);
-        let tokenToUse;
-        let amount;
-        if (input.name === 'withdrawNative') {
-            tokenToUse = this.gasToken;
-            amount = new blockchain_service_1.BSBigUnitAmount(response.value, tokenToUse.decimals)
-                .minus(input.args._maxFee.toString())
-                .toHuman()
-                .toFormatted();
-        }
-        else if (input.name === 'withdrawToken') {
-            tokenToUse = this.neoToken;
-            amount = new blockchain_service_1.BSBigUnitAmount(input.args._amount.toString(), tokenToUse.decimals).toHuman().toFormatted();
-        }
-        if (!tokenToUse || !amount)
-            return undefined;
-        return { neo3NeoxBridge: { tokenToUse, receiverAddress, amount } };
+        this.ndmemeToken = {
+            ...ndmemeToken,
+            blockchain: service.name,
+            multichainId: 'ndmeme',
+        };
+        this.tokens = [this.gasToken, this.neoToken, this.ndmemeToken];
     }
     async getBridgeConstants(token) {
         try {
-            const provider = new ethers_1.ethers.providers.JsonRpcProvider(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.url);
+            const provider = new ethers_1.JsonRpcProvider(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.url);
             const bridgeContract = new ethers_1.ethers.Contract(_a.BRIDGE_SCRIPT_HASH, bridge_1.BRIDGE_ABI, provider);
             const isNativeToken = __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").tokenService.predicateByHash(token, BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET);
             const response = isNativeToken
@@ -101,15 +82,15 @@ class Neo3NeoXBridgeService {
             if (isNaN(chainId)) {
                 throw new Error('Invalid chainId');
             }
-            const signer = await __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f")._generateSigner(params.account);
-            const nonce = await signer.getTransactionCount('pending');
+            const signer = await __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f")._getSigner(params.account);
+            const nonce = await signer.getNonce('pending');
             if (isNaN(nonce)) {
                 throw new Error('Invalid nonce');
             }
             const approvedEstimated = await signer.estimateGas({ ...populatedApproveTransaction, chainId, nonce, type: 2 });
-            const provider = new ethers_1.ethers.providers.JsonRpcProvider(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.url);
-            const gasPrice = await provider.getGasPrice();
-            return new blockchain_service_1.BSBigUnitAmount(gasPrice.toString(), bs_ethereum_1.BSEthereumConstants.DEFAULT_DECIMALS)
+            const provider = new ethers_1.JsonRpcProvider(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.url);
+            const { gasPrice } = await provider.getFeeData();
+            return new blockchain_service_1.BSBigUnitAmount(gasPrice?.toString() || '0', bs_ethereum_1.BSEthereumConstants.DEFAULT_DECIMALS)
                 .multipliedBy(approvedEstimated.toString())
                 .toHuman()
                 .toFormatted();
@@ -125,18 +106,19 @@ class Neo3NeoXBridgeService {
         if (__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.type !== 'mainnet') {
             throw new blockchain_service_1.BSError('Bridging to Neo3 is only supported on mainnet', 'UNSUPPORTED_NETWORK');
         }
-        const signer = await __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f")._generateSigner(params.account);
+        const signer = await __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f")._getSigner(params.account);
         const bridgeContract = new ethers_1.ethers.Contract(_a.BRIDGE_SCRIPT_HASH, bridge_1.BRIDGE_ABI);
         const { wallet } = bs_neo3_1.BSNeo3NeonJsSingletonHelper.getInstance();
         const to = `0x${wallet.getScriptHashFromAddress(params.receiverAddress)}`;
-        const bridgeFee = new blockchain_service_1.BSBigHumanAmount(params.bridgeFee, BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET.decimals).toUnit().toString();
+        const bridgeFee = new blockchain_service_1.BSBigHumanAmount(params.bridgeFee, BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET.decimals).toUnit().toFixed();
         const isNativeToken = __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").tokenService.predicateByHash(params.token, BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET);
-        const gasPrice = await signer.getGasPrice();
-        const gasPriceBn = new blockchain_service_1.BSBigUnitAmount(gasPrice.toString(), bs_ethereum_1.BSEthereumConstants.DEFAULT_DECIMALS);
+        const provider = new ethers_1.JsonRpcProvider(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.url);
+        const { gasPrice } = await provider.getFeeData();
+        const gasPriceBn = new blockchain_service_1.BSBigUnitAmount(gasPrice?.toString() || '0', bs_ethereum_1.BSEthereumConstants.DEFAULT_DECIMALS);
         const transactionParams = { type: 2 };
         if (isNativeToken) {
-            const populatedTransactionParams = await bridgeContract.populateTransaction.withdrawNative(to, bridgeFee);
-            const value = new blockchain_service_1.BSBigHumanAmount(params.amount, params.token.decimals).toUnit().plus(bridgeFee).toString();
+            const populatedTransactionParams = await bridgeContract.withdrawNative.populateTransaction(to, bridgeFee);
+            const value = new blockchain_service_1.BSBigHumanAmount(params.amount, params.token.decimals).toUnit().plus(bridgeFee).toFixed();
             Object.assign(transactionParams, populatedTransactionParams, { value });
         }
         else {
@@ -147,12 +129,12 @@ class Neo3NeoXBridgeService {
                     gasPriceBn,
                     transactionParams: approveTransactionParam,
                 });
-                const provider = new ethers_1.ethers.providers.JsonRpcProvider(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.url);
+                const provider = new ethers_1.JsonRpcProvider(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.url);
                 await provider.waitForTransaction(transactionHash);
             }
             const fixedAmount = new blockchain_service_1.BSBigHumanAmount(params.amount, 0).toFormatted();
-            const amount = new blockchain_service_1.BSBigHumanAmount(fixedAmount, params.token.decimals).toUnit().toString();
-            const populatedTransactionParams = await bridgeContract.populateTransaction.withdrawToken(params.token.hash, to, amount);
+            const amount = new blockchain_service_1.BSBigHumanAmount(fixedAmount, params.token.decimals).toUnit().toFixed();
+            const populatedTransactionParams = await bridgeContract.withdrawToken.populateTransaction(params.token.hash, to, amount);
             Object.assign(transactionParams, populatedTransactionParams, { value: bridgeFee });
         }
         const { transactionHash } = await __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f")._sendTransaction({ signer, gasPriceBn, transactionParams });
@@ -165,16 +147,18 @@ class Neo3NeoXBridgeService {
         });
         if (!transactionLogsResponse)
             throw new blockchain_service_1.BSError('Failed to get nonce from transaction log', 'FAILED_TO_GET_NONCE', transactionLogsResponseError);
-        const [nonce, nonceError] = await blockchain_service_1.BSUtilsHelper.tryCatch(() => {
-            const BridgeInterface = new ethers_1.ethers.utils.Interface(bridge_1.BRIDGE_ABI);
-            const isNativeToken = __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").tokenService.predicateByHash(params.token, BSNeoXConstants_1.BSNeoXConstants.NATIVE_ASSET);
-            const dataIndex = isNativeToken ? 0 : 1;
-            const log = transactionLogsResponse.data.items[dataIndex];
-            const parsedLog = BridgeInterface.parseLog({
-                data: log.data,
-                topics: log.topics.filter(Boolean),
-            });
-            return parsedLog.args.nonce ? parsedLog.args.nonce.toString() : undefined;
+        const [nonce, nonceError] = await blockchain_service_1.BSUtilsHelper.tryCatch(async () => {
+            const BridgeInterface = new ethers_1.Interface(bridge_1.BRIDGE_ABI);
+            for (const log of transactionLogsResponse.data.items) {
+                const [parsedNonce] = await blockchain_service_1.BSUtilsHelper.tryCatch(() => {
+                    const parsedLog = BridgeInterface.parseLog({ data: log.data, topics: log.topics.filter(Boolean) });
+                    const nonce = parsedLog?.args?.nonce;
+                    return nonce !== undefined && nonce !== null ? nonce.toString() : undefined;
+                });
+                if (parsedNonce)
+                    return parsedNonce;
+            }
+            return undefined;
         });
         if (!nonce) {
             throw new blockchain_service_1.BSError('Failed to get nonce from transaction log', 'FAILED_TO_GET_NONCE', nonceError);
@@ -189,7 +173,7 @@ class Neo3NeoXBridgeService {
                 url = `${_a.BRIDGE_BASE_CONFIRMATION_URL}/${params.nonce}`;
             }
             else {
-                url = `${_a.BRIDGE_BASE_CONFIRMATION_URL}/${this.neoToken.hash}/${params.nonce}`;
+                url = `${_a.BRIDGE_BASE_CONFIRMATION_URL}/${params.token.hash}/${params.nonce}`;
             }
             const response = await axios_1.default.get(url);
             if (!response.data?.txid) {
@@ -202,8 +186,7 @@ class Neo3NeoXBridgeService {
         }
     }
     getTokenByMultichainId(multichainId) {
-        const tokens = [this.gasToken, this.neoToken];
-        return tokens.find(token => token.multichainId === multichainId);
+        return this.tokens.find(token => token.multichainId === multichainId);
     }
     getTransactionData(transaction) {
         return transaction.data?.neo3NeoxBridge ? transaction.data : undefined;
@@ -211,17 +194,17 @@ class Neo3NeoXBridgeService {
 }
 exports.Neo3NeoXBridgeService = Neo3NeoXBridgeService;
 _a = Neo3NeoXBridgeService, _Neo3NeoXBridgeService_service = new WeakMap(), _Neo3NeoXBridgeService_instances = new WeakSet(), _Neo3NeoXBridgeService_buildApproveTransactionParam = async function _Neo3NeoXBridgeService_buildApproveTransactionParam(params) {
-    const provider = new ethers_1.ethers.providers.JsonRpcProvider(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.url);
+    const provider = new ethers_1.JsonRpcProvider(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.url);
     const erc20Contract = new ethers_1.ethers.Contract(params.token.hash, bs_ethereum_1.ERC20_ABI, provider);
     const allowance = await erc20Contract.allowance(params.account.address, _a.BRIDGE_SCRIPT_HASH);
     const allowanceNumber = new blockchain_service_1.BSBigUnitAmount(allowance.toString(), this.neoToken.decimals);
     // We are using 0 as the decimals because the NEO token in Neo3 has 0 decimals
     const fixedAmount = new blockchain_service_1.BSBigHumanAmount(params.amount, 0).toFormatted();
-    const amount = new blockchain_service_1.BSBigHumanAmount(fixedAmount, params.token.decimals).toUnit().toString();
+    const amount = new blockchain_service_1.BSBigHumanAmount(fixedAmount, params.token.decimals).toUnit().toFixed();
     if (allowanceNumber.isGreaterThanOrEqualTo(amount)) {
         return null;
     }
-    return await erc20Contract.populateTransaction.approve(_a.BRIDGE_SCRIPT_HASH, amount);
+    return await erc20Contract.approve.populateTransaction(_a.BRIDGE_SCRIPT_HASH, amount);
 };
 Neo3NeoXBridgeService.BRIDGE_SCRIPT_HASH = '0x1212000000000000000000000000000000000004';
 Neo3NeoXBridgeService.BRIDGE_BASE_CONFIRMATION_URL = 'https://xexplorer.neo.org:8877/api/v1/transactions/deposits';

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

@@ -12,7 +12,7 @@ class GhostMarketNDSNeoX extends blockchain_service_1.GhostMarketNDS {
         try {
             if (!collectionHash)
                 return false;
-            const provider = new ethers_1.ethers.providers.JsonRpcProvider(this._service.network.url);
+            const provider = new ethers_1.JsonRpcProvider(this._service.network.url);
             const contract = new ethers_1.ethers.Contract(collectionHash, bs_ethereum_1.ERC20_ABI, provider);
             const response = await contract.balanceOf(address);
             if (!response)

package/dist/services/wallet-connect/WalletConnectServiceNeoX.d.ts

@@ -2,9 +2,11 @@ import { type TWalletConnectEthereumHandlers, WalletConnectServiceEthereum } fro
 import type { IBSNeoX, TBSNeoXName, TBSNeoXNetworkId, TWalletConnectServiceNeoxMethod } from '../../types';
 import z from 'zod';
 declare const getCachedTransactionParamsSchema: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+declare const getNonceParamsSchema: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
 type TWalletConnectNeoXHandlers = TWalletConnectEthereumHandlers & {
     eth_getTransactionCount: unknown;
     eth_getCachedTransaction: z.infer<typeof getCachedTransactionParamsSchema>;
+    eth_getNonce: z.infer<typeof getNonceParamsSchema>;
 };
 export declare class WalletConnectServiceNeoX extends WalletConnectServiceEthereum<TBSNeoXName, TBSNeoXNetworkId, TWalletConnectServiceNeoxMethod, TWalletConnectNeoXHandlers> {
     #private;

package/dist/services/wallet-connect/WalletConnectServiceNeoX.js

@@ -7,7 +7,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _WalletConnectServiceNeoX_getTransactionCountHandler, _WalletConnectServiceNeoX_getCachedTransactionHandler, _WalletConnectServiceNeoX_sendTransactionHandler;
+var _WalletConnectServiceNeoX_getTransactionCountHandler, _WalletConnectServiceNeoX_getCachedTransactionHandler, _WalletConnectServiceNeoX_getNonce, _WalletConnectServiceNeoX_sendTransactionHandler;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WalletConnectServiceNeoX = void 0;
 const blockchain_service_1 = require("@cityofzion/blockchain-service");
@@ -17,24 +17,25 @@ const viem_1 = require("viem");
 const axios_1 = __importDefault(require("axios"));
 const zod_1 = __importDefault(require("zod"));
 const getCachedTransactionParamsSchema = zod_1.default.tuple([zod_1.default.string(), zod_1.default.string()]);
+const getNonceParamsSchema = zod_1.default.union([zod_1.default.string(), zod_1.default.number()]).optional();
 class WalletConnectServiceNeoX extends bs_ethereum_1.WalletConnectServiceEthereum {
     constructor(service) {
         super(service);
         _WalletConnectServiceNeoX_getTransactionCountHandler.set(this, {
             validate: async () => { },
             process: async (args) => {
-                const wallet = await this._service._generateSigner(args.account);
-                const provider = new ethers_1.ethers.providers.JsonRpcProvider(this._service.network.url);
+                const wallet = await this._service._getSigner(args.account);
+                const provider = new ethers_1.JsonRpcProvider(this._service.network.url);
                 const connectedWallet = wallet.connect(provider);
-                return await connectedWallet.getTransactionCount('pending');
+                return await connectedWallet.getNonce('pending');
             },
         });
         _WalletConnectServiceNeoX_getCachedTransactionHandler.set(this, {
             validate: async (params) => await getCachedTransactionParamsSchema.parseAsync(params),
             process: async (args) => {
                 const url = this._service.network.url;
-                const wallet = await this._service._generateSigner(args.account);
-                const provider = new ethers_1.ethers.providers.JsonRpcProvider(url);
+                const wallet = await this._service._getSigner(args.account);
+                const provider = new ethers_1.JsonRpcProvider(url);
                 const connectedWallet = wallet.connect(provider);
                 const nonce = args.params[0];
                 const signature = await connectedWallet.signMessage(nonce.toString());
@@ -49,27 +50,37 @@ class WalletConnectServiceNeoX extends bs_ethereum_1.WalletConnectServiceEthereu
                 return cachedTransactionResponse.data.result;
             },
         });
+        _WalletConnectServiceNeoX_getNonce.set(this, {
+            validate: async (params) => await getNonceParamsSchema.parseAsync(params),
+            process: async (args) => {
+                const wallet = await this._service._getSigner(args.account);
+                return await wallet.getNonce(args.params || 'pending');
+            },
+        });
         _WalletConnectServiceNeoX_sendTransactionHandler.set(this, {
             validate: async (params) => await this._sendTransactionHandler.validate(params),
             process: async (args) => {
                 const { transaction, connectedWallet } = await this._resolveTransactionParams(args);
-                const [response, error] = await blockchain_service_1.BSUtilsHelper.tryCatch(() => connectedWallet.sendTransaction(transaction));
-                const transactionHash = response?.hash || error?.returnedHash;
+                const provider = new ethers_1.JsonRpcProvider(this._service.network.url);
+                const populatedTransaction = await connectedWallet.populateTransaction(transaction);
+                const signedTransaction = await connectedWallet.signTransaction(populatedTransaction);
+                const transactionHash = await provider.send('eth_sendRawTransaction', [signedTransaction]);
                 if (!transactionHash) {
-                    throw error || new blockchain_service_1.BSError('Transaction error', 'TRANSACTION_ERROR');
+                    throw new blockchain_service_1.BSError('Transaction error', 'TRANSACTION_ERROR');
                 }
                 return transactionHash;
             },
         });
-        this.supportedMethods.push('eth_getTransactionCount', 'eth_getCachedTransaction');
-        this.autoApproveMethods.push('eth_getTransactionCount', 'eth_getCachedTransaction');
+        this.supportedMethods.push('eth_getTransactionCount', 'eth_getCachedTransaction', 'eth_getNonce');
+        this.autoApproveMethods.push('eth_getTransactionCount', 'eth_getCachedTransaction', 'eth_getNonce');
         this.handlers = {
             ...this.handlers,
             eth_getTransactionCount: __classPrivateFieldGet(this, _WalletConnectServiceNeoX_getTransactionCountHandler, "f"),
             eth_getCachedTransaction: __classPrivateFieldGet(this, _WalletConnectServiceNeoX_getCachedTransactionHandler, "f"),
+            eth_getNonce: __classPrivateFieldGet(this, _WalletConnectServiceNeoX_getNonce, "f"),
             eth_sendTransaction: __classPrivateFieldGet(this, _WalletConnectServiceNeoX_sendTransactionHandler, "f"),
         };
     }
 }
 exports.WalletConnectServiceNeoX = WalletConnectServiceNeoX;
-_WalletConnectServiceNeoX_getTransactionCountHandler = new WeakMap(), _WalletConnectServiceNeoX_getCachedTransactionHandler = new WeakMap(), _WalletConnectServiceNeoX_sendTransactionHandler = new WeakMap();
+_WalletConnectServiceNeoX_getTransactionCountHandler = new WeakMap(), _WalletConnectServiceNeoX_getCachedTransactionHandler = new WeakMap(), _WalletConnectServiceNeoX_getNonce = new WeakMap(), _WalletConnectServiceNeoX_sendTransactionHandler = new WeakMap();

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 import type { BSBigUnitAmount, IBSWithNeo3NeoXBridge, TBSNetworkId } from '@cityofzion/blockchain-service';
 import { ERC20_ABI, IBSEthereum, type TWalletConnectServiceEthereumMethod } from '@cityofzion/bs-ethereum';
-import { ethers, Signer } from 'ethers';
+import { Signer, type TransactionRequest } from 'ethers';
 import type { Neo3NeoXBridgeService } from './services/neo3-neox-bridge/Neo3NeoXBridgeService';
 export type TBSNeoXNetworkId = TBSNetworkId<'47763' | '12227332'>;
 export type TBSNeoXName = 'neox';
@@ -94,10 +94,10 @@ export type TNeo3NeoXBridgeServiceGetTransactionByNonceApiReponse = {
 export type TSendTransactionParams = {
     signer: Signer;
     gasPriceBn: BSBigUnitAmount;
-    transactionParams: ethers.utils.Deferrable<ethers.providers.TransactionRequest>;
+    transactionParams: TransactionRequest;
 };
 export type TSendTransactionResponse = {
     transactionHash: string;
     fee: string;
 };
-export type TWalletConnectServiceNeoxMethod = TWalletConnectServiceEthereumMethod | 'eth_getTransactionCount' | 'eth_getCachedTransaction';
+export type TWalletConnectServiceNeoxMethod = TWalletConnectServiceEthereumMethod | 'eth_getTransactionCount' | 'eth_getCachedTransaction' | 'eth_getNonce';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-neox",
-  "version": "3.1.16",
+  "version": "3.1.18",
   "repository": "https://github.com/CityOfZion/blockchain-services",
   "license": "GPL-3.0-only",
   "author": "Coz",
@@ -11,23 +11,24 @@
   ],
   "dependencies": {
     "@cityofzion/dora-ts": "0.6.2",
-    "axios": "~1.15.0",
-    "ethers": "~5.7.2",
+    "axios": "1.16.0",
+    "ethers": "6.16.0",
     "neox-tpke": "~1.0.5",
-    "viem": "~2.38.5",
-    "zod": "~4.3.6",
-    "@cityofzion/bs-ethereum": "3.1.16",
-    "@cityofzion/bs-neo3": "3.1.16",
-    "@cityofzion/blockchain-service": "3.1.16"
+    "viem": "~2.48.8",
+    "zod": "~4.4.3",
+    "@cityofzion/bs-neo3": "3.1.18",
+    "@cityofzion/bs-ethereum": "3.1.18",
+    "@cityofzion/blockchain-service": "3.1.18"
   },
   "devDependencies": {
-    "@ledgerhq/hw-transport": "~6.32.0",
-    "@ledgerhq/hw-transport-node-hid": "~6.30.0",
+    "@ledgerhq/hw-transport": "6.35.1",
+    "@ledgerhq/hw-transport-node-hid": "~6.33.1",
+    "@types/node": "~25.6.0",
     "date-fns": "~4.1.0",
-    "dotenv": "~17.3.1",
-    "eslint": "~9.37.0",
-    "typescript": "~5.9.2",
-    "vitest": "~4.0.18"
+    "dotenv": "~17.4.2",
+    "eslint": "~10.3.0",
+    "typescript": "~6.0.3",
+    "vitest": "~4.1.5"
   },
   "scripts": {
     "build": "rm -rf ./dist && rm -f *.tgz && npm run typecheck && tsc --project tsconfig.build.json",