@cityofzion/bs-neox 3.1.17 → 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/services/blockchain-data/BlockscoutBDSNeoX.js

@@ -150,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');

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

@@ -43,7 +43,7 @@ class Neo3NeoXBridgeService {
     }
     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
@@ -82,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();
@@ -106,17 +106,18 @@ 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().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 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 });
         }
@@ -128,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().toFixed();
-            const populatedTransactionParams = await bridgeContract.populateTransaction.withdrawToken(params.token.hash, to, amount);
+            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 });
@@ -147,11 +148,12 @@ 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(async () => {
-            const BridgeInterface = new ethers_1.ethers.utils.Interface(bridge_1.BRIDGE_ABI);
+            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) });
-                    return parsedLog.args.nonce ? parsedLog.args.nonce.toString() : undefined;
+                    const nonce = parsedLog?.args?.nonce;
+                    return nonce !== undefined && nonce !== null ? nonce.toString() : undefined;
                 });
                 if (parsedNonce)
                     return parsedNonce;
@@ -192,7 +194,7 @@ 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);
@@ -202,7 +204,7 @@ _a = Neo3NeoXBridgeService, _Neo3NeoXBridgeService_service = new WeakMap(), _Neo
     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.17",
+  "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/blockchain-service": "3.1.17",
-    "@cityofzion/bs-neo3": "3.1.17",
-    "@cityofzion/bs-ethereum": "3.1.17"
+    "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",