@cityofzion/bs-neo3 3.1.10 → 3.1.12

package/dist/BSNeo3.d.ts

@@ -1,9 +1,10 @@
-import { type IBlockchainDataService, type IExchangeDataService, type IExplorerService, type INftDataService, type ITokenService, type IWalletConnectService, type TBSAccount, type TBSNetwork, type TBSToken, type TGetLedgerTransport, type TPingNetworkResponse, type TTransferParams, type IFullTransactionsDataService, type TTransactionDefault } from '@cityofzion/blockchain-service';
+import { type IBlockchainDataService, type IExchangeDataService, type IExplorerService, type INftDataService, type ITokenService, type TBSAccount, type TBSNetwork, type TBSToken, type TGetLedgerTransport, type TPingNetworkResponse, type TTransferParams, type IFullTransactionsDataService, type TTransactionDefault } from '@cityofzion/blockchain-service';
 import { NeonDappKitLedgerServiceNeo3 } from './services/ledger/NeonDappKitLedgerServiceNeo3';
 import { Neo3NeoXBridgeService } from './services/neo3-neox-bridge/Neo3NeoXBridgeService';
 import { VoteServiceNeo3 } from './services/vote/VoteServiceNeo3';
 import type { IBSNeo3, TBSNeo3Name, TBSNeo3NetworkId } from './types';
 import { api, wallet } from './helpers/BSNeo3NeonJsSingletonHelper';
+import { WalletConnectServiceNeo3 } from './services/wallet-connect/WalletConnectServiceNeo3';
 import { ClaimServiceNeo3 } from './services/claim/ClaimServiceNeo3';
 export declare class BSNeo3 implements IBSNeo3 {
     #private;
@@ -27,7 +28,7 @@ export declare class BSNeo3 implements IBSNeo3 {
     neo3NeoXBridgeService: Neo3NeoXBridgeService;
     tokenService: ITokenService;
     claimService: ClaimServiceNeo3;
-    walletConnectService: IWalletConnectService<TBSNeo3Name>;
+    walletConnectService: WalletConnectServiceNeo3;
     fullTransactionsDataService: IFullTransactionsDataService<TBSNeo3Name>;
     constructor(network?: TBSNetwork<TBSNeo3NetworkId>, getLedgerTransport?: TGetLedgerTransport<TBSNeo3Name>);
     setNetwork(network: TBSNetwork<TBSNeo3NetworkId>): void;

package/dist/BSNeo3.js

@@ -176,11 +176,11 @@ class BSNeo3 {
             account: neonJsAccount,
         });
         const invocations = await __classPrivateFieldGet(this, _BSNeo3_instances, "m", _BSNeo3_buildTransferInvocation).call(this, params, neonJsAccount);
-        const { total } = await invoker.calculateFee({
+        const { networkFee, systemFee } = await invoker.calculateFee({
             invocations,
             signers: [],
         });
-        return total.toString();
+        return new blockchain_service_1.BSBigHumanAmount(networkFee, this.feeToken.decimals).plus(systemFee).toFormatted();
     }
     async transfer(params) {
         const { senderAccount } = params;
@@ -226,8 +226,8 @@ class BSNeo3 {
                 txIdUrl: this.explorerService.buildTransactionUrl(txId),
                 date: new Date().toJSON(),
                 invocationCount: invocations.length,
-                networkFeeAmount: blockchain_service_1.BSBigNumberHelper.format(fees.networkFee, { decimals: this.feeToken.decimals }),
-                systemFeeAmount: blockchain_service_1.BSBigNumberHelper.format(fees.systemFee, { decimals: this.feeToken.decimals }),
+                networkFeeAmount: new blockchain_service_1.BSBigHumanAmount(fees.networkFee, this.feeToken.decimals).toFormatted(),
+                systemFeeAmount: new blockchain_service_1.BSBigHumanAmount(fees.systemFee, this.feeToken.decimals).toFormatted(),
                 view: 'default',
                 events,
                 data,
@@ -270,7 +270,7 @@ _BSNeo3_instances = new WeakSet(), _BSNeo3_setTokens = function _BSNeo3_setToken
                 { type: 'Hash160', value: intent.receiverAddress },
                 {
                     type: 'Integer',
-                    value: blockchain_service_1.BSBigNumberHelper.toDecimals(blockchain_service_1.BSBigNumberHelper.fromNumber(intent.amount), token.decimals),
+                    value: new blockchain_service_1.BSBigHumanAmount(intent.amount, intent.token.decimals).toUnit().toString(),
                 },
                 { type: 'Any', value: null },
             ],

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

@@ -51,8 +51,8 @@ class DoraBDSNeo3 extends RpcBDSNeo3_1.RpcBDSNeo3 {
             txIdUrl,
             block: response.block,
             date: new Date(Number(response.time) * 1000).toJSON(),
-            systemFeeAmount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(response.sysfee ?? 0, this._service.feeToken.decimals), { decimals: this._service.feeToken.decimals }),
-            networkFeeAmount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(response.netfee ?? 0, this._service.feeToken.decimals), { decimals: this._service.feeToken.decimals }),
+            systemFeeAmount: new blockchain_service_1.BSBigUnitAmount(response.sysfee, this._service.feeToken.decimals).toHuman().toFormatted(),
+            networkFeeAmount: new blockchain_service_1.BSBigUnitAmount(response.netfee, this._service.feeToken.decimals).toHuman().toFormatted(),
             invocationCount: 0,
             notificationCount: 0,
             view: 'default',
@@ -89,8 +89,8 @@ class DoraBDSNeo3 extends RpcBDSNeo3_1.RpcBDSNeo3 {
                 txIdUrl,
                 block: item.block,
                 date: new Date(Number(item.time) * 1000).toJSON(),
-                systemFeeAmount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(item.sysfee ?? 0, this._service.feeToken.decimals), { decimals: this._service.feeToken.decimals }),
-                networkFeeAmount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(item.netfee ?? 0, this._service.feeToken.decimals), { decimals: this._service.feeToken.decimals }),
+                systemFeeAmount: new blockchain_service_1.BSBigUnitAmount(item.sysfee, this._service.feeToken.decimals).toHuman().toFormatted(),
+                networkFeeAmount: new blockchain_service_1.BSBigUnitAmount(item.netfee, this._service.feeToken.decimals).toHuman().toFormatted(),
                 invocationCount: 0,
                 notificationCount: notifications?.length ?? 0,
                 view: 'default',
@@ -158,9 +158,7 @@ class DoraBDSNeo3 extends RpcBDSNeo3_1.RpcBDSNeo3 {
             try {
                 const token = await this.getTokenInfo(balance.asset);
                 return {
-                    amount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromNumber(balance.balance), {
-                        decimals: token.decimals,
-                    }),
+                    amount: new blockchain_service_1.BSBigHumanAmount(balance.balance, token.decimals).toFormatted(),
                     token,
                 };
             }

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

@@ -59,12 +59,8 @@ class RpcBDSNeo3 {
                 txIdUrl,
                 block: response.validuntilblock,
                 date: new Date(Number(response.blocktime) * 1000).toJSON(),
-                systemFeeAmount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(response.sysfee ?? 0, this._service.feeToken.decimals), {
-                    decimals: this._service.feeToken.decimals,
-                }),
-                networkFeeAmount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(response.netfee ?? 0, this._service.feeToken.decimals), {
-                    decimals: this._service.feeToken.decimals,
-                }),
+                systemFeeAmount: new blockchain_service_1.BSBigUnitAmount(response.sysfee, this._service.feeToken.decimals).toHuman().toFormatted(),
+                networkFeeAmount: new blockchain_service_1.BSBigUnitAmount(response.netfee, this._service.feeToken.decimals).toHuman().toFormatted(),
                 invocationCount: 0,
                 notificationCount: notifications.length,
                 view: 'default',
@@ -165,9 +161,7 @@ class RpcBDSNeo3 {
                 // Empty Block
             }
             return {
-                amount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(balance.amount, token.decimals), {
-                    decimals: token.decimals,
-                }),
+                amount: new blockchain_service_1.BSBigUnitAmount(balance.amount, token.decimals).toHuman().toFormatted(),
                 token,
             };
         });
@@ -200,9 +194,7 @@ _RpcBDSNeo3_instances = new WeakSet(), _RpcBDSNeo3_convertByteStringToAddress =
         const amount = properties[2].value || '0';
         return {
             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: convertedFrom,
             fromUrl,

package/dist/services/claim/ClaimServiceNeo3.d.ts

@@ -1,5 +1,5 @@
 import type { IBSNeo3, TBSNeo3Name } from '../../types';
-import type { IClaimService, TBSAccount, TClaimServiceTransactionData, TTransactionBase, TTransactionDefault, TTransactionDefaultEvent, TTransactionDefaultTokenEvent } from '@cityofzion/blockchain-service';
+import { type IClaimService, type TBSAccount, type TClaimServiceTransactionData, type TTransactionBase, type TTransactionDefault, type TTransactionDefaultEvent, type TTransactionDefaultTokenEvent } from '@cityofzion/blockchain-service';
 export declare class ClaimServiceNeo3 implements IClaimService<TBSNeo3Name> {
     #private;
     readonly _service: IBSNeo3;

package/dist/services/claim/ClaimServiceNeo3.js

@@ -8,6 +8,7 @@ var _ClaimServiceNeo3_instances, _ClaimServiceNeo3_buildClaimParams;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClaimServiceNeo3 = void 0;
 const BSNeo3NeonJsSingletonHelper_1 = require("../../helpers/BSNeo3NeonJsSingletonHelper");
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
 const BSNeo3Constants_1 = require("../../constants/BSNeo3Constants");
 class ClaimServiceNeo3 {
     constructor(service) {
@@ -48,10 +49,10 @@ class ClaimServiceNeo3 {
         };
     }
     async getUnclaimed(address) {
-        const { rpc, u } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
+        const { rpc } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
         const rpcClient = new rpc.RPCClient(this._service.network.url);
         const response = await rpcClient.getUnclaimedGas(address);
-        return u.BigInteger.fromNumber(response).toDecimal(this.claimToken.decimals);
+        return new blockchain_service_1.BSBigUnitAmount(response, this.claimToken.decimals).toHuman().toFormatted();
     }
     async calculateFee(senderAccount) {
         const claimParams = __classPrivateFieldGet(this, _ClaimServiceNeo3_instances, "m", _ClaimServiceNeo3_buildClaimParams).call(this, senderAccount);
@@ -62,8 +63,7 @@ class ClaimServiceNeo3 {
         const claimEvent = await this._buildTransactionEvent(senderAccount.address);
         const [transaction] = await this._service.transfer(claimParams);
         transaction.events.push(claimEvent);
-        const data = { isClaim: true };
-        transaction.data = data;
+        transaction.data = { isClaim: true };
         return transaction;
     }
     getTransactionData(transaction) {

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

@@ -68,7 +68,7 @@ class DoraFullTransactionsDataServiceNeo3 {
                 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,
@@ -108,10 +108,10 @@ class DoraFullTransactionsDataServiceNeo3 {
                 invocationCount: item.invocationCount,
                 notificationCount: item.notificationCount,
                 networkFeeAmount: networkFeeAmount
-                    ? blockchain_service_1.BSBigNumberHelper.format(networkFeeAmount, { decimals: __classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_service, "f").feeToken.decimals })
+                    ? new blockchain_service_1.BSBigHumanAmount(networkFeeAmount, __classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_service, "f").feeToken.decimals).toFormatted()
                     : undefined,
                 systemFeeAmount: systemFeeAmount
-                    ? blockchain_service_1.BSBigNumberHelper.format(systemFeeAmount, { decimals: __classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_service, "f").feeToken.decimals })
+                    ? new blockchain_service_1.BSBigHumanAmount(systemFeeAmount, __classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_service, "f").feeToken.decimals).toFormatted()
                     : undefined,
                 view: 'default',
                 events,

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

@@ -58,9 +58,7 @@ class Neo3NeoXBridgeService {
         const { u } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
         return {
             neo3NeoxBridge: {
-                amount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(amountInDecimals, tokenToUse.decimals), {
-                    decimals: tokenToUse.decimals,
-                }),
+                amount: new blockchain_service_1.BSBigUnitAmount(amountInDecimals, tokenToUse.decimals).toHuman().toFormatted(),
                 tokenToUse,
                 receiverAddress: `0x${u.HexString.fromBase64(byteStringReceiverAddress).toLittleEndian()}`,
             },
@@ -110,12 +108,11 @@ class Neo3NeoXBridgeService {
             !TypeChecker.isStackTypeInteger(minDepositItem) ||
             !TypeChecker.isStackTypeInteger(maxDepositItem))
             throw new blockchain_service_1.BSError('Invalid response', 'INVALID_RESPONSE');
-        const bridgeFeeBn = blockchain_service_1.BSBigNumberHelper.fromDecimals(depositFeeItem.value, BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN.decimals).toString();
-        const minAmountBn = blockchain_service_1.BSBigNumberHelper.fromDecimals(minDepositItem.value, token.decimals).toString();
-        const maxAmountBn = blockchain_service_1.BSBigNumberHelper.fromDecimals(maxDepositItem.value, token.decimals).toString();
-        const bridgeFee = blockchain_service_1.BSBigNumberHelper.format(bridgeFeeBn, { decimals: BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN.decimals });
-        const bridgeMinAmount = blockchain_service_1.BSBigNumberHelper.format(minAmountBn, { decimals: token.decimals });
-        const bridgeMaxAmount = blockchain_service_1.BSBigNumberHelper.format(maxAmountBn, { decimals: token.decimals });
+        const bridgeFee = new blockchain_service_1.BSBigUnitAmount(depositFeeItem.value, BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN.decimals)
+            .toHuman()
+            .toFormatted();
+        const bridgeMinAmount = new blockchain_service_1.BSBigUnitAmount(minDepositItem.value, token.decimals).toHuman().toFormatted();
+        const bridgeMaxAmount = new blockchain_service_1.BSBigUnitAmount(maxDepositItem.value, token.decimals).toHuman().toFormatted();
         return {
             bridgeFee,
             bridgeMinAmount,
@@ -142,11 +139,11 @@ class Neo3NeoXBridgeService {
                 { type: 'Hash160', value: params.receiverAddress },
                 {
                     type: 'Integer',
-                    value: blockchain_service_1.BSBigNumberHelper.toDecimals(blockchain_service_1.BSBigNumberHelper.fromNumber(params.amount), params.token.decimals),
+                    value: new blockchain_service_1.BSBigHumanAmount(params.amount, params.token.decimals).toUnit().toString(),
                 },
                 {
                     type: 'Integer',
-                    value: blockchain_service_1.BSBigNumberHelper.toDecimals(blockchain_service_1.BSBigNumberHelper.fromNumber(params.bridgeFee), BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN.decimals),
+                    value: new blockchain_service_1.BSBigHumanAmount(params.bridgeFee, BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN.decimals).toUnit().toString(),
                 },
             ],
         };

package/dist/services/vote/VoteServiceNeo3.js

@@ -115,8 +115,8 @@ class VoteServiceNeo3 {
             txIdUrl: this._service.explorerService.buildTransactionUrl(txId),
             date: new Date().toJSON(),
             invocationCount,
-            networkFeeAmount: blockchain_service_1.BSBigNumberHelper.format(fees.networkFee, { decimals: feeDecimals }),
-            systemFeeAmount: blockchain_service_1.BSBigNumberHelper.format(fees.systemFee, { decimals: feeDecimals }),
+            networkFeeAmount: new blockchain_service_1.BSBigHumanAmount(fees.networkFee, feeDecimals).toFormatted(),
+            systemFeeAmount: new blockchain_service_1.BSBigHumanAmount(fees.systemFee, feeDecimals).toFormatted(),
             view: 'default',
             events: [claimEvent, voteEvent],
             data,
@@ -135,7 +135,7 @@ class VoteServiceNeo3 {
         });
         const cim = __classPrivateFieldGet(this, _VoteServiceNeo3_instances, "m", _VoteServiceNeo3_buildVoteInvocation).call(this, { address: account.address, candidatePubKey });
         const { total } = await invoker.calculateFee(cim);
-        return blockchain_service_1.BSBigNumberHelper.format(total, { decimals: this._service.feeToken.decimals });
+        return new blockchain_service_1.BSBigHumanAmount(total, this._service.feeToken.decimals).toFormatted();
     }
 }
 exports.VoteServiceNeo3 = VoteServiceNeo3;

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

@@ -1,45 +1,112 @@
-import type { IWalletConnectService, TWalletConnectServiceRequestMethodParams } from '@cityofzion/blockchain-service';
-import type { IBSNeo3, TBSNeo3Name } from '../../types';
-export declare class WalletConnectServiceNeo3 implements IWalletConnectService<TBSNeo3Name> {
+import { type IWalletConnectService, type TWalletConnectServiceHandlers, type TWalletConnectServiceRequestMethodParams } from '@cityofzion/blockchain-service';
+import type { IBSNeo3, TBSNeo3Name, TWalletConnectServiceNeo3Method } from '../../types';
+import { z } from 'zod';
+declare const contractInvocationParamsSchema: z.ZodObject<{
+    invocations: z.ZodArray<z.ZodObject<{
+        scriptHash: z.ZodString;
+        operation: z.ZodString;
+        args: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"Any">;
+            value: z.ZodAny;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"String">;
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"Boolean">;
+            value: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"PublicKey">;
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"Hash160">;
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"Hash256">;
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"Integer">;
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"ByteArray">;
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"Array">;
+            value: z.ZodArray<z.ZodAny>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"Map">;
+            value: z.ZodArray<z.ZodAny>;
+        }, z.core.$strip>], "type">>;
+        abortOnFail: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    signers: z.ZodArray<z.ZodObject<{
+        scopes: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        account: z.ZodOptional<z.ZodString>;
+        allowedContracts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        allowedGroups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            action: z.ZodString;
+            condition: z.ZodAny;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    extraSystemFee: z.ZodOptional<z.ZodNumber>;
+    systemFeeOverride: z.ZodOptional<z.ZodNumber>;
+    extraNetworkFee: z.ZodOptional<z.ZodNumber>;
+    networkFeeOverride: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const signMessageParamsSchema: z.ZodObject<{
+    message: z.ZodString;
+    version: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+}, z.core.$strip>;
+declare const verifyMessageSchema: z.ZodUnion<readonly [z.ZodObject<{
+    publicKey: z.ZodString;
+    data: z.ZodString;
+    salt: z.ZodOptional<z.ZodString>;
+    messageHex: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    publicKey: z.ZodString;
+    data: z.ZodString;
+    salt: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+    messageHex: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+declare const encryptParamsSchema: z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodArray<z.ZodString>>], null>;
+declare const decryptParamsSchema: z.ZodTuple<[z.ZodObject<{
+    randomVector: z.ZodString;
+    cipherText: z.ZodString;
+    dataTag: z.ZodString;
+    ephemPublicKey: z.ZodString;
+}, z.core.$strip>], null>;
+declare const decryptFromArrayParamsSchema: z.ZodTuple<[z.ZodArray<z.ZodObject<{
+    randomVector: z.ZodString;
+    cipherText: z.ZodString;
+    dataTag: z.ZodString;
+    ephemPublicKey: z.ZodString;
+}, z.core.$strip>>], null>;
+declare const traverseIteratorParamsSchema: z.ZodTuple<[z.ZodString, z.ZodString, z.ZodNumber], null>;
+export declare class WalletConnectServiceNeo3 implements IWalletConnectService<TBSNeo3Name, TWalletConnectServiceNeo3Method> {
     #private;
     readonly namespace: string;
     readonly chain: string;
-    readonly supportedMethods: string[];
+    readonly supportedMethods: TWalletConnectServiceNeo3Method[];
     readonly supportedEvents: string[];
-    readonly calculableMethods: string[];
-    readonly autoApproveMethods: string[];
-    constructor(service: IBSNeo3);
-    [methodName: string]: any;
-    invokeFunction(args: TWalletConnectServiceRequestMethodParams<TBSNeo3Name>): Promise<string>;
-    testInvoke(args: TWalletConnectServiceRequestMethodParams<TBSNeo3Name>): Promise<import("@cityofzion/neon-dappkit-types/dist/Neo3Invoker").InvokeResult<import("@cityofzion/neon-dappkit-types/dist/Neo3Invoker").RpcResponseStackItem>>;
-    signMessage(args: TWalletConnectServiceRequestMethodParams<TBSNeo3Name>): Promise<import("@cityofzion/neon-dappkit-types/dist/Neo3Signer").SignedMessage>;
-    verifyMessage(args: TWalletConnectServiceRequestMethodParams<TBSNeo3Name>): Promise<boolean>;
-    traverseIterator(args: TWalletConnectServiceRequestMethodParams<TBSNeo3Name>): Promise<import("@cityofzion/neon-dappkit-types/dist/Neo3Invoker").RpcResponseStackItem[]>;
-    decrypt(args: TWalletConnectServiceRequestMethodParams<TBSNeo3Name>): Promise<string>;
-    encrypt(args: TWalletConnectServiceRequestMethodParams<TBSNeo3Name>): Promise<import("@cityofzion/neon-dappkit-types/dist/Neo3Signer").EncryptedPayload[]>;
-    decryptFromArray(args: TWalletConnectServiceRequestMethodParams<TBSNeo3Name>): Promise<import("@cityofzion/neon-dappkit-types/dist/Neo3Signer").DecryptFromArrayResult>;
-    getNetworkVersion(): Promise<{
-        tcpport: number;
-        wsport: number;
-        nonce: number;
-        useragent: string;
-        protocol: {
-            addressversion: number;
-            network: number;
-            validatorscount: number;
-            msperblock: number;
-            maxtraceableblocks: number;
-            maxvaliduntilblockincrement: number;
-            maxtransactionsperblock: number;
-            memorypoolmaxtransactions: number;
-            initialgasdistribution: number;
-        };
-        rpcAddress: string;
-    }>;
-    calculateFee(args: TWalletConnectServiceRequestMethodParams<TBSNeo3Name>): Promise<import("@cityofzion/neon-dappkit-types/dist/Neo3Invoker").CalculateFee>;
-    signTransaction(args: TWalletConnectServiceRequestMethodParams<TBSNeo3Name>): Promise<import("@cityofzion/neon-dappkit-types/dist/Neo3Invoker").BuiltTransaction>;
-    getWalletInfo(args: TWalletConnectServiceRequestMethodParams<TBSNeo3Name>): Promise<{
-        isLedger: boolean;
+    readonly calculableMethods: TWalletConnectServiceNeo3Method[];
+    readonly autoApproveMethods: TWalletConnectServiceNeo3Method[];
+    handlers: TWalletConnectServiceHandlers<TBSNeo3Name, {
+        invokeFunction: z.infer<typeof contractInvocationParamsSchema>;
+        testInvoke: z.infer<typeof contractInvocationParamsSchema>;
+        signTransaction: z.infer<typeof contractInvocationParamsSchema>;
+        calculateFee: z.infer<typeof contractInvocationParamsSchema>;
+        signMessage: z.infer<typeof signMessageParamsSchema>;
+        verifyMessage: z.infer<typeof verifyMessageSchema>;
+        encrypt: z.infer<typeof encryptParamsSchema>;
+        decrypt: z.infer<typeof decryptParamsSchema>;
+        decryptFromArray: z.infer<typeof decryptFromArrayParamsSchema>;
+        getNetworkVersion: any;
+        traverseIterator: z.infer<typeof traverseIteratorParamsSchema>;
+        getWalletInfo: any;
     }>;
+    constructor(service: IBSNeo3);
     calculateRequestFee(args: TWalletConnectServiceRequestMethodParams<TBSNeo3Name>): Promise<string>;
 }
+export {};

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

@@ -10,28 +10,81 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _WalletConnectServiceNeo3_instances, _WalletConnectServiceNeo3_service, _WalletConnectServiceNeo3_getInvoker, _WalletConnectServiceNeo3_getSigner;
+var _WalletConnectServiceNeo3_instances, _WalletConnectServiceNeo3_service, _WalletConnectServiceNeo3_invokeFunctionHandler, _WalletConnectServiceNeo3_testInvokeHandler, _WalletConnectServiceNeo3_signTransactionHandler, _WalletConnectServiceNeo3_calculateFeeHandler, _WalletConnectServiceNeo3_signMessageHandler, _WalletConnectServiceNeo3_verifyMessageHandler, _WalletConnectServiceNeo3_encryptHandler, _WalletConnectServiceNeo3_decryptHandler, _WalletConnectServiceNeo3_decryptFromArrayHandler, _WalletConnectServiceNeo3_getNetworkVersionHandler, _WalletConnectServiceNeo3_traverseIteratorHandler, _WalletConnectServiceNeo3_getWalletInfoHandler, _WalletConnectServiceNeo3_getInvoker, _WalletConnectServiceNeo3_getSigner;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WalletConnectServiceNeo3 = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
 const BSNeo3NeonDappKitSingletonHelper_1 = require("../../helpers/BSNeo3NeonDappKitSingletonHelper");
 const BSNeo3NeonJsSingletonHelper_1 = require("../../helpers/BSNeo3NeonJsSingletonHelper");
+const zod_1 = require("zod");
+const contractInvocationParamsSchema = zod_1.z.object({
+    invocations: zod_1.z.array(zod_1.z.object({
+        scriptHash: zod_1.z.string(),
+        operation: zod_1.z.string(),
+        args: zod_1.z.array(zod_1.z.discriminatedUnion('type', [
+            zod_1.z.object({ type: zod_1.z.literal('Any'), value: zod_1.z.any() }),
+            zod_1.z.object({ type: zod_1.z.literal('String'), value: zod_1.z.string() }),
+            zod_1.z.object({ type: zod_1.z.literal('Boolean'), value: zod_1.z.boolean() }),
+            zod_1.z.object({ type: zod_1.z.literal('PublicKey'), value: zod_1.z.string() }),
+            zod_1.z.object({ type: zod_1.z.literal('Hash160'), value: zod_1.z.string() }),
+            zod_1.z.object({ type: zod_1.z.literal('Hash256'), value: zod_1.z.string() }),
+            zod_1.z.object({ type: zod_1.z.literal('Integer'), value: zod_1.z.string() }),
+            zod_1.z.object({ type: zod_1.z.literal('ByteArray'), value: zod_1.z.string() }),
+            zod_1.z.object({ type: zod_1.z.literal('Array'), value: zod_1.z.array(zod_1.z.any()) }),
+            zod_1.z.object({ type: zod_1.z.literal('Map'), value: zod_1.z.array(zod_1.z.any()) }),
+        ])),
+        abortOnFail: zod_1.z.boolean().optional(),
+    })),
+    signers: zod_1.z.array(zod_1.z.object({
+        scopes: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]),
+        account: zod_1.z.string().optional(),
+        allowedContracts: zod_1.z.array(zod_1.z.string()).optional(),
+        allowedGroups: zod_1.z.array(zod_1.z.string()).optional(),
+        rules: zod_1.z.array(zod_1.z.object({ action: zod_1.z.string(), condition: zod_1.z.any() })).optional(),
+    })),
+    extraSystemFee: zod_1.z.number().optional(),
+    systemFeeOverride: zod_1.z.number().optional(),
+    extraNetworkFee: zod_1.z.number().optional(),
+    networkFeeOverride: zod_1.z.number().optional(),
+});
+const signMessageParamsSchema = zod_1.z.object({
+    message: zod_1.z.string(),
+    version: zod_1.z.union([zod_1.z.literal(1), zod_1.z.literal(2), zod_1.z.literal(3)]).optional(),
+});
+const verifyMessageBaseParamsSchema = zod_1.z.object({
+    publicKey: zod_1.z.string(),
+    data: zod_1.z.string(),
+    salt: zod_1.z.string().optional(),
+});
+const verifyMessageSchema = zod_1.z.union([
+    verifyMessageBaseParamsSchema.extend({
+        messageHex: zod_1.z.string(),
+        message: zod_1.z.string().optional(),
+    }),
+    verifyMessageBaseParamsSchema.extend({
+        message: zod_1.z.string(),
+        messageHex: zod_1.z.string().optional(),
+    }),
+]);
+const encryptParamsSchema = zod_1.z.tuple([zod_1.z.string(), zod_1.z.array(zod_1.z.string()).optional()]);
+const encryptedMessageSchema = zod_1.z.object({
+    randomVector: zod_1.z.string(),
+    cipherText: zod_1.z.string(),
+    dataTag: zod_1.z.string(),
+    ephemPublicKey: zod_1.z.string(),
+});
+const decryptParamsSchema = zod_1.z.tuple([encryptedMessageSchema]);
+const decryptFromArrayParamsSchema = zod_1.z.tuple([zod_1.z.array(encryptedMessageSchema)]);
+const traverseIteratorParamsSchema = zod_1.z.tuple([zod_1.z.string(), zod_1.z.string(), zod_1.z.number()]);
 class WalletConnectServiceNeo3 {
     constructor(service) {
         _WalletConnectServiceNeo3_instances.add(this);
         this.namespace = 'neo3';
+        // prettier-ignore
         this.supportedMethods = [
-            'invokeFunction',
-            'testInvoke',
-            'signMessage',
-            'verifyMessage',
-            'getWalletInfo',
-            'traverseIterator',
-            'getNetworkVersion',
-            'encrypt',
-            'decrypt',
-            'decryptFromArray',
-            'calculateFee',
-            'signTransaction',
+            'invokeFunction', 'testInvoke', 'signMessage', 'verifyMessage',
+            'getWalletInfo', 'traverseIterator', 'getNetworkVersion', 'encrypt',
+            'decrypt', 'decryptFromArray', 'calculateFee', 'signTransaction',
         ];
         this.supportedEvents = [];
         this.calculableMethods = ['invokeFunction', 'signTransaction'];
@@ -43,76 +96,129 @@ class WalletConnectServiceNeo3 {
             'calculateFee',
         ];
         _WalletConnectServiceNeo3_service.set(this, void 0);
+        _WalletConnectServiceNeo3_invokeFunctionHandler.set(this, {
+            validate: async (params) => await contractInvocationParamsSchema.parseAsync(params),
+            process: async (args) => {
+                const invoker = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_instances, "m", _WalletConnectServiceNeo3_getInvoker).call(this, args.account);
+                return await invoker.invokeFunction(args.params);
+            },
+        });
+        _WalletConnectServiceNeo3_testInvokeHandler.set(this, {
+            validate: async (params) => await contractInvocationParamsSchema.parseAsync(params),
+            process: async (args) => {
+                const invoker = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_instances, "m", _WalletConnectServiceNeo3_getInvoker).call(this, args.account);
+                return await invoker.testInvoke(args.params);
+            },
+        });
+        _WalletConnectServiceNeo3_signTransactionHandler.set(this, {
+            validate: async (params) => await contractInvocationParamsSchema.parseAsync(params),
+            process: async (args) => {
+                const invoker = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_instances, "m", _WalletConnectServiceNeo3_getInvoker).call(this, args.account);
+                return await invoker.signTransaction(args.params);
+            },
+        });
+        _WalletConnectServiceNeo3_calculateFeeHandler.set(this, {
+            validate: async (params) => await contractInvocationParamsSchema.parseAsync(params),
+            process: async (args) => {
+                const invoker = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_instances, "m", _WalletConnectServiceNeo3_getInvoker).call(this, args.account);
+                return await invoker.calculateFee(args.params);
+            },
+        });
+        _WalletConnectServiceNeo3_signMessageHandler.set(this, {
+            validate: async (params) => await signMessageParamsSchema.parseAsync(params),
+            process: async (args) => {
+                const signer = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_instances, "m", _WalletConnectServiceNeo3_getSigner).call(this, args.account);
+                return await signer.signMessage(args.params);
+            },
+        });
+        _WalletConnectServiceNeo3_verifyMessageHandler.set(this, {
+            validate: async (params) => await verifyMessageSchema.parseAsync(params),
+            process: async (args) => {
+                const signer = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_instances, "m", _WalletConnectServiceNeo3_getSigner).call(this, args.account);
+                return await signer.verifyMessage(args.params);
+            },
+        });
+        _WalletConnectServiceNeo3_encryptHandler.set(this, {
+            validate: async (params) => await encryptParamsSchema.parseAsync(params),
+            process: async (args) => {
+                const signer = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_instances, "m", _WalletConnectServiceNeo3_getSigner).call(this, args.account);
+                let publicKeys = args.params[1];
+                if (!publicKeys || publicKeys.length === 0) {
+                    publicKeys = [signer.account.getPublicKey()];
+                }
+                return await signer.encrypt(args.params[0], publicKeys);
+            },
+        });
+        _WalletConnectServiceNeo3_decryptHandler.set(this, {
+            validate: async (params) => await decryptParamsSchema.parseAsync(params),
+            process: async (args) => {
+                const signer = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_instances, "m", _WalletConnectServiceNeo3_getSigner).call(this, args.account);
+                return await signer.decrypt(args.params[0]);
+            },
+        });
+        _WalletConnectServiceNeo3_decryptFromArrayHandler.set(this, {
+            validate: async (params) => await decryptFromArrayParamsSchema.parseAsync(params),
+            process: async (args) => {
+                const signer = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_instances, "m", _WalletConnectServiceNeo3_getSigner).call(this, args.account);
+                return await signer.decryptFromArray(args.params[0]);
+            },
+        });
+        _WalletConnectServiceNeo3_getNetworkVersionHandler.set(this, {
+            validate: async () => { },
+            process: async () => {
+                const { rpc } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
+                const rpcClient = new rpc.RPCClient(__classPrivateFieldGet(this, _WalletConnectServiceNeo3_service, "f").network.url);
+                const response = await rpcClient.getVersion();
+                return {
+                    rpcAddress: __classPrivateFieldGet(this, _WalletConnectServiceNeo3_service, "f").network.url,
+                    ...response,
+                };
+            },
+        });
+        _WalletConnectServiceNeo3_traverseIteratorHandler.set(this, {
+            validate: async (params) => await traverseIteratorParamsSchema.parseAsync(params),
+            process: async (args) => {
+                const invoker = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_instances, "m", _WalletConnectServiceNeo3_getInvoker).call(this, args.account);
+                return await invoker.traverseIterator(args.params[0], args.params[1], args.params[2]);
+            },
+        });
+        _WalletConnectServiceNeo3_getWalletInfoHandler.set(this, {
+            validate: async () => { },
+            process: async (args) => {
+                return {
+                    isLedger: args.account.isHardware || false,
+                };
+            },
+        });
         __classPrivateFieldSet(this, _WalletConnectServiceNeo3_service, service, "f");
         const networkId = service.network.type === 'custom' ? 'private' : __classPrivateFieldGet(this, _WalletConnectServiceNeo3_service, "f").network.id.toString();
         this.chain = `${this.namespace}:${networkId}`;
-    }
-    async invokeFunction(args) {
-        const invoker = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_instances, "m", _WalletConnectServiceNeo3_getInvoker).call(this, args);
-        return await invoker.invokeFunction(args.params);
-    }
-    async testInvoke(args) {
-        const invoker = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_instances, "m", _WalletConnectServiceNeo3_getInvoker).call(this, args);
-        return await invoker.testInvoke(args.params);
-    }
-    async signMessage(args) {
-        const signer = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_instances, "m", _WalletConnectServiceNeo3_getSigner).call(this, args);
-        return await signer.signMessage(args.params);
-    }
-    async verifyMessage(args) {
-        const signer = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_instances, "m", _WalletConnectServiceNeo3_getSigner).call(this, args);
-        return await signer.verifyMessage(args.params);
-    }
-    async traverseIterator(args) {
-        const invoker = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_instances, "m", _WalletConnectServiceNeo3_getInvoker).call(this, args);
-        return await invoker.traverseIterator(args.params[0], args.params[1], args.params[2]);
-    }
-    async decrypt(args) {
-        const signer = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_instances, "m", _WalletConnectServiceNeo3_getSigner).call(this, args);
-        return await signer.decrypt(args.params[0]);
-    }
-    async encrypt(args) {
-        const signer = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_instances, "m", _WalletConnectServiceNeo3_getSigner).call(this, args);
-        let publicKeys = args.params[1];
-        if (!publicKeys || publicKeys.length === 0) {
-            publicKeys = [signer.account.getPublicKey()];
-        }
-        return await signer.encrypt(args.params[0], publicKeys);
-    }
-    async decryptFromArray(args) {
-        const signer = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_instances, "m", _WalletConnectServiceNeo3_getSigner).call(this, args);
-        return await signer.decryptFromArray(args.params[0]);
-    }
-    async getNetworkVersion() {
-        const { rpc } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
-        const rpcClient = new rpc.RPCClient(__classPrivateFieldGet(this, _WalletConnectServiceNeo3_service, "f").network.url);
-        const response = await rpcClient.getVersion();
-        return {
-            rpcAddress: __classPrivateFieldGet(this, _WalletConnectServiceNeo3_service, "f").network.url,
-            ...response,
-        };
-    }
-    async calculateFee(args) {
-        const invoker = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_instances, "m", _WalletConnectServiceNeo3_getInvoker).call(this, args);
-        return await invoker.calculateFee(args.params);
-    }
-    async signTransaction(args) {
-        const invoker = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_instances, "m", _WalletConnectServiceNeo3_getInvoker).call(this, args);
-        return await invoker.signTransaction(args.params);
-    }
-    async getWalletInfo(args) {
-        return {
-            isLedger: args.account.isHardware || false,
+        this.handlers = {
+            invokeFunction: __classPrivateFieldGet(this, _WalletConnectServiceNeo3_invokeFunctionHandler, "f"),
+            testInvoke: __classPrivateFieldGet(this, _WalletConnectServiceNeo3_testInvokeHandler, "f"),
+            signTransaction: __classPrivateFieldGet(this, _WalletConnectServiceNeo3_signTransactionHandler, "f"),
+            calculateFee: __classPrivateFieldGet(this, _WalletConnectServiceNeo3_calculateFeeHandler, "f"),
+            signMessage: __classPrivateFieldGet(this, _WalletConnectServiceNeo3_signMessageHandler, "f"),
+            verifyMessage: __classPrivateFieldGet(this, _WalletConnectServiceNeo3_verifyMessageHandler, "f"),
+            encrypt: __classPrivateFieldGet(this, _WalletConnectServiceNeo3_encryptHandler, "f"),
+            decrypt: __classPrivateFieldGet(this, _WalletConnectServiceNeo3_decryptHandler, "f"),
+            decryptFromArray: __classPrivateFieldGet(this, _WalletConnectServiceNeo3_decryptFromArrayHandler, "f"),
+            getNetworkVersion: __classPrivateFieldGet(this, _WalletConnectServiceNeo3_getNetworkVersionHandler, "f"),
+            traverseIterator: __classPrivateFieldGet(this, _WalletConnectServiceNeo3_traverseIteratorHandler, "f"),
+            getWalletInfo: __classPrivateFieldGet(this, _WalletConnectServiceNeo3_getWalletInfoHandler, "f"),
         };
     }
     async calculateRequestFee(args) {
-        const { total } = await this.calculateFee(args);
+        const params = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_calculateFeeHandler, "f").validate(args.params).catch(error => {
+            throw new blockchain_service_1.BSError('Params validation failed: ' + error.message, 'INVALID_PARAMS');
+        });
+        const { total } = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_calculateFeeHandler, "f").process({ ...args, params });
         return total.toString();
     }
 }
 exports.WalletConnectServiceNeo3 = WalletConnectServiceNeo3;
-_WalletConnectServiceNeo3_service = new WeakMap(), _WalletConnectServiceNeo3_instances = new WeakSet(), _WalletConnectServiceNeo3_getInvoker = async function _WalletConnectServiceNeo3_getInvoker(args) {
-    const { neonJsAccount, signingCallback } = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_service, "f")._generateSigningCallback(args.account);
+_WalletConnectServiceNeo3_service = new WeakMap(), _WalletConnectServiceNeo3_invokeFunctionHandler = new WeakMap(), _WalletConnectServiceNeo3_testInvokeHandler = new WeakMap(), _WalletConnectServiceNeo3_signTransactionHandler = new WeakMap(), _WalletConnectServiceNeo3_calculateFeeHandler = new WeakMap(), _WalletConnectServiceNeo3_signMessageHandler = new WeakMap(), _WalletConnectServiceNeo3_verifyMessageHandler = new WeakMap(), _WalletConnectServiceNeo3_encryptHandler = new WeakMap(), _WalletConnectServiceNeo3_decryptHandler = new WeakMap(), _WalletConnectServiceNeo3_decryptFromArrayHandler = new WeakMap(), _WalletConnectServiceNeo3_getNetworkVersionHandler = new WeakMap(), _WalletConnectServiceNeo3_traverseIteratorHandler = new WeakMap(), _WalletConnectServiceNeo3_getWalletInfoHandler = new WeakMap(), _WalletConnectServiceNeo3_instances = new WeakSet(), _WalletConnectServiceNeo3_getInvoker = async function _WalletConnectServiceNeo3_getInvoker(account) {
+    const { neonJsAccount, signingCallback } = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_service, "f")._generateSigningCallback(account);
     const { NeonInvoker } = BSNeo3NeonDappKitSingletonHelper_1.BSNeo3NeonDappKitSingletonHelper.getInstance();
     const invoker = await NeonInvoker.init({
         rpcAddress: __classPrivateFieldGet(this, _WalletConnectServiceNeo3_service, "f").network.url,
@@ -120,8 +226,8 @@ _WalletConnectServiceNeo3_service = new WeakMap(), _WalletConnectServiceNeo3_ins
         signingCallback,
     });
     return invoker;
-}, _WalletConnectServiceNeo3_getSigner = async function _WalletConnectServiceNeo3_getSigner(args) {
-    const { neonJsAccount } = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_service, "f")._generateSigningCallback(args.account);
+}, _WalletConnectServiceNeo3_getSigner = async function _WalletConnectServiceNeo3_getSigner(account) {
+    const { neonJsAccount } = await __classPrivateFieldGet(this, _WalletConnectServiceNeo3_service, "f")._generateSigningCallback(account);
     const { NeonSigner } = BSNeo3NeonDappKitSingletonHelper_1.BSNeo3NeonDappKitSingletonHelper.getInstance();
     const signer = new NeonSigner(neonJsAccount);
     return signer;

package/dist/types.d.ts

@@ -103,3 +103,4 @@ export type TRpcBDSNeo3Notification = {
     eventname: string;
     state: TRpcBDSNeo3NotificationState | TRpcBDSNeo3NotificationState[] | undefined;
 };
+export type TWalletConnectServiceNeo3Method = 'invokeFunction' | 'testInvoke' | 'signMessage' | 'verifyMessage' | 'getWalletInfo' | 'traverseIterator' | 'getNetworkVersion' | 'encrypt' | 'decrypt' | 'decryptFromArray' | 'calculateFee' | 'signTransaction';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-neo3",
-  "version": "3.1.10",
+  "version": "3.1.12",
   "repository": "https://github.com/CityOfZion/blockchain-services",
   "license": "GPL-3.0-only",
   "author": "Coz",
@@ -19,7 +19,7 @@
     "@cityofzion/neon-dappkit": "~0.6.0",
     "@cityofzion/neon-js": "~5.8.1",
     "axios": "~1.15.0",
-    "@cityofzion/blockchain-service": "3.1.10"
+    "@cityofzion/blockchain-service": "3.1.12"
   },
   "devDependencies": {
     "@cityofzion/neon-dappkit-types": "~0.5.0",
@@ -29,7 +29,8 @@
     "dotenv": "~17.3.1",
     "eslint": "~9.37.0",
     "typescript": "~5.9.2",
-    "vitest": "~4.0.18"
+    "vitest": "~4.0.18",
+    "zod": "~4.3.6"
   },
   "scripts": {
     "build": "rm -rf ./dist && rm -f *.tgz && npm run typecheck && tsc --project tsconfig.build.json",