@cityofzion/bs-neo3 3.1.2 → 3.1.4

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

@@ -4,7 +4,7 @@ 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 _RpcBDSNeo3_instances, _RpcBDSNeo3_convertByteStringToAddress;
+var _RpcBDSNeo3_instances, _RpcBDSNeo3_convertByteStringToAddress, _RpcBDSNeo3_parseTransferNotification, _RpcBDSNeo3_parseVoteNotification;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RpcBDSNeo3 = void 0;
 const blockchain_service_1 = require("@cityofzion/blockchain-service");
@@ -19,88 +19,24 @@ class RpcBDSNeo3 {
     }
     async _extractEventsFromNotifications(notifications = []) {
         const events = [];
-        const promises = notifications.map(async ({ contract: contractHash, state, eventname }, index) => {
-            const properties = (Array.isArray(state) ? state : (state?.value ?? []));
-            if (eventname !== 'Transfer' || (properties.length !== 3 && properties.length !== 4))
-                return;
-            const isAsset = properties.length === 3;
-            const from = properties[0].value;
-            const to = properties[1].value;
-            const convertedFrom = from ? __classPrivateFieldGet(this, _RpcBDSNeo3_instances, "m", _RpcBDSNeo3_convertByteStringToAddress).call(this, from) : 'Mint';
-            const convertedTo = to ? __classPrivateFieldGet(this, _RpcBDSNeo3_instances, "m", _RpcBDSNeo3_convertByteStringToAddress).call(this, to) : 'Burn';
-            const fromUrl = from ? this._service.explorerService.buildAddressUrl(convertedFrom) : undefined;
-            const toUrl = to ? this._service.explorerService.buildAddressUrl(convertedTo) : undefined;
-            if (isAsset) {
-                const token = await this.getTokenInfo(contractHash);
-                const amount = properties[2].value || '0';
-                events.splice(index, 0, {
-                    eventType: 'token',
-                    amount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(amount, token.decimals), {
-                        decimals: token.decimals,
-                    }),
-                    methodName: 'transfer',
-                    from: convertedFrom,
-                    fromUrl,
-                    to: convertedTo,
-                    toUrl,
-                    tokenType: 'nep-17',
-                    tokenUrl: this._service.explorerService.buildContractUrl(token.hash),
-                    token,
-                });
-                return;
+        const promises = notifications.map(async (notification, index) => {
+            const eventName = notification.eventname.toLowerCase();
+            if (eventName === 'transfer') {
+                const transferEvent = await __classPrivateFieldGet(this, _RpcBDSNeo3_instances, "m", _RpcBDSNeo3_parseTransferNotification).call(this, notification);
+                if (transferEvent) {
+                    events.splice(index, 0, transferEvent);
+                }
+            }
+            if (eventName === 'vote') {
+                const voteEvent = __classPrivateFieldGet(this, _RpcBDSNeo3_instances, "m", _RpcBDSNeo3_parseVoteNotification).call(this, notification);
+                if (voteEvent) {
+                    events.splice(index, 0, voteEvent);
+                }
             }
-            const tokenHash = properties[3].value;
-            const [nft] = await blockchain_service_1.BSUtilsHelper.tryCatch(() => this._service.nftDataService.getNft({ collectionHash: contractHash, tokenHash }));
-            events.splice(index, 0, {
-                eventType: 'nft',
-                amount: '1',
-                methodName: 'transfer',
-                from: convertedFrom,
-                fromUrl,
-                to: convertedTo,
-                toUrl,
-                tokenType: 'nep-11',
-                nft,
-            });
         });
         await Promise.allSettled(promises);
         return events;
     }
-    getBridgeNeo3NeoXDataByNotifications(notifications) {
-        const gasNotification = notifications.find(({ eventname }) => eventname === 'NativeDeposit');
-        const isNativeToken = !!gasNotification;
-        const neoNotification = !isNativeToken
-            ? notifications.find(({ eventname }) => eventname === 'TokenDeposit')
-            : undefined;
-        const notification = isNativeToken ? gasNotification : neoNotification;
-        const notificationStateValue = notification?.state
-            ?.value;
-        if (!notificationStateValue)
-            return undefined;
-        let tokenToUse;
-        let amountInDecimals;
-        let byteStringReceiverAddress;
-        if (isNativeToken) {
-            tokenToUse = this._service.neo3NeoXBridgeService.gasToken;
-            amountInDecimals = notificationStateValue[2]?.value;
-            byteStringReceiverAddress = notificationStateValue[1]?.value;
-        }
-        else {
-            tokenToUse = this._service.neo3NeoXBridgeService.neoToken;
-            amountInDecimals = notificationStateValue[4]?.value;
-            byteStringReceiverAddress = notificationStateValue[3]?.value;
-        }
-        if (!tokenToUse || !amountInDecimals || !byteStringReceiverAddress)
-            return undefined;
-        const { u } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
-        return {
-            amount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(amountInDecimals, tokenToUse.decimals), {
-                decimals: tokenToUse.decimals,
-            }),
-            tokenToUse,
-            receiverAddress: `0x${u.HexString.fromBase64(byteStringReceiverAddress).toLittleEndian()}`,
-        };
-    }
     async getTransaction(hash) {
         try {
             const { rpc } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
@@ -111,7 +47,12 @@ class RpcBDSNeo3 {
             const events = await this._extractEventsFromNotifications(notifications);
             const txId = response.hash;
             const txIdUrl = this._service.explorerService.buildTransactionUrl(txId);
-            let transaction = {
+            const data = {
+                ...this._service.neo3NeoXBridgeService._getDataFromNotifications(notifications),
+                ...this._service.claimService._getTransactionDataFromEvents(events),
+                ...this._service.voteService._getTransactionDataFromEvents(events),
+            };
+            const transaction = {
                 txId,
                 txIdUrl,
                 block: response.validuntilblock,
@@ -124,14 +65,10 @@ class RpcBDSNeo3 {
                 }),
                 invocationCount: 0,
                 notificationCount: notifications.length,
-                type: 'default',
                 view: 'default',
                 events,
+                data,
             };
-            const bridgeNeo3NeoXData = this.getBridgeNeo3NeoXDataByNotifications(notifications);
-            if (bridgeNeo3NeoXData) {
-                transaction = { ...transaction, type: 'bridgeNeo3NeoX', data: bridgeNeo3NeoXData };
-            }
             return transaction;
         }
         catch {
@@ -245,4 +182,54 @@ _RpcBDSNeo3_instances = new WeakSet(), _RpcBDSNeo3_convertByteStringToAddress =
     const { wallet, u } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
     const account = new wallet.Account(u.reverseHex(u.HexString.fromBase64(byteString).toString()));
     return account.address;
+}, _RpcBDSNeo3_parseTransferNotification = async function _RpcBDSNeo3_parseTransferNotification({ contract: contractHash, state, }) {
+    const properties = (Array.isArray(state) ? state : (state?.value ?? []));
+    if (properties.length !== 3 && properties.length !== 4)
+        return;
+    const isAsset = properties.length === 3;
+    const from = properties[0].value;
+    const to = properties[1].value;
+    const convertedFrom = from ? __classPrivateFieldGet(this, _RpcBDSNeo3_instances, "m", _RpcBDSNeo3_convertByteStringToAddress).call(this, from) : undefined;
+    const convertedTo = to ? __classPrivateFieldGet(this, _RpcBDSNeo3_instances, "m", _RpcBDSNeo3_convertByteStringToAddress).call(this, to) : undefined;
+    const fromUrl = convertedFrom ? this._service.explorerService.buildAddressUrl(convertedFrom) : undefined;
+    const toUrl = convertedTo ? this._service.explorerService.buildAddressUrl(convertedTo) : undefined;
+    if (isAsset) {
+        const token = await this.getTokenInfo(contractHash);
+        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,
+            }),
+            methodName: 'transfer',
+            from: convertedFrom,
+            fromUrl,
+            to: convertedTo,
+            toUrl,
+            tokenUrl: this._service.explorerService.buildContractUrl(contractHash),
+            token,
+        };
+    }
+    const tokenHash = properties[3].value;
+    const [nft] = await blockchain_service_1.BSUtilsHelper.tryCatch(() => this._service.nftDataService.getNft({ collectionHash: contractHash, tokenHash }));
+    return {
+        eventType: 'nft',
+        amount: '1',
+        methodName: 'transfer',
+        from: convertedFrom,
+        fromUrl,
+        to: convertedTo,
+        toUrl,
+        nft,
+    };
+}, _RpcBDSNeo3_parseVoteNotification = function _RpcBDSNeo3_parseVoteNotification({ state }) {
+    const properties = (Array.isArray(state) ? state : (state?.value ?? []));
+    if (properties.length !== 4)
+        return;
+    const from = properties[0].value;
+    const convertedFrom = __classPrivateFieldGet(this, _RpcBDSNeo3_instances, "m", _RpcBDSNeo3_convertByteStringToAddress).call(this, from);
+    const candidatePubKeyBase64 = properties[2].value;
+    const { u } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
+    const candidate = u.HexString.fromBase64(candidatePubKeyBase64).toString();
+    return this._service.voteService._buildTransactionEvent(convertedFrom, candidate);
 };

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

@@ -0,0 +1,15 @@
+import type { IBSNeo3, TBSNeo3Name } from '../../types';
+import type { IClaimService, TBSAccount, TClaimServiceTransactionData, TTransaction, TTransactionDefault, TTransactionDefaultEvent, TTransactionDefaultTokenEvent } from '@cityofzion/blockchain-service';
+export declare class ClaimServiceNeo3 implements IClaimService<TBSNeo3Name> {
+    #private;
+    readonly _service: IBSNeo3;
+    claimToken: import("@cityofzion/blockchain-service").TBSToken;
+    burnToken: import("@cityofzion/blockchain-service").TBSToken;
+    constructor(service: IBSNeo3);
+    _getTransactionDataFromEvents(events: TTransactionDefaultEvent[]): TClaimServiceTransactionData | undefined;
+    _buildTransactionEvent(address: string): Promise<TTransactionDefaultTokenEvent>;
+    getUnclaimed(address: string): Promise<string>;
+    calculateFee(senderAccount: TBSAccount<TBSNeo3Name>): Promise<string>;
+    claim(senderAccount: TBSAccount<TBSNeo3Name>): Promise<TTransactionDefault>;
+    getTransactionData(transaction: TTransaction): TClaimServiceTransactionData | undefined;
+}

package/dist/services/claim/ClaimServiceNeo3.js

@@ -0,0 +1,79 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 _ClaimServiceNeo3_instances, _ClaimServiceNeo3_buildClaimParams;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaimServiceNeo3 = void 0;
+const BSNeo3NeonJsSingletonHelper_1 = require("../../helpers/BSNeo3NeonJsSingletonHelper");
+const BSNeo3Constants_1 = require("../../constants/BSNeo3Constants");
+class ClaimServiceNeo3 {
+    constructor(service) {
+        _ClaimServiceNeo3_instances.add(this);
+        this.claimToken = BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN;
+        this.burnToken = BSNeo3Constants_1.BSNeo3Constants.NEO_TOKEN;
+        this._service = service;
+    }
+    _getTransactionDataFromEvents(events) {
+        if (!events?.length)
+            return;
+        const claimEvent = events.find(event => {
+            return (event.eventType === 'token' &&
+                event.token?.hash === this.claimToken.hash &&
+                event.methodName === 'transfer' &&
+                !event.from);
+        });
+        if (!claimEvent || !claimEvent.amount)
+            return;
+        const hasBurnEvent = events.some(event => event.eventType === 'token' &&
+            event.token?.hash === this.burnToken.hash &&
+            event.methodName === 'transfer' &&
+            event.from === claimEvent.to);
+        if (!hasBurnEvent)
+            return;
+        return { isClaim: true };
+    }
+    async _buildTransactionEvent(address) {
+        const amount = await this.getUnclaimed(address);
+        return {
+            eventType: 'token',
+            amount,
+            methodName: 'transfer',
+            to: address,
+            toUrl: this._service.explorerService.buildAddressUrl(address),
+            tokenUrl: this._service.explorerService.buildContractUrl(this.claimToken.hash),
+            token: this.claimToken,
+        };
+    }
+    async getUnclaimed(address) {
+        const { rpc, u } = 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);
+    }
+    async calculateFee(senderAccount) {
+        const claimParams = __classPrivateFieldGet(this, _ClaimServiceNeo3_instances, "m", _ClaimServiceNeo3_buildClaimParams).call(this, senderAccount);
+        return this._service.calculateTransferFee(claimParams);
+    }
+    async claim(senderAccount) {
+        const claimParams = __classPrivateFieldGet(this, _ClaimServiceNeo3_instances, "m", _ClaimServiceNeo3_buildClaimParams).call(this, senderAccount);
+        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;
+        return transaction;
+    }
+    getTransactionData(transaction) {
+        return transaction.data?.isClaim === true ? transaction.data : undefined;
+    }
+}
+exports.ClaimServiceNeo3 = ClaimServiceNeo3;
+_ClaimServiceNeo3_instances = new WeakSet(), _ClaimServiceNeo3_buildClaimParams = function _ClaimServiceNeo3_buildClaimParams(senderAccount) {
+    return {
+        senderAccount,
+        intents: [{ amount: '0', receiverAddress: senderAccount.address, token: this.burnToken }],
+    };
+};

package/dist/services/exchange-data/FlamingoForthewinEDSNeo3.d.ts

@@ -1,7 +1,7 @@
 import { FlamingoForthewinEDS, type TGetTokenPriceHistoryParams, type TGetTokenPricesParams, type TTokenPricesHistoryResponse, type TTokenPricesResponse } from '@cityofzion/blockchain-service';
-import type { IBSNeo3 } from '../../types';
-export declare class FlamingoForthewinEDSNeo3<N extends string> extends FlamingoForthewinEDS<N> {
-    constructor(service: IBSNeo3<N>);
+import type { IBSNeo3, TBSNeo3Name, TBSNeo3NetworkId } from '../../types';
+export declare class FlamingoForthewinEDSNeo3 extends FlamingoForthewinEDS<TBSNeo3Name, TBSNeo3NetworkId> {
+    constructor(service: IBSNeo3);
     getTokenPrices(params: TGetTokenPricesParams): Promise<TTokenPricesResponse[]>;
     getTokenPriceHistory(params: TGetTokenPriceHistoryParams): Promise<TTokenPricesHistoryResponse[]>;
 }

package/dist/services/exchange-data/FlamingoForthewinEDSNeo3.js

@@ -2,18 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlamingoForthewinEDSNeo3 = void 0;
 const blockchain_service_1 = require("@cityofzion/blockchain-service");
-const BSNeo3Helper_1 = require("../../helpers/BSNeo3Helper");
 class FlamingoForthewinEDSNeo3 extends blockchain_service_1.FlamingoForthewinEDS {
     constructor(service) {
         super(service);
     }
     async getTokenPrices(params) {
-        if (!BSNeo3Helper_1.BSNeo3Helper.isMainnetNetwork(this._service.network))
+        if (this._service.network.type !== 'mainnet')
             throw new Error('Exchange is only available on Mainnet');
         return await super.getTokenPrices(params);
     }
     async getTokenPriceHistory(params) {
-        if (!BSNeo3Helper_1.BSNeo3Helper.isMainnetNetwork(this._service.network))
+        if (this._service.network.type !== 'mainnet')
             throw new Error('Exchange is only available on Mainnet');
         return await super.getTokenPriceHistory(params);
     }

package/dist/services/explorer/DoraESNeo3.d.ts

@@ -1,8 +1,8 @@
 import { type TBuildNftUrlParams, type IExplorerService } from '@cityofzion/blockchain-service';
 import type { IBSNeo3 } from '../../types';
-export declare class DoraESNeo3<N extends string> implements IExplorerService {
+export declare class DoraESNeo3 implements IExplorerService {
     #private;
-    constructor(service: IBSNeo3<N>);
+    constructor(service: IBSNeo3);
     buildTransactionUrl(transactionId: string): string | undefined;
     buildContractUrl(contractHash: string): string | undefined;
     buildNftUrl({ tokenHash, collectionHash }: TBuildNftUrlParams): string | undefined;

package/dist/services/explorer/DoraESNeo3.js

@@ -14,14 +14,13 @@ var _DoraESNeo3_instances, _DoraESNeo3_service, _DoraESNeo3_baseUrl, _DoraESNeo3
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DoraESNeo3 = void 0;
 const blockchain_service_1 = require("@cityofzion/blockchain-service");
-const BSNeo3Helper_1 = require("../../helpers/BSNeo3Helper");
 class DoraESNeo3 {
     constructor(service) {
         _DoraESNeo3_instances.add(this);
         _DoraESNeo3_service.set(this, void 0);
         _DoraESNeo3_baseUrl.set(this, void 0);
         __classPrivateFieldSet(this, _DoraESNeo3_service, service, "f");
-        if (!BSNeo3Helper_1.BSNeo3Helper.isCustomNetwork(__classPrivateFieldGet(this, _DoraESNeo3_service, "f").network)) {
+        if (service.network.type !== 'custom') {
             __classPrivateFieldSet(this, _DoraESNeo3_baseUrl, blockchain_service_1.BSCommonConstants.DORA_URL, "f");
         }
     }

package/dist/services/full-transactions-data/DoraFullTransactionsDataServiceNeo3.d.ts

@@ -1,10 +1,10 @@
 import { type IFullTransactionsDataService, type TExportFullTransactionsByAddressParams, type TGetFullTransactionsByAddressParams, type TGetTransactionsByAddressResponse, type TTransactionDefault } from '@cityofzion/blockchain-service';
 import type { IBSNeo3, TBSNeo3NetworkId } from '../../types';
-export declare class DoraFullTransactionsDataServiceNeo3<N extends string> implements IFullTransactionsDataService<N> {
+export declare class DoraFullTransactionsDataServiceNeo3 implements IFullTransactionsDataService {
     #private;
     static readonly SUPPORTED_NEP11_STANDARDS: string[];
     static readonly SUPPORTED_NETWORKS_IDS: TBSNeo3NetworkId[];
-    constructor(service: IBSNeo3<N>);
-    getFullTransactionsByAddress({ nextPageParams, ...params }: TGetFullTransactionsByAddressParams): Promise<TGetTransactionsByAddressResponse<N, TTransactionDefault<N>>>;
+    constructor(service: IBSNeo3);
+    getFullTransactionsByAddress({ nextPageParams, ...params }: TGetFullTransactionsByAddressParams): Promise<TGetTransactionsByAddressResponse<TTransactionDefault>>;
     exportFullTransactionsByAddress(params: TExportFullTransactionsByAddressParams): Promise<string>;
 }

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

@@ -41,25 +41,9 @@ class DoraFullTransactionsDataServiceNeo3 {
         const itemPromises = items.map(async ({ networkFeeAmount, systemFeeAmount, ...item }, index) => {
             const txId = item.transactionID;
             const txIdUrl = __classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_service, "f").explorerService.buildTransactionUrl(txId);
-            let newItem = {
-                txId,
-                txIdUrl,
-                block: item.block,
-                date: item.date,
-                invocationCount: item.invocationCount,
-                notificationCount: item.notificationCount,
-                networkFeeAmount: networkFeeAmount
-                    ? blockchain_service_1.BSBigNumberHelper.format(networkFeeAmount, { decimals: __classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_service, "f").feeToken.decimals })
-                    : undefined,
-                systemFeeAmount: systemFeeAmount
-                    ? blockchain_service_1.BSBigNumberHelper.format(systemFeeAmount, { decimals: __classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_service, "f").feeToken.decimals })
-                    : undefined,
-                type: 'default',
-                view: 'default',
-                events: [],
-            };
+            const events = [];
             const eventPromises = item.events.map(async (event, eventIndex) => {
-                const { methodName, tokenID: tokenHash, contractHash, contractName } = event;
+                const { methodName, tokenID: tokenHash, contractHash } = event;
                 const from = event.from || undefined;
                 const to = event.to || undefined;
                 const fromUrl = from ? __classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_service, "f").explorerService.buildAddressUrl(from) : undefined;
@@ -68,7 +52,7 @@ class DoraFullTransactionsDataServiceNeo3 {
                 const isNft = DoraFullTransactionsDataServiceNeo3.SUPPORTED_NEP11_STANDARDS.includes(standard) && !!tokenHash;
                 if (isNft) {
                     const [nft] = await blockchain_service_1.BSUtilsHelper.tryCatch(() => __classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_service, "f").nftDataService.getNft({ collectionHash: contractHash, tokenHash }));
-                    newItem.events.splice(eventIndex, 0, {
+                    events.splice(eventIndex, 0, {
                         eventType: 'nft',
                         amount: '1',
                         methodName,
@@ -76,13 +60,12 @@ class DoraFullTransactionsDataServiceNeo3 {
                         fromUrl,
                         to,
                         toUrl,
-                        tokenType: 'nep-11',
                         nft,
                     });
                     return;
                 }
                 const [token] = await blockchain_service_1.BSUtilsHelper.tryCatch(() => __classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_service, "f").blockchainDataService.getTokenInfo(contractHash));
-                newItem.events.splice(eventIndex, 0, {
+                events.splice(eventIndex, 0, {
                     eventType: 'token',
                     amount: event.amount
                         ? blockchain_service_1.BSBigNumberHelper.format(event.amount, { decimals: token?.decimals ?? event.tokenDecimals })
@@ -92,21 +75,45 @@ class DoraFullTransactionsDataServiceNeo3 {
                     fromUrl,
                     to,
                     toUrl,
-                    tokenType: 'nep-17',
                     tokenUrl: token ? __classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_service, "f").explorerService.buildContractUrl(token.hash) : undefined,
                     token,
                 });
-                if (newItem.type === 'default' && contractName === 'NeoXBridge') {
-                    const [log] = await blockchain_service_1.BSUtilsHelper.tryCatch(() => __classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_instances, "a", _DoraFullTransactionsDataServiceNeo3_api_get).log(txId, __classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_service, "f").network.id));
-                    if (!!log && log.vmstate === 'HALT') {
-                        const notifications = log.notifications;
-                        const data = DoraBDSNeo3_1.DoraBDSNeo3.getBridgeNeo3NeoXDataByNotifications(notifications ?? [], __classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_service, "f"));
-                        if (data)
-                            newItem = { ...newItem, type: 'bridgeNeo3NeoX', data };
-                    }
-                }
             });
             await Promise.allSettled(eventPromises);
+            let data = {
+                ...__classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_service, "f").claimService._getTransactionDataFromEvents(events),
+                ...__classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_service, "f").voteService._getTransactionDataFromEvents(events),
+            };
+            if (item.events.some(event => event.contractName === 'NeoXBridge')) {
+                const [log] = await blockchain_service_1.BSUtilsHelper.tryCatch(() => __classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_instances, "a", _DoraFullTransactionsDataServiceNeo3_api_get).log(txId, __classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_service, "f").network.id));
+                if (log) {
+                    data = {
+                        ...data,
+                        ...__classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_service, "f").neo3NeoXBridgeService._getDataFromNotifications(log.notifications.map((notification) => ({
+                            contract: notification.contract,
+                            eventname: notification.event_name,
+                            state: notification.state,
+                        }))),
+                    };
+                }
+            }
+            const newItem = {
+                txId,
+                txIdUrl,
+                block: item.block,
+                date: item.date,
+                invocationCount: item.invocationCount,
+                notificationCount: item.notificationCount,
+                networkFeeAmount: networkFeeAmount
+                    ? blockchain_service_1.BSBigNumberHelper.format(networkFeeAmount, { decimals: __classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_service, "f").feeToken.decimals })
+                    : undefined,
+                systemFeeAmount: systemFeeAmount
+                    ? blockchain_service_1.BSBigNumberHelper.format(systemFeeAmount, { decimals: __classPrivateFieldGet(this, _DoraFullTransactionsDataServiceNeo3_service, "f").feeToken.decimals })
+                    : undefined,
+                view: 'default',
+                events,
+                data,
+            };
             transactions.splice(index, 0, newItem);
         });
         await Promise.allSettled(itemPromises);

package/dist/services/ledger/NeonDappKitLedgerServiceNeo3.d.ts

@@ -1,14 +1,14 @@
 import { type TBSAccount, type TGetLedgerTransport, type ILedgerService, type TLedgerServiceEmitter, type TUntilIndexRecord } from '@cityofzion/blockchain-service';
 import Transport from '@ledgerhq/hw-transport';
-import { type IBSNeo3 } from '../../types';
+import { type IBSNeo3, type TBSNeo3Name } from '../../types';
 import { api } from '../../helpers/BSNeo3NeonJsSingletonHelper';
-export declare class NeonDappKitLedgerServiceNeo3<N extends string = string> implements ILedgerService<N> {
+export declare class NeonDappKitLedgerServiceNeo3 implements ILedgerService<TBSNeo3Name> {
     #private;
-    readonly getLedgerTransport?: TGetLedgerTransport<N>;
+    readonly getLedgerTransport?: TGetLedgerTransport<TBSNeo3Name>;
     emitter: TLedgerServiceEmitter;
-    constructor(blockchainService: IBSNeo3<N>, getLedgerTransport?: TGetLedgerTransport<N>);
+    constructor(blockchainService: IBSNeo3, getLedgerTransport?: TGetLedgerTransport<TBSNeo3Name>);
     verifyAppName(transport: Transport): Promise<boolean>;
-    getAccount(transport: Transport, index: number): Promise<TBSAccount<N>>;
-    getAccounts(transport: Transport, untilIndexByBlockchainService?: TUntilIndexRecord<N>): Promise<TBSAccount<N>[]>;
-    getSigningCallback(transport: Transport, account: TBSAccount<N>): api.SigningFunction;
+    getAccount(transport: Transport, index: number): Promise<TBSAccount<TBSNeo3Name>>;
+    getAccounts(transport: Transport, untilIndexByBlockchainService?: TUntilIndexRecord<TBSNeo3Name>): Promise<TBSAccount<TBSNeo3Name>[]>;
+    getSigningCallback(transport: Transport, account: TBSAccount<TBSNeo3Name>): api.SigningFunction;
 }

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

@@ -1,15 +1,17 @@
-import { INeo3NeoXBridgeService, TBridgeToken, TNeo3NeoXBridgeServiceBridgeParam, TNeo3NeoXBridgeServiceConstants, TNeo3NeoXBridgeServiceGetNonceParams, TNeo3NeoXBridgeServiceGetTransactionHashByNonceParams } from '@cityofzion/blockchain-service';
-import type { IBSNeo3 } from '../../types';
-export declare class Neo3NeoXBridgeService<N extends string> implements INeo3NeoXBridgeService<N> {
+import { INeo3NeoXBridgeService, TBridgeToken, TNeo3NeoXBridgeServiceBridgeParam, TNeo3NeoXBridgeServiceConstants, TNeo3NeoXBridgeServiceGetNonceParams, TNeo3NeoXBridgeServiceGetTransactionHashByNonceParams, type TNeo3NeoXBridgeTransactionData, type TTransaction } from '@cityofzion/blockchain-service';
+import type { IBSNeo3, TBSNeo3Name, TRpcBDSNeo3Notification } from '../../types';
+export declare class Neo3NeoXBridgeService implements INeo3NeoXBridgeService<TBSNeo3Name> {
     #private;
     static readonly BRIDGE_SCRIPT_HASH: string;
-    readonly gasToken: TBridgeToken<N>;
-    readonly neoToken: TBridgeToken<N>;
-    constructor(service: IBSNeo3<N>);
+    readonly gasToken: TBridgeToken<TBSNeo3Name>;
+    readonly neoToken: TBridgeToken<TBSNeo3Name>;
+    constructor(service: IBSNeo3);
+    _getDataFromNotifications(notifications: TRpcBDSNeo3Notification[]): TNeo3NeoXBridgeTransactionData<TBSNeo3Name> | undefined;
     getApprovalFee(): Promise<string>;
-    getBridgeConstants(token: TBridgeToken<N>): Promise<TNeo3NeoXBridgeServiceConstants>;
-    bridge(params: TNeo3NeoXBridgeServiceBridgeParam<N>): Promise<string>;
-    getNonce(params: TNeo3NeoXBridgeServiceGetNonceParams<N>): Promise<string>;
-    getTransactionHashByNonce(params: TNeo3NeoXBridgeServiceGetTransactionHashByNonceParams<N>): Promise<string>;
-    getTokenByMultichainId(multichainId: string): TBridgeToken<N> | undefined;
+    getBridgeConstants(token: TBridgeToken<TBSNeo3Name>): Promise<TNeo3NeoXBridgeServiceConstants>;
+    bridge(params: TNeo3NeoXBridgeServiceBridgeParam<TBSNeo3Name>): Promise<string>;
+    getNonce(params: TNeo3NeoXBridgeServiceGetNonceParams<TBSNeo3Name>): Promise<string>;
+    getTransactionHashByNonce(params: TNeo3NeoXBridgeServiceGetTransactionHashByNonceParams<TBSNeo3Name>): Promise<string>;
+    getTokenByMultichainId(multichainId: string): TBridgeToken<TBSNeo3Name> | undefined;
+    getTransactionData(transaction: TTransaction): TNeo3NeoXBridgeTransactionData<TBSNeo3Name> | undefined;
 }

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

@@ -19,9 +19,9 @@ exports.Neo3NeoXBridgeService = void 0;
 const blockchain_service_1 = require("@cityofzion/blockchain-service");
 const BSNeo3Constants_1 = require("../../constants/BSNeo3Constants");
 const axios_1 = __importDefault(require("axios"));
-const BSNeo3Helper_1 = require("../../helpers/BSNeo3Helper");
 const DoraBDSNeo3_1 = require("../blockchain-data/DoraBDSNeo3");
 const BSNeo3NeonDappKitSingletonHelper_1 = require("../../helpers/BSNeo3NeonDappKitSingletonHelper");
+const BSNeo3NeonJsSingletonHelper_1 = require("../../helpers/BSNeo3NeonJsSingletonHelper");
 class Neo3NeoXBridgeService {
     constructor(service) {
         _Neo3NeoXBridgeService_service.set(this, void 0);
@@ -29,6 +29,43 @@ class Neo3NeoXBridgeService {
         this.gasToken = { ...BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN, blockchain: service.name, multichainId: 'gas' };
         this.neoToken = { ...BSNeo3Constants_1.BSNeo3Constants.NEO_TOKEN, blockchain: service.name, multichainId: 'neo' };
     }
+    _getDataFromNotifications(notifications) {
+        const gasNotification = notifications.find(({ eventname }) => eventname === 'NativeDeposit');
+        const isNativeToken = !!gasNotification;
+        const neoNotification = !isNativeToken
+            ? notifications.find(({ eventname }) => eventname === 'TokenDeposit')
+            : undefined;
+        const notification = isNativeToken ? gasNotification : neoNotification;
+        const notificationStateValue = notification?.state
+            ?.value;
+        if (!notificationStateValue)
+            return undefined;
+        let tokenToUse;
+        let amountInDecimals;
+        let byteStringReceiverAddress;
+        if (isNativeToken) {
+            tokenToUse = this.gasToken;
+            amountInDecimals = notificationStateValue[2]?.value;
+            byteStringReceiverAddress = notificationStateValue[1]?.value;
+        }
+        else {
+            tokenToUse = this.neoToken;
+            amountInDecimals = notificationStateValue[4]?.value;
+            byteStringReceiverAddress = notificationStateValue[3]?.value;
+        }
+        if (!tokenToUse || !amountInDecimals || !byteStringReceiverAddress)
+            return undefined;
+        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,
+                }),
+                tokenToUse,
+                receiverAddress: `0x${u.HexString.fromBase64(byteStringReceiverAddress).toLittleEndian()}`,
+            },
+        };
+    }
     async getApprovalFee() {
         throw new blockchain_service_1.BSError('Neo3 does not require approval', 'APPROVAl_NOT_NEEDED');
     }
@@ -86,11 +123,11 @@ class Neo3NeoXBridgeService {
         };
     }
     async bridge(params) {
-        if (!BSNeo3Helper_1.BSNeo3Helper.isMainnetNetwork(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network)) {
+        if (__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.type !== 'mainnet') {
             throw new blockchain_service_1.BSError('Bridging to NeoX is only supported on mainnet', 'UNSUPPORTED_NETWORK');
         }
         const { account } = params;
-        const { neonJsAccount, signingCallback } = await __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").generateSigningCallback(account);
+        const { neonJsAccount, signingCallback } = await __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f")._generateSigningCallback(account);
         const { NeonInvoker } = BSNeo3NeonDappKitSingletonHelper_1.BSNeo3NeonDappKitSingletonHelper.getInstance();
         const invoker = await NeonInvoker.init({
             rpcAddress: __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.url,
@@ -194,6 +231,9 @@ class Neo3NeoXBridgeService {
         const tokens = [this.gasToken, this.neoToken];
         return tokens.find(token => token.multichainId === multichainId);
     }
+    getTransactionData(transaction) {
+        return transaction.data?.neo3NeoxBridge ? transaction.data : undefined;
+    }
 }
 exports.Neo3NeoXBridgeService = Neo3NeoXBridgeService;
 _Neo3NeoXBridgeService_service = new WeakMap();

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

@@ -1,8 +1,8 @@
 import { GhostMarketNDS, type THasTokenParams } from '@cityofzion/blockchain-service';
-import type { IBSNeo3, TBSNeo3NetworkId } from '../../types';
-export declare class GhostMarketNDSNeo3<N extends string> extends GhostMarketNDS<N, TBSNeo3NetworkId, IBSNeo3<N>> {
+import type { IBSNeo3, TBSNeo3Name, TBSNeo3NetworkId } from '../../types';
+export declare class GhostMarketNDSNeo3 extends GhostMarketNDS<TBSNeo3Name, TBSNeo3NetworkId, IBSNeo3> {
     static readonly CHAIN_BY_NETWORK_ID: Record<TBSNeo3NetworkId, string>;
-    constructor(service: IBSNeo3<N>);
+    constructor(service: IBSNeo3);
     hasToken({ address, collectionHash }: THasTokenParams): Promise<boolean>;
     getChain(): string;
 }

package/dist/services/token/TokenServiceNeo3.d.ts

@@ -1,4 +1,5 @@
 import { TokenService } from '@cityofzion/blockchain-service';
-export declare class TokenServiceNeo3 extends TokenService {
+import type { TBSNeo3Name, TBSNeo3NetworkId } from '../../types';
+export declare class TokenServiceNeo3 extends TokenService<TBSNeo3Name, TBSNeo3NetworkId> {
     normalizeHash(hash: string): string;
 }