@cityofzion/bs-ethereum 3.1.10 → 3.1.11

package/dist/BSEthereum.d.ts

@@ -1,8 +1,9 @@
-import { type TBSAccount, type TTransferIntent, type TBSToken, type TTransferParams, type TGetLedgerTransport, type ITokenService, type TBSNetwork, type IBlockchainDataService, type IExchangeDataService, type INftDataService, type IExplorerService, type TPingNetworkResponse, type IWalletConnectService, type IFullTransactionsDataService, type TTransactionDefault, type TBSNetworkId } from '@cityofzion/blockchain-service';
+import { type TBSAccount, type TTransferIntent, type TBSToken, type TTransferParams, type TGetLedgerTransport, type ITokenService, type TBSNetwork, type IBlockchainDataService, type IExchangeDataService, type INftDataService, type IExplorerService, type TPingNetworkResponse, type IFullTransactionsDataService, type TTransactionDefault, type TBSNetworkId, BSBigUnitAmount } from '@cityofzion/blockchain-service';
 import { ethers } from 'ethers';
 import { EthersLedgerServiceEthereum } from './services/ledger/EthersLedgerServiceEthereum';
 import type { IBSEthereum, TBSEthereumName, TBSEthereumNetworkId } from './types';
 import { TypedDataSigner } from '@ethersproject/abstract-signer';
+import { WalletConnectServiceEthereum } from './services/wallet-connect/WalletConnectServiceEthereum';
 export declare class BSEthereum<N extends string = TBSEthereumName, A extends TBSNetworkId = TBSEthereumNetworkId> implements IBSEthereum<N, A> {
     #private;
     readonly name: N;
@@ -22,13 +23,13 @@ export declare class BSEthereum<N extends string = TBSEthereumName, A extends TB
     nftDataService: INftDataService;
     explorerService: IExplorerService;
     tokenService: ITokenService;
-    walletConnectService: IWalletConnectService<N>;
+    walletConnectService: WalletConnectServiceEthereum<N, A>;
     fullTransactionsDataService: IFullTransactionsDataService<N>;
     constructor(name: N, network?: TBSNetwork<A>, getLedgerTransport?: TGetLedgerTransport<N>);
     _generateSigner(account: TBSAccount<N>): Promise<ethers.Signer & TypedDataSigner>;
     _buildTransferParams(intent: TTransferIntent): Promise<{
         transactionParams: ethers.utils.Deferrable<ethers.providers.TransactionRequest>;
-        gasPrice: ethers.BigNumber;
+        gasPriceBn: BSBigUnitAmount;
     }>;
     setNetwork(network: TBSNetwork<A>): void;
     pingNetwork(url: string): Promise<TPingNetworkResponse>;

package/dist/BSEthereum.js

@@ -47,7 +47,6 @@ const blockchain_service_1 = require("@cityofzion/blockchain-service");
 const ethers_1 = require("ethers");
 const ethersJsonWallets = __importStar(require("@ethersproject/json-wallets"));
 const ethersBytes = __importStar(require("@ethersproject/bytes"));
-const ethersBigNumber = __importStar(require("@ethersproject/bignumber"));
 const BSEthereumConstants_1 = require("./constants/BSEthereumConstants");
 const EthersLedgerServiceEthereum_1 = require("./services/ledger/EthersLedgerServiceEthereum");
 const BSEthereumHelper_1 = require("./helpers/BSEthereumHelper");
@@ -91,8 +90,9 @@ class BSEthereum {
     }
     async _buildTransferParams(intent) {
         const provider = new ethers_1.ethers.providers.JsonRpcProvider(this.network.url);
-        const amount = ethersBigNumber.parseFixed(intent.amount, intent.token.decimals);
+        const amount = new blockchain_service_1.BSBigHumanAmount(intent.amount, intent.token.decimals).toUnit().toString();
         const gasPrice = await provider.getGasPrice();
+        const gasPriceBn = new blockchain_service_1.BSBigUnitAmount(gasPrice.toString(), BSEthereumConstants_1.BSEthereumConstants.DEFAULT_DECIMALS);
         let transactionParams = {
             type: 2,
         };
@@ -113,7 +113,7 @@ class BSEthereum {
         }
         return {
             transactionParams,
-            gasPrice,
+            gasPriceBn,
         };
     }
     setNetwork(network) {
@@ -146,7 +146,7 @@ class BSEthereum {
         return {
             latency,
             url,
-            height: ethers_1.ethers.BigNumber.from(response.data.result).toNumber(),
+            height: blockchain_service_1.BSBigNumber.ensureNumber(response.data.result),
         };
     }
     validateAddress(address) {
@@ -220,21 +220,22 @@ class BSEthereum {
         let nonce = await signer.getTransactionCount('pending');
         for (const intent of intents) {
             try {
-                const { transactionParams, gasPrice } = await this._buildTransferParams(intent);
-                let gasLimit;
+                const { transactionParams, gasPriceBn } = await this._buildTransferParams(intent);
                 transactionParams.nonce = nonce++;
+                let gasLimitBn;
                 try {
-                    gasLimit = await signer.estimateGas(transactionParams);
+                    const estimatedGas = await signer.estimateGas(transactionParams);
+                    gasLimitBn = new blockchain_service_1.BSBigUnitAmount(estimatedGas.toString(), BSEthereumConstants_1.BSEthereumConstants.DEFAULT_DECIMALS);
                 }
                 catch {
-                    gasLimit = BSEthereumConstants_1.BSEthereumConstants.DEFAULT_GAS_LIMIT;
+                    gasLimitBn = BSEthereumConstants_1.BSEthereumConstants.DEFAULT_GAS_LIMIT_BN;
                 }
-                const fee = ethers_1.ethers.utils.formatEther(gasPrice.mul(gasLimit));
+                const fee = gasPriceBn.multipliedBy(gasLimitBn).toHuman().toFormatted();
                 const transaction = await signer.sendTransaction({
                     ...transactionParams,
-                    gasLimit,
-                    maxPriorityFeePerGas: gasPrice,
-                    maxFeePerGas: gasPrice,
+                    gasLimit: gasLimitBn.toString(),
+                    maxPriorityFeePerGas: gasPriceBn.toString(),
+                    maxFeePerGas: gasPriceBn.toString(),
                 });
                 const txId = transaction.hash;
                 if (txId) {
@@ -277,14 +278,14 @@ class BSEthereum {
     }
     async calculateTransferFee(params) {
         const signer = await this._generateSigner(params.senderAccount);
-        let fee = ethers_1.ethers.utils.parseEther('0');
+        let feeBn = new blockchain_service_1.BSBigUnitAmount(0, BSEthereumConstants_1.BSEthereumConstants.DEFAULT_DECIMALS);
         for (const intent of params.intents) {
-            const { gasPrice, transactionParams } = await this._buildTransferParams(intent);
-            const estimated = await signer.estimateGas(transactionParams);
-            const intentFee = gasPrice.mul(estimated);
-            fee = fee.add(intentFee);
+            const { gasPriceBn, transactionParams } = await this._buildTransferParams(intent);
+            const estimatedGas = await signer.estimateGas(transactionParams);
+            const intentFeeBn = gasPriceBn.multipliedBy(estimatedGas.toString());
+            feeBn = feeBn.plus(intentFeeBn);
         }
-        return ethers_1.ethers.utils.formatEther(fee);
+        return feeBn.toHuman().toFormatted();
     }
     async resolveNameServiceDomain(domainName) {
         const provider = new ethers_1.ethers.providers.JsonRpcProvider(this.network.url);

package/dist/constants/BSEthereumConstants.d.ts

@@ -1,8 +1,8 @@
-import type { TBSNetwork } from '@cityofzion/blockchain-service';
+import { BSBigUnitAmount, type TBSNetwork } from '@cityofzion/blockchain-service';
 import type { TBSEthereumNetworkId, TBSEthereumName } from '../types';
 export declare class BSEthereumConstants {
     static readonly DEFAULT_DECIMALS = 18;
-    static readonly DEFAULT_GAS_LIMIT = 21000;
+    static readonly DEFAULT_GAS_LIMIT_BN: BSBigUnitAmount;
     static readonly DEFAULT_BIP_DERIVATION_PATH = "m/44'/60'/0'/0/?";
     static readonly NATIVE_SYMBOL_BY_NETWORK_ID: Record<TBSEthereumNetworkId, string>;
     static readonly NATIVE_WRAPPED_HASH_BY_NETWORK_ID: Partial<Record<TBSEthereumNetworkId, string>>;

package/dist/constants/BSEthereumConstants.js

@@ -2,12 +2,13 @@
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSEthereumConstants = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
 class BSEthereumConstants {
 }
 exports.BSEthereumConstants = BSEthereumConstants;
 _a = BSEthereumConstants;
 BSEthereumConstants.DEFAULT_DECIMALS = 18;
-BSEthereumConstants.DEFAULT_GAS_LIMIT = 0x5208;
+BSEthereumConstants.DEFAULT_GAS_LIMIT_BN = new blockchain_service_1.BSBigUnitAmount(0x5208, _a.DEFAULT_DECIMALS);
 BSEthereumConstants.DEFAULT_BIP_DERIVATION_PATH = "m/44'/60'/0'/0/?";
 BSEthereumConstants.NATIVE_SYMBOL_BY_NETWORK_ID = {
     '1': 'ETH',

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

@@ -47,9 +47,7 @@ class MoralisBDSEthereum extends RpcBDSEthereum_1.RpcBDSEthereum {
         const nativeToken = BSEthereumHelper_1.BSEthereumHelper.getNativeAsset(this._service.network);
         const balances = [
             {
-                amount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(nativeBalance, nativeToken.decimals), {
-                    decimals: nativeToken.decimals,
-                }),
+                amount: new blockchain_service_1.BSBigUnitAmount(nativeBalance, nativeToken.decimals).toHuman().toFormatted(),
                 token: nativeToken,
             },
         ];
@@ -58,9 +56,7 @@ class MoralisBDSEthereum extends RpcBDSEthereum_1.RpcBDSEthereum {
             if (balance.possible_spam || !balance.decimals || !balance.token_address || !balance.symbol)
                 return;
             balances.push({
-                amount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(balance.balance, balance.decimals), {
-                    decimals: balance.decimals,
-                }),
+                amount: new blockchain_service_1.BSBigUnitAmount(balance.balance, balance.decimals).toHuman().toFormatted(),
                 token: this._service.tokenService.normalizeToken({
                     decimals: balance.decimals,
                     hash: balance.token_address,
@@ -108,9 +104,7 @@ class MoralisBDSEthereum extends RpcBDSEthereum_1.RpcBDSEthereum {
             const toUrl = this._service.explorerService.buildAddressUrl(data.to_address);
             events.push({
                 eventType: 'token',
-                amount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(data.value, nativeToken.decimals), {
-                    decimals: nativeToken.decimals,
-                }),
+                amount: new blockchain_service_1.BSBigUnitAmount(data.value, nativeToken.decimals).toHuman().toFormatted(),
                 methodName: 'transfer',
                 from: data.from_address,
                 fromUrl,
@@ -138,9 +132,7 @@ class MoralisBDSEthereum extends RpcBDSEthereum_1.RpcBDSEthereum {
                     const token = await this.getTokenInfo(contractHash);
                     events.push({
                         eventType: 'token',
-                        amount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(amount, token.decimals), {
-                            decimals: token.decimals,
-                        }),
+                        amount: new blockchain_service_1.BSBigUnitAmount(amount, token.decimals).toHuman().toFormatted(),
                         methodName: 'transfer',
                         from,
                         fromUrl,
@@ -174,9 +166,7 @@ class MoralisBDSEthereum extends RpcBDSEthereum_1.RpcBDSEthereum {
             txIdUrl: this._service.explorerService.buildTransactionUrl(hash),
             block: Number(data.block_number),
             date: new Date(data.block_timestamp).toJSON(),
-            networkFeeAmount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromNumber(data.transaction_fee), {
-                decimals: this._service.feeToken.decimals,
-            }),
+            networkFeeAmount: new blockchain_service_1.BSBigHumanAmount(data.transaction_fee, this._service.feeToken.decimals).toFormatted(),
             view: 'default',
             events,
         };
@@ -200,9 +190,7 @@ class MoralisBDSEthereum extends RpcBDSEthereum_1.RpcBDSEthereum {
                 const toUrl = this._service.explorerService.buildAddressUrl(transfer.to_address);
                 events.push({
                     eventType: 'token',
-                    amount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(transfer.value, nativeAsset.decimals), {
-                        decimals: nativeAsset.decimals,
-                    }),
+                    amount: new blockchain_service_1.BSBigUnitAmount(transfer.value, nativeAsset.decimals).toHuman().toFormatted(),
                     methodName: 'transfer',
                     from: transfer.from_address,
                     fromUrl,
@@ -226,9 +214,7 @@ class MoralisBDSEthereum extends RpcBDSEthereum_1.RpcBDSEthereum {
                 });
                 events.push({
                     eventType: 'token',
-                    amount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(transfer.value, tokenDecimals), {
-                        decimals: tokenDecimals,
-                    }),
+                    amount: new blockchain_service_1.BSBigUnitAmount(transfer.value, tokenDecimals).toHuman().toFormatted(),
                     methodName: 'transfer',
                     from: transfer.from_address,
                     fromUrl,
@@ -263,9 +249,7 @@ class MoralisBDSEthereum extends RpcBDSEthereum_1.RpcBDSEthereum {
                 txIdUrl: this._service.explorerService.buildTransactionUrl(item.hash),
                 block: Number(item.block_number),
                 date: new Date(item.block_timestamp).toJSON(),
-                networkFeeAmount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromNumber(item.transaction_fee), {
-                    decimals: this._service.feeToken.decimals,
-                }),
+                networkFeeAmount: new blockchain_service_1.BSBigHumanAmount(item.transaction_fee, this._service.feeToken.decimals).toFormatted(),
                 view: 'default',
                 events,
             });

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

@@ -45,16 +45,12 @@ class RpcBDSEthereum {
             txIdUrl: this._service.explorerService.buildTransactionUrl(hash),
             block: receipt.blockNumber,
             date: new Date(timestamp).toJSON(),
-            networkFeeAmount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(fee.toString(), this._service.feeToken.decimals), {
-                decimals: this._service.feeToken.decimals,
-            }),
+            networkFeeAmount: new blockchain_service_1.BSBigUnitAmount(fee.toString(), token.decimals).toHuman().toFormatted(),
             view: 'default',
             events: [
                 {
                     eventType: 'token',
-                    amount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(transaction.value.toString(), token.decimals), {
-                        decimals: token.decimals,
-                    }),
+                    amount: new blockchain_service_1.BSBigUnitAmount(transaction.value.toString(), token.decimals).toHuman().toFormatted(),
                     methodName: 'transfer',
                     from: transaction.from,
                     fromUrl,
@@ -96,9 +92,7 @@ class RpcBDSEthereum {
         const token = BSEthereumHelper_1.BSEthereumHelper.getNativeAsset(this._service.network);
         return [
             {
-                amount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(balance.toString(), token.decimals), {
-                    decimals: token.decimals,
-                }),
+                amount: new blockchain_service_1.BSBigUnitAmount(balance.toString(), token.decimals).toHuman().toFormatted(),
                 token,
             },
         ];

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

@@ -49,7 +49,7 @@ class MoralisFullTransactionsDataServiceEthereum {
                 block: item.block,
                 date: item.date,
                 networkFeeAmount: networkFeeAmount
-                    ? blockchain_service_1.BSBigNumberHelper.format(networkFeeAmount, { decimals: nativeToken.decimals })
+                    ? new blockchain_service_1.BSBigHumanAmount(networkFeeAmount, nativeToken.decimals).toFormatted()
                     : undefined,
                 view: 'default',
                 events: [],
@@ -82,7 +82,7 @@ class MoralisFullTransactionsDataServiceEthereum {
                 newItem.events.splice(eventIndex, 0, {
                     eventType: 'token',
                     amount: event.amount
-                        ? blockchain_service_1.BSBigNumberHelper.format(event.amount, { decimals: token?.decimals ?? event.tokenDecimals })
+                        ? new blockchain_service_1.BSBigHumanAmount(event.amount, token?.decimals ?? event.tokenDecimals).toFormatted()
                         : undefined,
                     methodName,
                     from,

package/dist/services/ledger/EthersLedgerServiceEthereum.js

@@ -105,7 +105,7 @@ class EthersLedgerSigner extends ethers_1.Signer {
             const signature = await __classPrivateFieldGet(this, _EthersLedgerSigner_ledgerApp, "f").signTransaction(__classPrivateFieldGet(this, _EthersLedgerSigner_bipPath, "f"), serializedUnsignedTransaction, resolution);
             __classPrivateFieldGet(this, _EthersLedgerSigner_emitter, "f")?.emit('getSignatureEnd');
             return ethers_1.ethers.utils.serializeTransaction(tx, {
-                v: ethers_1.ethers.BigNumber.from('0x' + signature.v).toNumber(),
+                v: blockchain_service_1.BSBigNumber.ensureNumber('0x' + signature.v),
                 r: '0x' + signature.r,
                 s: '0x' + signature.s,
             });

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

@@ -0,0 +1,8 @@
+import { GhostMarketNDS, type TBSNetworkId, type THasTokenParams } from '@cityofzion/blockchain-service';
+import type { IBSEthereum, TBSEthereumNetworkId } from '../../types';
+export declare class GhostMarketNDSEthereum<N extends string, A extends TBSNetworkId> extends GhostMarketNDS<N, A, IBSEthereum<N, A>> {
+    static readonly CHAIN_BY_NETWORK_ID: Partial<Record<TBSEthereumNetworkId, string>>;
+    constructor(service: IBSEthereum<N, A>);
+    hasToken({ address, collectionHash }: THasTokenParams): Promise<boolean>;
+    getChain(): string;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GhostMarketNDSEthereum = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
+const ethers_1 = require("ethers");
+const ERC20_1 = require("../../assets/abis/ERC20");
+class GhostMarketNDSEthereum extends blockchain_service_1.GhostMarketNDS {
+    constructor(service) {
+        super(service);
+    }
+    async hasToken({ address, collectionHash }) {
+        try {
+            if (!collectionHash)
+                return false;
+            const provider = new ethers_1.ethers.providers.JsonRpcProvider(this._service.network.url);
+            const contract = new ethers_1.ethers.Contract(collectionHash, ERC20_1.ERC20_ABI, provider);
+            const response = await contract.balanceOf(address);
+            if (!response)
+                return false;
+            const parsedResponse = new blockchain_service_1.BSBigUnitAmount(response.toString(), 0);
+            return parsedResponse.isGreaterThan(0);
+        }
+        catch {
+            return false;
+        }
+    }
+    getChain() {
+        const chain = GhostMarketNDSEthereum.CHAIN_BY_NETWORK_ID[this._service.network.id];
+        if (!chain)
+            throw new Error('Network not supported');
+        return chain;
+    }
+}
+exports.GhostMarketNDSEthereum = GhostMarketNDSEthereum;
+GhostMarketNDSEthereum.CHAIN_BY_NETWORK_ID = {
+    '1': 'eth',
+    '56': 'bsc',
+    '137': 'polygon',
+    '43114': 'avalanche',
+    '8453': 'base',
+};

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

@@ -1,36 +1,89 @@
-import type { IWalletConnectService, TBSNetworkId, TWalletConnectServiceRequestMethodParams } from '@cityofzion/blockchain-service';
-import type { IBSEthereum } from '../../types';
+import { type IWalletConnectService, type TBSNetworkId, type TWalletConnectServiceHandlers, type TWalletConnectServiceMethodHandler, type TWalletConnectServiceRequestMethodParams } from '@cityofzion/blockchain-service';
+import type { IBSEthereum, TWalletConnectServiceEthereumMethod } from '../../types';
+import { z } from 'zod';
 import { ethers } from 'ethers';
-export declare class WalletConnectServiceEthereum<N extends string, A extends TBSNetworkId> implements IWalletConnectService<N> {
+declare const personalSignParamsSchema: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+declare const signTypedDataParamsSchema: z.ZodTuple<[z.ZodString, z.ZodUnion<readonly [z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<any, string>>, z.ZodObject<{
+    primaryType: z.ZodString;
+    types: z.ZodRecord<z.ZodString, z.ZodAny>;
+    domain: z.ZodObject<{
+        chainId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt, z.ZodString]>>;
+        name: z.ZodOptional<z.ZodString>;
+        salt: z.ZodOptional<z.ZodString>;
+        verifyingContract: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    message: z.ZodRecord<z.ZodString, z.ZodAny>;
+    account: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>, z.ZodObject<{
+    primaryType: z.ZodString;
+    types: z.ZodRecord<z.ZodString, z.ZodAny>;
+    domain: z.ZodObject<{
+        chainId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt, z.ZodString]>>;
+        name: z.ZodOptional<z.ZodString>;
+        salt: z.ZodOptional<z.ZodString>;
+        verifyingContract: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    message: z.ZodRecord<z.ZodString, z.ZodAny>;
+    account: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>], null>;
+declare const signTransactionParamsSchema: z.ZodTuple<[z.ZodObject<{
+    to: z.ZodOptional<z.ZodString>;
+    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    data: z.ZodOptional<z.ZodString>;
+    gas: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    maxPriorityFeePerGas: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    maxFeePerGas: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    nonce: z.ZodOptional<z.ZodNumber>;
+    chainId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    gasLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    type: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    gasPrice: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+}, z.core.$strip>], null>;
+declare const sendRawTransactionParamsSchema: z.ZodTuple<[z.ZodString], null>;
+export type TWalletConnectEthereumHandlers = {
+    personal_sign: z.infer<typeof personalSignParamsSchema>;
+    eth_sign: z.infer<typeof personalSignParamsSchema>;
+    eth_signTypedData: z.infer<typeof signTypedDataParamsSchema>;
+    eth_signTypedData_v3: z.infer<typeof signTypedDataParamsSchema>;
+    eth_signTypedData_v4: z.infer<typeof signTypedDataParamsSchema>;
+    eth_signTransaction: z.infer<typeof signTransactionParamsSchema>;
+    eth_sendTransaction: z.infer<typeof signTransactionParamsSchema>;
+    eth_sendRawTransaction: z.infer<typeof sendRawTransactionParamsSchema>;
+    eth_call: z.infer<typeof signTransactionParamsSchema>;
+    eth_requestAccounts: unknown;
+    eth_switchEthereumChain: unknown;
+    eth_addEthereumChain: unknown;
+    wallet_switchEthereumChain: unknown;
+    wallet_addEthereumChain: unknown;
+    wallet_getPermissions: unknown;
+    wallet_requestPermissions: unknown;
+};
+export declare class WalletConnectServiceEthereum<N extends string, A extends TBSNetworkId, M extends string = TWalletConnectServiceEthereumMethod, H extends Record<string, any> = TWalletConnectEthereumHandlers> implements IWalletConnectService<N, M> {
     #private;
     readonly namespace: string;
     readonly chain: string;
-    readonly supportedMethods: string[];
+    supportedMethods: M[];
     readonly supportedEvents: string[];
-    readonly calculableMethods: string[];
-    readonly autoApproveMethods: string[];
+    calculableMethods: M[];
+    autoApproveMethods: M[];
     protected readonly _service: IBSEthereum<N, A>;
+    handlers: TWalletConnectServiceHandlers<N, H>;
     constructor(service: IBSEthereum<N, A>);
-    protected _resolveParams(args: TWalletConnectServiceRequestMethodParams<N>): Promise<{
-        wallet: ethers.Signer & import("@ethersproject/abstract-signer").TypedDataSigner;
-        provider: ethers.providers.JsonRpcProvider;
-        param: any;
+    _personalSignHandler: TWalletConnectServiceMethodHandler<N, z.infer<typeof personalSignParamsSchema>>;
+    _signTypedDataHandlers: TWalletConnectServiceMethodHandler<N, z.infer<typeof signTypedDataParamsSchema>>;
+    _signTransactionHandler: TWalletConnectServiceMethodHandler<N, z.infer<typeof signTransactionParamsSchema>>;
+    _sendTransactionHandler: TWalletConnectServiceMethodHandler<N, z.infer<typeof signTransactionParamsSchema>>;
+    _sendRawTransactionHandler: TWalletConnectServiceMethodHandler<N, z.infer<typeof sendRawTransactionParamsSchema>>;
+    _callHandler: TWalletConnectServiceMethodHandler<N, z.infer<typeof signTransactionParamsSchema>>;
+    _requestAccount: TWalletConnectServiceMethodHandler<N>;
+    _nullHandlers: TWalletConnectServiceMethodHandler<N>;
+    _emptyHandlers: TWalletConnectServiceMethodHandler<N>;
+    _resolveTransactionParams(args: TWalletConnectServiceRequestMethodParams<N, z.infer<typeof signTransactionParamsSchema>>): Promise<{
+        connectedWallet: ethers.Signer;
+        transaction: ethers.providers.TransactionRequest;
     }>;
-    personal_sign(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
-    eth_sign(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
-    eth_signTransaction(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
-    eth_signTypedData(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
-    eth_signTypedData_v3(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
-    eth_signTypedData_v4(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
-    eth_sendTransaction(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
-    eth_call(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
-    eth_requestAccounts(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string[]>;
-    eth_sendRawTransaction(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
-    wallet_switchEthereumChain(): Promise<string>;
-    eth_addEthereumChain(): Promise<string>;
-    eth_switchEthereumChain(): Promise<string>;
-    wallet_getPermissions(): Promise<any[]>;
-    wallet_requestPermissions(): Promise<any[]>;
-    wallet_addEthereumChain(): Promise<string>;
     calculateRequestFee(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
 }
+export {};

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

@@ -7,168 +7,244 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _WalletConnectServiceEthereum_instances, _WalletConnectServiceEthereum_convertHexToUtf8;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WalletConnectServiceEthereum = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
+const zod_1 = require("zod");
 const ethers_1 = require("ethers");
 const BSEthereumConstants_1 = require("../../constants/BSEthereumConstants");
+const utils_1 = require("ethers/lib/utils");
+const personalSignParamsSchema = zod_1.z.tuple([zod_1.z.string(), zod_1.z.string()]);
+const typedDataParamSchema = zod_1.z.object({
+    primaryType: zod_1.z.string(),
+    types: zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
+    domain: zod_1.z.object({
+        chainId: zod_1.z.union([zod_1.z.number(), zod_1.z.bigint(), zod_1.z.string()]).optional(),
+        name: zod_1.z.string().optional(),
+        salt: zod_1.z.string().optional(),
+        verifyingContract: zod_1.z.string().optional(),
+        version: zod_1.z.string().optional(),
+    }),
+    message: zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
+    account: zod_1.z.string().optional(),
+});
+const jsonStringifiedTypedDataParamSchema = zod_1.z
+    .string()
+    .transform((val, ctx) => {
+    try {
+        return JSON.parse(val);
+    }
+    catch {
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, message: 'Invalid JSON string' });
+        return zod_1.z.NEVER;
+    }
+})
+    .pipe(typedDataParamSchema);
+const signTypedDataParamsSchema = zod_1.z.tuple([
+    zod_1.z.string(),
+    zod_1.z.union([jsonStringifiedTypedDataParamSchema, typedDataParamSchema]),
+]);
+const signTransactionParamsSchema = zod_1.z.tuple([
+    zod_1.z.object({
+        to: zod_1.z.string().optional(),
+        value: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]).optional(),
+        data: zod_1.z.string().optional(),
+        gas: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]).optional(),
+        maxPriorityFeePerGas: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]).optional(),
+        maxFeePerGas: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]).optional(),
+        nonce: zod_1.z.number().optional(),
+        chainId: zod_1.z.union([zod_1.z.number(), zod_1.z.string()]).optional(),
+        gasLimit: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]).optional(),
+        type: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]).optional(),
+        gasPrice: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]).optional(),
+    }),
+]);
+const sendRawTransactionParamsSchema = zod_1.z.tuple([zod_1.z.string()]);
 class WalletConnectServiceEthereum {
     constructor(service) {
         _WalletConnectServiceEthereum_instances.add(this);
         this.namespace = 'eip155';
+        // prettier-ignore
         this.supportedMethods = [
-            'personal_sign',
-            'eth_sign',
-            'eth_signTransaction',
-            'eth_signTypedData',
-            'eth_signTypedData_v3',
-            'eth_signTypedData_v4',
-            'eth_sendTransaction',
-            'eth_call',
-            'eth_requestAccounts',
-            'eth_sendRawTransaction',
-            'eth_addEthereumChain',
-            'eth_switchEthereumChain',
-            'wallet_switchEthereumChain',
-            'wallet_getPermissions',
-            'wallet_requestPermissions',
-            'wallet_addEthereumChain',
+            'personal_sign', 'eth_sign', 'eth_signTransaction', 'eth_signTypedData',
+            'eth_signTypedData_v3', 'eth_signTypedData_v4', 'eth_sendTransaction', 'eth_call',
+            'eth_requestAccounts', 'eth_sendRawTransaction', 'eth_addEthereumChain', 'eth_switchEthereumChain',
+            'wallet_switchEthereumChain', 'wallet_getPermissions', 'wallet_requestPermissions', 'wallet_addEthereumChain',
         ];
         this.supportedEvents = ['chainChanged', 'accountsChanged', 'disconnect', 'connect'];
-        this.calculableMethods = ['eth_sendTransaction', 'eth_call', 'eth_sendRawTransaction'];
+        this.calculableMethods = ['eth_sendTransaction', 'eth_sendRawTransaction'];
+        // prettier-ignore
         this.autoApproveMethods = [
-            'eth_requestAccounts',
-            'eth_addEthereumChain',
-            'eth_switchEthereumChain',
-            'wallet_switchEthereumChain',
-            'wallet_getPermissions',
-            'wallet_requestPermissions',
-            'wallet_addEthereumChain',
+            'eth_requestAccounts', 'eth_addEthereumChain', 'eth_switchEthereumChain', 'wallet_switchEthereumChain',
+            'wallet_getPermissions', 'wallet_requestPermissions', 'wallet_addEthereumChain', 'eth_call',
         ];
+        this._personalSignHandler = {
+            validate: async (params) => await personalSignParamsSchema.parseAsync(params),
+            process: async (args) => {
+                const wallet = await this._service._generateSigner(args.account);
+                const convertedMessage = __classPrivateFieldGet(this, _WalletConnectServiceEthereum_instances, "m", _WalletConnectServiceEthereum_convertHexToUtf8).call(this, args.params[0]);
+                return await wallet.signMessage(convertedMessage);
+            },
+        };
+        this._signTypedDataHandlers = {
+            validate: async (params) => await signTypedDataParamsSchema.parseAsync(params),
+            process: async (args) => {
+                const wallet = await this._service._generateSigner(args.account);
+                const { domain, types, message } = args.params[1];
+                // https://github.com/ethers-io/ethers.js/issues/687#issuecomment-714069471
+                delete types?.EIP712Domain;
+                return await wallet._signTypedData(domain, types, message);
+            },
+        };
+        this._signTransactionHandler = {
+            validate: async (params) => await signTransactionParamsSchema.parseAsync(params),
+            process: async (args) => {
+                const { connectedWallet, transaction } = await this._resolveTransactionParams(args);
+                return await connectedWallet.signTransaction(transaction);
+            },
+        };
+        this._sendTransactionHandler = {
+            validate: async (params) => await signTransactionParamsSchema.parseAsync(params),
+            process: async (args) => {
+                const { transaction, connectedWallet } = await this._resolveTransactionParams(args);
+                const { hash } = await connectedWallet.sendTransaction(transaction);
+                return hash;
+            },
+        };
+        this._sendRawTransactionHandler = {
+            validate: async (params) => await sendRawTransactionParamsSchema.parseAsync(params),
+            process: async (args) => {
+                const provider = new ethers_1.ethers.providers.JsonRpcProvider(this._service.network.url);
+                const { hash } = await provider.sendTransaction(args.params[0]);
+                return hash;
+            },
+        };
+        this._callHandler = {
+            validate: async (params) => await signTransactionParamsSchema.parseAsync(params),
+            process: async (args) => {
+                const { transaction, connectedWallet } = await this._resolveTransactionParams(args);
+                return await connectedWallet.call(transaction);
+            },
+        };
+        this._requestAccount = {
+            validate: async () => { },
+            process: async (args) => {
+                const wallet = await this._service._generateSigner(args.account);
+                return [await wallet.getAddress()];
+            },
+        };
+        this._nullHandlers = {
+            validate: async () => { },
+            process: async () => {
+                return 'null';
+            },
+        };
+        this._emptyHandlers = {
+            validate: async () => { },
+            process: async () => {
+                return [];
+            },
+        };
         this._service = service;
         this.chain = `${this.namespace}:${this._service.network.id.toString()}`;
+        this.handlers = {
+            personal_sign: this._personalSignHandler,
+            eth_sign: this._personalSignHandler,
+            eth_signTypedData: this._signTypedDataHandlers,
+            eth_signTypedData_v3: this._signTypedDataHandlers,
+            eth_signTypedData_v4: this._signTypedDataHandlers,
+            eth_signTransaction: this._signTransactionHandler,
+            eth_sendTransaction: this._sendTransactionHandler,
+            eth_sendRawTransaction: this._sendRawTransactionHandler,
+            eth_call: this._callHandler,
+            eth_requestAccounts: this._requestAccount,
+            eth_switchEthereumChain: this._nullHandlers,
+            eth_addEthereumChain: this._nullHandlers,
+            wallet_switchEthereumChain: this._nullHandlers,
+            wallet_addEthereumChain: this._nullHandlers,
+            wallet_getPermissions: this._emptyHandlers,
+            wallet_requestPermissions: this._emptyHandlers,
+        };
     }
-    async _resolveParams(args) {
-        const param = args.params[0];
-        if (typeof param !== 'object') {
-            throw new Error('Invalid params');
-        }
-        const chainId = parseInt(param.chainId ?? this._service.network.id);
-        if (!isNaN(chainId))
-            param.chainId = chainId;
-        if (param.gas) {
-            param.gasLimit = param.gas;
-            delete param.gas;
+    async _resolveTransactionParams(args) {
+        const params = args.params[0];
+        const provider = new ethers_1.ethers.providers.JsonRpcProvider(this._service.network.url);
+        const wallet = await this._service._generateSigner(args.account);
+        const connectedWallet = wallet.connect(provider);
+        const transaction = {
+            to: params.to,
+            value: params.value,
+            data: params.data,
+        };
+        transaction.chainId = parseInt(params.chainId?.toString() ?? this._service.network.id);
+        transaction.nonce = params.nonce;
+        if (!transaction.nonce) {
+            transaction.nonce = await connectedWallet.getTransactionCount('pending');
         }
-        if (param.type && typeof param.type !== 'number') {
-            const typeAsNumber = parseInt(param.type);
-            if (!isNaN(typeAsNumber))
-                param.type = typeAsNumber;
+        if (params.type) {
+            const typeAsNumber = parseInt(params.type.toString());
+            if (!isNaN(typeAsNumber)) {
+                transaction.type = typeAsNumber;
+            }
         }
-        const provider = new ethers_1.ethers.providers.JsonRpcProvider(this._service.network.url);
-        const gasPrice = await provider.getGasPrice();
-        if (param.type === 2) {
-            param.maxPriorityFeePerGas = param.maxPriorityFeePerGas ?? gasPrice;
-            param.maxFeePerGas = param.maxFeePerGas ?? gasPrice;
+        if (transaction.type === 2) {
+            transaction.maxFeePerGas = params.maxFeePerGas;
+            transaction.maxPriorityFeePerGas = params.maxPriorityFeePerGas;
+            if (!transaction.maxFeePerGas || !transaction.maxPriorityFeePerGas) {
+                const feeData = await connectedWallet.getFeeData();
+                transaction.maxFeePerGas = transaction.maxFeePerGas ?? feeData.maxFeePerGas ?? undefined;
+                transaction.maxPriorityFeePerGas = transaction.maxPriorityFeePerGas ?? feeData.maxPriorityFeePerGas ?? undefined;
+            }
         }
         else {
-            param.gasPrice = param.gasPrice ?? gasPrice;
+            transaction.gasPrice = params.gasPrice?.toString();
+            if (!transaction.gasPrice) {
+                const gasPrice = await provider.getGasPrice();
+                transaction.gasPrice = gasPrice;
+            }
         }
-        const wallet = await this._service._generateSigner(args.account);
-        const connectedWallet = wallet.connect(provider);
-        if (!param.gasLimit) {
+        transaction.gasLimit = params.gasLimit ?? params.gas;
+        if (!transaction.gasLimit) {
             try {
-                param.gasLimit = await connectedWallet.estimateGas({
-                    ...param,
+                const estimatedGas = await connectedWallet.estimateGas({
+                    ...transaction,
                     gasPrice: undefined,
                     maxFeePerGas: undefined,
                     maxPriorityFeePerGas: undefined,
                 });
+                transaction.gasLimit = estimatedGas;
             }
             catch {
-                param.gasLimit = BSEthereumConstants_1.BSEthereumConstants.DEFAULT_GAS_LIMIT;
+                transaction.gasLimit = BSEthereumConstants_1.BSEthereumConstants.DEFAULT_GAS_LIMIT_BN.toString();
             }
         }
-        if (!param.nonce) {
-            param.nonce = await connectedWallet.getTransactionCount('pending');
-        }
-        return { wallet, provider, param };
-    }
-    async personal_sign(args) {
-        const wallet = await this._service._generateSigner(args.account);
-        const message = args.params.filter((param) => !ethers_1.ethers.utils.isAddress(param))[0];
-        const convertedMessage = __classPrivateFieldGet(this, _WalletConnectServiceEthereum_instances, "m", _WalletConnectServiceEthereum_convertHexToUtf8).call(this, message);
-        return await wallet.signMessage(convertedMessage);
-    }
-    async eth_sign(args) {
-        return await this.personal_sign(args);
-    }
-    async eth_signTransaction(args) {
-        const { param, wallet } = await this._resolveParams(args);
-        return await wallet.signTransaction(param);
-    }
-    async eth_signTypedData(args) {
-        const wallet = await this._service._generateSigner(args.account);
-        const data = args.params.filter((param) => !ethers_1.ethers.utils.isAddress(param))[0];
-        const parsedData = typeof data === 'string' ? JSON.parse(data) : data;
-        const { domain, types, message } = parsedData;
-        // https://github.com/ethers-io/ethers.js/issues/687#issuecomment-714069471
-        delete types.EIP712Domain;
-        return await wallet._signTypedData(domain, types, message);
-    }
-    async eth_signTypedData_v3(args) {
-        return await this.eth_signTypedData(args);
-    }
-    async eth_signTypedData_v4(args) {
-        return await this.eth_signTypedData(args);
-    }
-    async eth_sendTransaction(args) {
-        const { param, provider, wallet } = await this._resolveParams(args);
-        const connectedWallet = wallet.connect(provider);
-        const { hash } = await connectedWallet.sendTransaction(param);
-        return hash;
-    }
-    async eth_call(args) {
-        const { param, provider, wallet } = await this._resolveParams(args);
-        const connectedWallet = wallet.connect(provider);
-        return await connectedWallet.call(param);
-    }
-    async eth_requestAccounts(args) {
-        const wallet = await this._service._generateSigner(args.account);
-        return [await wallet.getAddress()];
-    }
-    async eth_sendRawTransaction(args) {
-        const provider = new ethers_1.ethers.providers.JsonRpcProvider(this._service.network.url);
-        const { hash } = await provider.sendTransaction(args.params[0]);
-        return hash;
-    }
-    async wallet_switchEthereumChain() {
-        return 'null';
-    }
-    async eth_addEthereumChain() {
-        return 'null';
-    }
-    async eth_switchEthereumChain() {
-        return 'null';
-    }
-    async wallet_getPermissions() {
-        return [];
-    }
-    async wallet_requestPermissions() {
-        return [];
-    }
-    async wallet_addEthereumChain() {
-        return 'null';
+        return { connectedWallet, transaction };
     }
     async calculateRequestFee(args) {
-        const { param, wallet, provider } = await this._resolveParams(args);
+        let transactionToEstimate;
+        if (args.method === 'eth_sendTransaction') {
+            const params = await this._sendTransactionHandler.validate(args.params).catch(error => {
+                throw new blockchain_service_1.BSError('Params validation failed: ' + error.message, 'INVALID_PARAMS');
+            });
+            const { transaction } = await this._resolveTransactionParams({ ...args, params });
+            transactionToEstimate = transaction;
+        }
+        else if (args.method === 'eth_sendRawTransaction') {
+            const params = await this._sendRawTransactionHandler.validate(args.params).catch(error => {
+                throw new blockchain_service_1.BSError('Params validation failed: ' + error.message, 'INVALID_PARAMS');
+            });
+            transactionToEstimate = (0, utils_1.parseTransaction)(params[0]);
+        }
+        else {
+            throw new blockchain_service_1.BSError(`Method ${args.method} is not supported for fee calculation`, 'UNSUPPORTED_METHOD');
+        }
+        const provider = new ethers_1.ethers.providers.JsonRpcProvider(this._service.network.url);
+        const wallet = await this._service._generateSigner(args.account);
         const connectedWallet = wallet.connect(provider);
         const gasPrice = await connectedWallet.getGasPrice();
-        const estimated = await connectedWallet.estimateGas({
-            ...param,
-            gasLimit: undefined,
-            gasPrice: undefined,
-            maxFeePerGas: undefined,
-            maxPriorityFeePerGas: undefined,
-        });
-        return ethers_1.ethers.utils.formatEther(gasPrice.mul(estimated));
+        const gasPriceBn = new blockchain_service_1.BSBigUnitAmount(gasPrice.toString(), this._service.feeToken.decimals);
+        const estimatedGas = await connectedWallet.estimateGas(transactionToEstimate);
+        const estimatedGasBn = new blockchain_service_1.BSBigUnitAmount(estimatedGas.toString(), this._service.feeToken.decimals);
+        const feeFormatted = gasPriceBn.multipliedBy(estimatedGasBn).toHuman().toFormatted();
+        return feeFormatted;
     }
 }
 exports.WalletConnectServiceEthereum = WalletConnectServiceEthereum;

package/dist/types.d.ts

@@ -174,4 +174,5 @@ export type TMoralisNDSEthereumNftsByAddressApiResponse = {
     page?: number;
     page_size?: number;
 };
+export type TWalletConnectServiceEthereumMethod = 'personal_sign' | 'eth_sign' | 'eth_signTransaction' | 'eth_signTypedData' | 'eth_signTypedData_v3' | 'eth_signTypedData_v4' | 'eth_sendTransaction' | 'eth_call' | 'eth_requestAccounts' | 'eth_sendRawTransaction' | 'eth_addEthereumChain' | 'eth_switchEthereumChain' | 'wallet_switchEthereumChain' | 'wallet_getPermissions' | 'wallet_requestPermissions' | 'wallet_addEthereumChain' | (string & {});
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-ethereum",
-  "version": "3.1.10",
+  "version": "3.1.11",
   "repository": "https://github.com/CityOfZion/blockchain-services",
   "license": "GPL-3.0-only",
   "author": "Coz",
@@ -19,7 +19,8 @@
     "@ledgerhq/hw-app-eth": "~7.3.0",
     "axios": "~1.15.0",
     "ethers": "5.8.0",
-    "@cityofzion/blockchain-service": "3.1.10"
+    "zod": "~4.3.6",
+    "@cityofzion/blockchain-service": "3.1.11"
   },
   "devDependencies": {
     "@ledgerhq/hw-transport": "~6.32.0",