@cityofzion/bs-neo3 1.14.1 → 1.15.1

package/dist/BSNeo3.d.ts

@@ -1,8 +1,8 @@
-import { Account, BDSClaimable, BlockchainDataService, BlockchainService, BSCalculableFee, BSClaimable, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft, ExchangeDataService, ExplorerService, GetLedgerTransport, Network, NftDataService, Token, TransferParam } from '@cityofzion/blockchain-service';
+import { Account, BDSClaimable, BlockchainDataService, BlockchainService, BSCalculableFee, BSClaimable, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft, ExchangeDataService, ExplorerService, GetLedgerTransport, IBSWithNeo3NeoXBridge, INeo3NeoXBridgeService, Network, NftDataService, Token, TransferParam } from '@cityofzion/blockchain-service';
 import { NeonDappKitLedgerServiceNeo3 } from './services/ledger/NeonDappKitLedgerServiceNeo3';
 import { BSNeo3NetworkId } from './constants/BSNeo3Constants';
 import { GenerateSigningCallbackResponse, VoteService } from './interfaces';
-export declare class BSNeo3<BSName extends string = string> implements BlockchainService<BSName, BSNeo3NetworkId>, BSClaimable<BSName>, BSWithNameService, BSCalculableFee<BSName>, BSWithNft, BSWithExplorerService, BSWithLedger<BSName> {
+export declare class BSNeo3<BSName extends string = string> implements BlockchainService<BSName, BSNeo3NetworkId>, BSClaimable<BSName>, BSWithNameService, BSCalculableFee<BSName>, BSWithNft, BSWithExplorerService, BSWithLedger<BSName>, IBSWithNeo3NeoXBridge<BSName> {
     #private;
     name: BSName;
     bip44DerivationPath: string;
@@ -17,6 +17,7 @@ export declare class BSNeo3<BSName extends string = string> implements Blockchai
     exchangeDataService: ExchangeDataService;
     explorerService: ExplorerService;
     voteService: VoteService<BSName>;
+    neo3NeoXBridgeService: INeo3NeoXBridgeService<BSName>;
     network: Network<BSNeo3NetworkId>;
     constructor(name: BSName, network?: Network<BSNeo3NetworkId>, getLedgerTransport?: GetLedgerTransport<BSName>);
     generateSigningCallback(account: Account<BSName>): Promise<GenerateSigningCallbackResponse>;

package/dist/BSNeo3.js

@@ -16,6 +16,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _BSNeo3_instances, _BSNeo3_setTokens, _BSNeo3_buildTransferInvocation;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSNeo3 = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
 const bs_asteroid_sdk_1 = require("@cityofzion/bs-asteroid-sdk");
 const neon_dappkit_1 = require("@cityofzion/neon-dappkit");
 const neon_js_1 = require("@cityofzion/neon-js");
@@ -27,6 +28,7 @@ const NeonDappKitLedgerServiceNeo3_1 = require("./services/ledger/NeonDappKitLed
 const GhostMarketNDSNeo3_1 = require("./services/nft-data/GhostMarketNDSNeo3");
 const BSNeo3Constants_1 = require("./constants/BSNeo3Constants");
 const RpcBDSNeo3_1 = require("./services/blockchain-data/RpcBDSNeo3");
+const Neo3NeoXBridgeService_1 = require("./services/neo3neoXBridge/Neo3NeoXBridgeService");
 const DoraVoteServiceNeo3_1 = require("./services/vote/DoraVoteServiceNeo3");
 class BSNeo3 {
     constructor(name, network, getLedgerTransport) {
@@ -69,6 +71,7 @@ class BSNeo3 {
         this.nftDataService = new GhostMarketNDSNeo3_1.GhostMarketNDSNeo3(network);
         this.explorerService = new DoraESNeo3_1.DoraESNeo3(network);
         this.voteService = new DoraVoteServiceNeo3_1.DoraVoteServiceNeo3(this);
+        this.neo3NeoXBridgeService = new Neo3NeoXBridgeService_1.Neo3NeoXBridgeService(this);
         this.blockchainDataService = new DoraBDSNeo3_1.DoraBDSNeo3(network, this.feeToken, this.claimToken, this.tokens, this.nftDataService, this.explorerService);
         this.exchangeDataService = new FlamingoForthewinEDSNeo3_1.FlamingoForthewinEDSNeo3(network);
     }
@@ -216,9 +219,7 @@ _BSNeo3_instances = new WeakSet(), _BSNeo3_setTokens = function _BSNeo3_setToken
                     { type: 'Hash160', value: intent.receiverAddress },
                     {
                         type: 'Integer',
-                        value: intent.tokenDecimals
-                            ? neon_js_1.u.BigInteger.fromDecimal(Number(intent.amount).toFixed(intent.tokenDecimals), intent.tokenDecimals).toString()
-                            : intent.amount,
+                        value: blockchain_service_1.BSBigNumberHelper.toDecimals(blockchain_service_1.BSBigNumberHelper.fromNumber(intent.amount), decimals),
                     },
                     { type: 'Any', value: null },
                 ],

package/dist/assets/tokens/native.json

@@ -2,13 +2,13 @@
     {
         "symbol": "GAS",
         "name": "GAS",
-        "hash": "d2a4cff31913016155e38e474a2c06d08be276cf",
+        "hash": "0xd2a4cff31913016155e38e474a2c06d08be276cf",
         "decimals": 8
     },
     {
         "symbol": "NEO",
         "name": "NEO",
-        "hash": "ef4073a0f2b305a38ec4050e4d3d28bc40ea63f5",
+        "hash": "0xef4073a0f2b305a38ec4050e4d3d28bc40ea63f5",
         "decimals": 0
     }
 ]

package/dist/constants/BSNeo3Constants.d.ts

@@ -2,6 +2,9 @@ import { Network, NetworkId, Token } from '@cityofzion/blockchain-service';
 export type BSNeo3NetworkId = NetworkId<'mainnet' | 'testnet'>;
 export declare class BSNeo3Constants {
     static EXTRA_TOKENS_BY_NETWORK_ID: Partial<Record<BSNeo3NetworkId, Token[]>>;
+    static NATIVE_ASSETS: Token[];
+    static GAS_TOKEN: Token;
+    static NEO_TOKEN: Token;
     static RPC_LIST_BY_NETWORK_ID: Partial<Record<BSNeo3NetworkId, string[]>>;
     static MAINNET_NETWORK_IDS: BSNeo3NetworkId[];
     static TESTNET_NETWORK_IDS: BSNeo3NetworkId[];
@@ -12,5 +15,4 @@ export declare class BSNeo3Constants {
     static DEFAULT_NETWORK: Network<BSNeo3NetworkId>;
     static NEO_NS_HASH: string;
     static DEFAULT_BIP44_DERIVATION_PATH: string;
-    static NATIVE_ASSETS: Token[];
 }

package/dist/constants/BSNeo3Constants.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSNeo3Constants = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
 const mainnet_json_1 = __importDefault(require("../assets/tokens/mainnet.json"));
 const native_json_1 = __importDefault(require("../assets/tokens/native.json"));
 class BSNeo3Constants {
@@ -12,8 +13,11 @@ class BSNeo3Constants {
 exports.BSNeo3Constants = BSNeo3Constants;
 _a = BSNeo3Constants;
 BSNeo3Constants.EXTRA_TOKENS_BY_NETWORK_ID = {
-    mainnet: mainnet_json_1.default,
+    mainnet: blockchain_service_1.BSTokenHelper.normalizeToken(mainnet_json_1.default),
 };
+BSNeo3Constants.NATIVE_ASSETS = blockchain_service_1.BSTokenHelper.normalizeToken(native_json_1.default);
+BSNeo3Constants.GAS_TOKEN = _a.NATIVE_ASSETS.find(token => token.name === 'GAS');
+BSNeo3Constants.NEO_TOKEN = _a.NATIVE_ASSETS.find(token => token.name === 'NEO');
 BSNeo3Constants.RPC_LIST_BY_NETWORK_ID = {
     mainnet: [
         'https://mainnet1.neo.coz.io:443',
@@ -55,7 +59,7 @@ BSNeo3Constants.TESTNET_NETWORKS = [
     },
 ];
 BSNeo3Constants.ALL_NETWORKS = [..._a.MAINNET_NETWORKS, ..._a.TESTNET_NETWORKS];
+// If tou change this, make sure to update the tests accordingly
 BSNeo3Constants.DEFAULT_NETWORK = _a.MAINNET_NETWORKS[0];
 BSNeo3Constants.NEO_NS_HASH = '0x50ac1c37690cc2cfc594472833cf57505d5f46de';
 BSNeo3Constants.DEFAULT_BIP44_DERIVATION_PATH = "m/44'/888'/0'/0/?";
-BSNeo3Constants.NATIVE_ASSETS = native_json_1.default;

package/dist/helpers/BSNeo3Helper.d.ts

@@ -1,14 +1,8 @@
 import { Network } from '@cityofzion/blockchain-service';
 import { BSNeo3NetworkId } from '../constants/BSNeo3Constants';
 export declare class BSNeo3Helper {
-    static getTokens(network: Network<BSNeo3NetworkId>): {
-        symbol: string;
-        name: string;
-        hash: string;
-        decimals: number;
-    }[];
+    static getTokens(network: Network<BSNeo3NetworkId>): import("@cityofzion/blockchain-service").Token[];
     static getRpcList(network: Network<BSNeo3NetworkId>): string[];
     static isMainnet(network: Network<BSNeo3NetworkId>): boolean;
     static isCustomNet(network: Network<BSNeo3NetworkId>): boolean;
-    static normalizeHash(hash: string): string;
 }

package/dist/helpers/BSNeo3Helper.js

@@ -1,17 +1,12 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSNeo3Helper = void 0;
-const blockchain_service_1 = require("@cityofzion/blockchain-service");
-const native_json_1 = __importDefault(require("../assets/tokens/native.json"));
 const BSNeo3Constants_1 = require("../constants/BSNeo3Constants");
 class BSNeo3Helper {
     static getTokens(network) {
         var _a;
         const extraTokens = (_a = BSNeo3Constants_1.BSNeo3Constants.EXTRA_TOKENS_BY_NETWORK_ID[network.id]) !== null && _a !== void 0 ? _a : [];
-        return [...extraTokens, ...native_json_1.default];
+        return [...extraTokens, ...BSNeo3Constants_1.BSNeo3Constants.NATIVE_ASSETS];
     }
     static getRpcList(network) {
         var _a;
@@ -23,8 +18,5 @@ class BSNeo3Helper {
     static isCustomNet(network) {
         return !BSNeo3Constants_1.BSNeo3Constants.ALL_NETWORK_IDS.includes(network.id);
     }
-    static normalizeHash(hash) {
-        return (0, blockchain_service_1.normalizeHash)(hash, { lowercase: false });
-    }
 }
 exports.BSNeo3Helper = BSNeo3Helper;

package/dist/index.d.ts

@@ -8,3 +8,4 @@ export * from './services/explorer/DoraESNeo3';
 export * from './services/ledger/NeonDappKitLedgerServiceNeo3';
 export * from './services/nft-data/GhostMarketNDSNeo3';
 export * from './services/nft-data/RpcNDSNeo3';
+export * from './interfaces';

package/dist/index.js

@@ -24,3 +24,4 @@ __exportStar(require("./services/explorer/DoraESNeo3"), exports);
 __exportStar(require("./services/ledger/NeonDappKitLedgerServiceNeo3"), exports);
 __exportStar(require("./services/nft-data/GhostMarketNDSNeo3"), exports);
 __exportStar(require("./services/nft-data/RpcNDSNeo3"), exports);
+__exportStar(require("./interfaces"), exports);

package/dist/interfaces.d.ts

@@ -5,7 +5,7 @@ export type GenerateSigningCallbackResponse = {
     neonJsAccount: Neon.wallet.Account;
     signingCallback: api.SigningFunction;
 };
-type Candidate = {
+export type Candidate = {
     position: number;
     name: string;
     description: string;
@@ -20,9 +20,10 @@ type Candidate = {
 };
 export type GetCandidatesToVoteResponse = Candidate[];
 export type GetVoteDetailsByAddressResponse = {
-    candidateName: string;
-    candidatePubKey: string;
+    candidateName?: string;
+    candidatePubKey?: string;
     neoBalance: number;
+    address: string;
 };
 export type VoteParams<BSName extends string> = {
     account: Account<BSName>;
@@ -38,4 +39,3 @@ export interface VoteService<BSName extends string> {
     vote(params: VoteParams<BSName>): Promise<VoteResponse>;
     calculateVoteFee(params: CalculateVoteFeeParams<BSName>): Promise<string>;
 }
-export {};

package/dist/services/blockchain-data/DoraBDSNeo3.d.ts

@@ -1,6 +1,8 @@
 import { BalanceResponse, ContractResponse, FullTransactionsByAddressParams, FullTransactionsByAddressResponse, Network, NftDataService, Token, TransactionResponse, TransactionsByAddressParams, TransactionsByAddressResponse, ExplorerService, ExportTransactionsByAddressParams } from '@cityofzion/blockchain-service';
+import { api } from '@cityofzion/dora-ts';
 import { BSNeo3NetworkId } from '../../constants/BSNeo3Constants';
 import { RpcBDSNeo3 } from './RpcBDSNeo3';
+export declare const DoraNeoRest: api.NeoRESTApi;
 export declare class DoraBDSNeo3 extends RpcBDSNeo3 {
     #private;
     constructor(network: Network<BSNeo3NetworkId>, feeToken: Token, claimToken: Token, tokens: Token[], nftDataService: NftDataService, explorerService: ExplorerService);

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

@@ -32,13 +32,13 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 var _DoraBDSNeo3_instances, _DoraBDSNeo3_supportedNep11Standards, _DoraBDSNeo3_nftDataService, _DoraBDSNeo3_explorerService, _DoraBDSNeo3_validateAddress, _DoraBDSNeo3_validateFullTransactionsByAddressParams, _DoraBDSNeo3_validateGetFullTransactionsByAddressParams;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DoraBDSNeo3 = void 0;
+exports.DoraBDSNeo3 = exports.DoraNeoRest = void 0;
 const blockchain_service_1 = require("@cityofzion/blockchain-service");
 const dora_ts_1 = require("@cityofzion/dora-ts");
 const neon_js_1 = require("@cityofzion/neon-js");
 const BSNeo3Helper_1 = require("../../helpers/BSNeo3Helper");
 const RpcBDSNeo3_1 = require("./RpcBDSNeo3");
-const NeoRest = new dora_ts_1.api.NeoRESTApi({
+exports.DoraNeoRest = new dora_ts_1.api.NeoRESTApi({
     doraUrl: blockchain_service_1.BSCommonConstants.DORA_URL,
     endpoint: '/api/v2/neo3',
 });
@@ -62,14 +62,15 @@ class DoraBDSNeo3 extends RpcBDSNeo3_1.RpcBDSNeo3 {
                 return yield _super.getTransaction.call(this, hash);
             }
             try {
-                const data = yield NeoRest.transaction(hash, this._network.id);
+                const data = yield exports.DoraNeoRest.transaction(hash, this._network.id);
+                const systemFeeNumber = blockchain_service_1.BSBigNumberHelper.fromNumber((_a = data.sysfee) !== null && _a !== void 0 ? _a : 0);
+                const networkFeeNumber = blockchain_service_1.BSBigNumberHelper.fromNumber((_b = data.netfee) !== null && _b !== void 0 ? _b : 0);
+                const totalFee = systemFeeNumber.plus(networkFeeNumber);
                 return {
                     block: data.block,
                     time: Number(data.time),
                     hash: data.hash,
-                    fee: neon_js_1.u.BigInteger.fromNumber((_a = data.netfee) !== null && _a !== void 0 ? _a : 0)
-                        .add(neon_js_1.u.BigInteger.fromNumber((_b = data.sysfee) !== null && _b !== void 0 ? _b : 0))
-                        .toDecimal(this._feeToken.decimals),
+                    fee: blockchain_service_1.BSBigNumberHelper.format(totalFee, { decimals: this._feeToken.decimals }),
                     notifications: [],
                     transfers: [],
                 };
@@ -87,7 +88,7 @@ class DoraBDSNeo3 extends RpcBDSNeo3_1.RpcBDSNeo3 {
             if (BSNeo3Helper_1.BSNeo3Helper.isCustomNet(this._network)) {
                 return yield _super.getTransactionsByAddress.call(this, { address, nextPageParams });
             }
-            const data = yield NeoRest.addressTXFull(address, nextPageParams, this._network.id);
+            const data = yield exports.DoraNeoRest.addressTXFull(address, nextPageParams, this._network.id);
             const promises = data.items.map((item) => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
                 const transferPromises = [];
@@ -130,13 +131,14 @@ class DoraBDSNeo3 extends RpcBDSNeo3_1.RpcBDSNeo3 {
                     eventName: notification.event_name,
                     state: notification.state,
                 }));
+                const systemFeeNumber = blockchain_service_1.BSBigNumberHelper.fromNumber((_a = item.sysfee) !== null && _a !== void 0 ? _a : 0);
+                const networkFeeNumber = blockchain_service_1.BSBigNumberHelper.fromNumber((_b = item.netfee) !== null && _b !== void 0 ? _b : 0);
+                const totalFee = systemFeeNumber.plus(networkFeeNumber);
                 return {
                     block: item.block,
                     time: Number(item.time),
                     hash: item.hash,
-                    fee: neon_js_1.u.BigInteger.fromNumber((_a = item.netfee) !== null && _a !== void 0 ? _a : 0)
-                        .add(neon_js_1.u.BigInteger.fromNumber((_b = item.sysfee) !== null && _b !== void 0 ? _b : 0))
-                        .toDecimal(this._feeToken.decimals),
+                    fee: blockchain_service_1.BSBigNumberHelper.format(totalFee, { decimals: this._feeToken.decimals }),
                     transfers,
                     notifications,
                 };
@@ -156,7 +158,7 @@ class DoraBDSNeo3 extends RpcBDSNeo3_1.RpcBDSNeo3 {
         return __awaiter(this, void 0, void 0, function* () {
             __classPrivateFieldGet(this, _DoraBDSNeo3_instances, "m", _DoraBDSNeo3_validateGetFullTransactionsByAddressParams).call(this, params);
             const data = [];
-            const response = yield NeoRest.getFullTransactionsByAddress({
+            const response = yield exports.DoraNeoRest.getFullTransactionsByAddress({
                 address: params.address,
                 timestampFrom: params.dateFrom,
                 timestampTo: params.dateTo,
@@ -180,10 +182,10 @@ class DoraBDSNeo3 extends RpcBDSNeo3_1.RpcBDSNeo3 {
                     invocationCount: item.invocationCount,
                     notificationCount: item.notificationCount,
                     networkFeeAmount: networkFeeAmount
-                        ? blockchain_service_1.BSNumberHelper.formatNumber(networkFeeAmount, { decimals: this._feeToken.decimals })
+                        ? blockchain_service_1.BSBigNumberHelper.format(networkFeeAmount, { decimals: this._feeToken.decimals })
                         : undefined,
                     systemFeeAmount: systemFeeAmount
-                        ? blockchain_service_1.BSNumberHelper.formatNumber(systemFeeAmount, { decimals: this._feeToken.decimals })
+                        ? blockchain_service_1.BSBigNumberHelper.format(systemFeeAmount, { decimals: this._feeToken.decimals })
                         : undefined,
                     events: [],
                 };
@@ -222,11 +224,10 @@ class DoraBDSNeo3 extends RpcBDSNeo3_1.RpcBDSNeo3 {
                     }
                     else {
                         const [token] = yield blockchain_service_1.BSPromisesHelper.tryCatch(() => this.getTokenInfo(hash));
-                        const { amount } = event;
                         assetEvent = {
                             eventType: 'token',
-                            amount: amount
-                                ? blockchain_service_1.BSNumberHelper.formatNumber(amount, { decimals: (_k = token === null || token === void 0 ? void 0 : token.decimals) !== null && _k !== void 0 ? _k : event.tokenDecimals })
+                            amount: event.amount
+                                ? blockchain_service_1.BSBigNumberHelper.format(event.amount, { decimals: (_k = token === null || token === void 0 ? void 0 : token.decimals) !== null && _k !== void 0 ? _k : event.tokenDecimals })
                                 : undefined,
                             methodName,
                             from,
@@ -251,7 +252,7 @@ class DoraBDSNeo3 extends RpcBDSNeo3_1.RpcBDSNeo3 {
     exportFullTransactionsByAddress(params) {
         return __awaiter(this, void 0, void 0, function* () {
             __classPrivateFieldGet(this, _DoraBDSNeo3_instances, "m", _DoraBDSNeo3_validateFullTransactionsByAddressParams).call(this, params);
-            return yield NeoRest.exportFullTransactionsByAddress({
+            return yield exports.DoraNeoRest.exportFullTransactionsByAddress({
                 address: params.address,
                 timestampFrom: params.dateFrom,
                 timestampTo: params.dateTo,
@@ -269,7 +270,7 @@ class DoraBDSNeo3 extends RpcBDSNeo3_1.RpcBDSNeo3 {
                 return yield _super.getContract.call(this, contractHash);
             }
             try {
-                const data = yield NeoRest.contract(contractHash, this._network.id);
+                const data = yield exports.DoraNeoRest.contract(contractHash, this._network.id);
                 return {
                     hash: data.hash,
                     methods: (_b = (_a = data.manifest.abi) === null || _a === void 0 ? void 0 : _a.methods) !== null && _b !== void 0 ? _b : [],
@@ -289,20 +290,21 @@ class DoraBDSNeo3 extends RpcBDSNeo3_1.RpcBDSNeo3 {
             if (BSNeo3Helper_1.BSNeo3Helper.isCustomNet(this._network)) {
                 return yield _super.getTokenInfo.call(this, tokenHash);
             }
-            const localToken = this._tokens.find(token => token.hash === tokenHash);
-            if (localToken)
-                return localToken;
-            if (this._tokenCache.has(tokenHash)) {
-                return this._tokenCache.get(tokenHash);
-            }
             try {
-                const { decimals, symbol, name, scripthash } = yield NeoRest.asset(tokenHash, this._network.id);
-                const token = {
-                    decimals: Number(decimals),
-                    symbol,
-                    name,
-                    hash: scripthash,
-                };
+                const cachedToken = this._tokenCache.get(tokenHash);
+                if (cachedToken) {
+                    return cachedToken;
+                }
+                let token = this._tokens.find(blockchain_service_1.BSTokenHelper.predicateByHash(tokenHash));
+                if (!token) {
+                    const { decimals, symbol, name, scripthash } = yield exports.DoraNeoRest.asset(tokenHash, this._network.id);
+                    token = blockchain_service_1.BSTokenHelper.normalizeToken({
+                        decimals: Number(decimals),
+                        symbol,
+                        name,
+                        hash: scripthash,
+                    });
+                }
                 this._tokenCache.set(tokenHash, token);
                 return token;
             }
@@ -319,7 +321,7 @@ class DoraBDSNeo3 extends RpcBDSNeo3_1.RpcBDSNeo3 {
             if (BSNeo3Helper_1.BSNeo3Helper.isCustomNet(this._network)) {
                 return yield _super.getBalance.call(this, address);
             }
-            const response = yield NeoRest.balance(address, this._network.id);
+            const response = yield exports.DoraNeoRest.balance(address, this._network.id);
             const promises = response.map((balance) => __awaiter(this, void 0, void 0, function* () {
                 try {
                     const token = yield this.getTokenInfo(balance.asset);

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

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RpcBDSNeo3 = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
 const neon_core_1 = require("@cityofzion/neon-core");
 const neon_dappkit_1 = require("@cityofzion/neon-dappkit");
 const BSNeo3Helper_1 = require("../../helpers/BSNeo3Helper");
@@ -85,40 +86,41 @@ class RpcBDSNeo3 {
     }
     getTokenInfo(tokenHash) {
         return __awaiter(this, void 0, void 0, function* () {
-            const localToken = this._tokens.find(token => BSNeo3Helper_1.BSNeo3Helper.normalizeHash(token.hash) === BSNeo3Helper_1.BSNeo3Helper.normalizeHash(tokenHash));
-            if (localToken)
-                return localToken;
-            if (this._tokenCache.has(tokenHash)) {
-                return this._tokenCache.get(tokenHash);
-            }
             try {
-                const rpcClient = new neon_core_1.rpc.RPCClient(this._network.url);
-                const contractState = yield rpcClient.getContractState(tokenHash);
-                const invoker = yield neon_dappkit_1.NeonInvoker.init({
-                    rpcAddress: this._network.url,
-                });
-                const response = yield invoker.testInvoke({
-                    invocations: [
-                        {
-                            scriptHash: tokenHash,
-                            operation: 'decimals',
-                            args: [],
-                        },
-                        { scriptHash: tokenHash, operation: 'symbol', args: [] },
-                    ],
-                });
-                if (!neon_dappkit_1.TypeChecker.isStackTypeInteger(response.stack[0]))
-                    throw new Error('Invalid decimals');
-                if (!neon_dappkit_1.TypeChecker.isStackTypeByteString(response.stack[1]))
-                    throw new Error('Invalid symbol');
-                const decimals = Number(response.stack[0].value);
-                const symbol = neon_core_1.u.base642utf8(response.stack[1].value);
-                const token = {
-                    name: contractState.manifest.name,
-                    symbol,
-                    hash: contractState.hash,
-                    decimals,
-                };
+                const cachedToken = this._tokenCache.get(tokenHash);
+                if (cachedToken) {
+                    return cachedToken;
+                }
+                let token = this._tokens.find(blockchain_service_1.BSTokenHelper.predicateByHash(tokenHash));
+                if (!token) {
+                    const rpcClient = new neon_core_1.rpc.RPCClient(this._network.url);
+                    const contractState = yield rpcClient.getContractState(tokenHash);
+                    const invoker = yield neon_dappkit_1.NeonInvoker.init({
+                        rpcAddress: this._network.url,
+                    });
+                    const response = yield invoker.testInvoke({
+                        invocations: [
+                            {
+                                scriptHash: tokenHash,
+                                operation: 'decimals',
+                                args: [],
+                            },
+                            { scriptHash: tokenHash, operation: 'symbol', args: [] },
+                        ],
+                    });
+                    if (!neon_dappkit_1.TypeChecker.isStackTypeInteger(response.stack[0]))
+                        throw new Error('Invalid decimals');
+                    if (!neon_dappkit_1.TypeChecker.isStackTypeByteString(response.stack[1]))
+                        throw new Error('Invalid symbol');
+                    const decimals = Number(response.stack[0].value);
+                    const symbol = neon_core_1.u.base642utf8(response.stack[1].value);
+                    token = blockchain_service_1.BSTokenHelper.normalizeToken({
+                        name: contractState.manifest.name,
+                        symbol,
+                        hash: contractState.hash,
+                        decimals,
+                    });
+                }
                 this._tokenCache.set(tokenHash, token);
                 return token;
             }

package/dist/services/explorer/DoraESNeo3.js

@@ -24,17 +24,17 @@ class DoraESNeo3 {
     buildTransactionUrl(hash) {
         if (BSNeo3Helper_1.BSNeo3Helper.isCustomNet(__classPrivateFieldGet(this, _DoraESNeo3_network, "f")))
             throw new Error('DoraESNeo3 is only available on mainnet and testnet');
-        return `${__classPrivateFieldGet(this, _DoraESNeo3_BASE_URL, "f")}/transaction/neo3/${__classPrivateFieldGet(this, _DoraESNeo3_network, "f").id}/${hash}`;
+        return `${__classPrivateFieldGet(this, _DoraESNeo3_BASE_URL, "f")}/transaction/neo3/${__classPrivateFieldGet(this, _DoraESNeo3_network, "f").id}/${blockchain_service_1.BSTokenHelper.normalizeHash(hash)}`;
     }
     buildContractUrl(contractHash) {
         if (BSNeo3Helper_1.BSNeo3Helper.isCustomNet(__classPrivateFieldGet(this, _DoraESNeo3_network, "f")))
             throw new Error('DoraESNeo3 is only available on mainnet and testnet');
-        return `${__classPrivateFieldGet(this, _DoraESNeo3_BASE_URL, "f")}/contract/neo3/${__classPrivateFieldGet(this, _DoraESNeo3_network, "f").id}/${contractHash}`;
+        return `${__classPrivateFieldGet(this, _DoraESNeo3_BASE_URL, "f")}/contract/neo3/${__classPrivateFieldGet(this, _DoraESNeo3_network, "f").id}/${blockchain_service_1.BSTokenHelper.normalizeHash(contractHash)}`;
     }
     buildNftUrl({ contractHash, tokenId }) {
         if (BSNeo3Helper_1.BSNeo3Helper.isCustomNet(__classPrivateFieldGet(this, _DoraESNeo3_network, "f")))
             throw new Error('DoraESNeo3 is only available on mainnet and testnet');
-        return `${__classPrivateFieldGet(this, _DoraESNeo3_BASE_URL, "f")}/nft/neo3/${__classPrivateFieldGet(this, _DoraESNeo3_network, "f").id}/${contractHash}/${tokenId}`;
+        return `${__classPrivateFieldGet(this, _DoraESNeo3_BASE_URL, "f")}/nft/neo3/${__classPrivateFieldGet(this, _DoraESNeo3_network, "f").id}/${blockchain_service_1.BSTokenHelper.normalizeHash(contractHash)}/${tokenId}`;
     }
     getAddressTemplateUrl() {
         if (BSNeo3Helper_1.BSNeo3Helper.isCustomNet(__classPrivateFieldGet(this, _DoraESNeo3_network, "f")))

package/dist/services/neo3neoXBridge/Neo3NeoXBridgeService.d.ts

@@ -0,0 +1,16 @@
+import { INeo3NeoXBridgeService, TNeo3NeoXBridgeServiceBridgeParam, TNeo3NeoXBridgeServiceCalculateMaxAmountParams, TNeo3NeoXBridgeServiceValidatedInputs, TNeo3NeoXBridgeServiceValidateInputParams, TNeo3NeoXBridgeServiceWaitParams } from '@cityofzion/blockchain-service';
+import { BSNeo3 } from '../../BSNeo3';
+export declare class Neo3NeoXBridgeService<BSName extends string = string> implements INeo3NeoXBridgeService<BSName> {
+    #private;
+    readonly BRIDGE_SCRIPT_HASH = "0xbb19cfc864b73159277e1fd39694b3fd5fc613d2";
+    readonly BRIDGE_GAS_FEE = 0.1;
+    readonly BRIDGE_MIN_AMOUNT = 1;
+    readonly BRIDGE_NEOX_BASE_CONFIRMATION_URL = "https://xexplorer.neo.org:8877/api/v1/transactions/deposits";
+    readonly BRIDGE_NEOX_NEO_TOKEN_HASH = "0xc28736dc83f4fd43d6fb832Fd93c3eE7bB26828f";
+    constructor(service: BSNeo3<BSName>);
+    calculateMaxAmount({ account, balances, receiverAddress, token, }: TNeo3NeoXBridgeServiceCalculateMaxAmountParams<BSName>): Promise<string>;
+    calculateFee(params: TNeo3NeoXBridgeServiceBridgeParam<BSName>): Promise<string>;
+    bridge(params: TNeo3NeoXBridgeServiceBridgeParam<BSName>): Promise<string>;
+    validateInputs(params: TNeo3NeoXBridgeServiceValidateInputParams<BSName>): Promise<TNeo3NeoXBridgeServiceValidatedInputs>;
+    wait(params: TNeo3NeoXBridgeServiceWaitParams): Promise<boolean>;
+}

package/dist/services/neo3neoXBridge/Neo3NeoXBridgeService.js

@@ -0,0 +1,302 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Neo3NeoXBridgeService_instances, _Neo3NeoXBridgeService_service, _Neo3NeoXBridgeService_buildGasCIM, _Neo3NeoXBridgeService_buildNeoCIM, _Neo3NeoXBridgeService_buildCIM, _Neo3NeoXBridgeService_validateGas, _Neo3NeoXBridgeService_validateNeo;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Neo3NeoXBridgeService = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
+const BSNeo3Constants_1 = require("../../constants/BSNeo3Constants");
+const neon_dappkit_1 = require("@cityofzion/neon-dappkit");
+const BSNeo3Helper_1 = require("../../helpers/BSNeo3Helper");
+const DoraBDSNeo3_1 = require("../blockchain-data/DoraBDSNeo3");
+const axios_1 = __importDefault(require("axios"));
+class Neo3NeoXBridgeService {
+    constructor(service) {
+        _Neo3NeoXBridgeService_instances.add(this);
+        this.BRIDGE_SCRIPT_HASH = '0xbb19cfc864b73159277e1fd39694b3fd5fc613d2';
+        this.BRIDGE_GAS_FEE = 0.1;
+        this.BRIDGE_MIN_AMOUNT = 1;
+        this.BRIDGE_NEOX_BASE_CONFIRMATION_URL = 'https://xexplorer.neo.org:8877/api/v1/transactions/deposits';
+        this.BRIDGE_NEOX_NEO_TOKEN_HASH = '0xc28736dc83f4fd43d6fb832Fd93c3eE7bB26828f';
+        _Neo3NeoXBridgeService_service.set(this, void 0);
+        __classPrivateFieldSet(this, _Neo3NeoXBridgeService_service, service, "f");
+    }
+    calculateMaxAmount({ account, balances, receiverAddress, token, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!BSNeo3Helper_1.BSNeo3Helper.isMainnet(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network))
+                throw new blockchain_service_1.BSError('Bridging to NeoX is only supported on mainnet', 'UNSUPPORTED_NETWORK');
+            const normalizedSelectedToken = blockchain_service_1.BSTokenHelper.normalizeToken(token);
+            const selectedTokenBalance = balances.find(balance => blockchain_service_1.BSTokenHelper.normalizeHash(balance.token.hash) === normalizedSelectedToken.hash);
+            if (!selectedTokenBalance) {
+                throw new blockchain_service_1.BSError('Token balance not found', 'TOKEN_BALANCE_NOT_FOUND');
+            }
+            const amountNumber = blockchain_service_1.BSBigNumberHelper.fromNumber(selectedTokenBalance.amount);
+            const validatedInputs = {
+                receiveAmount: amountNumber.minus(this.BRIDGE_MIN_AMOUNT).toString(),
+                token,
+                amount: amountNumber.toString(),
+            };
+            const fee = yield this.calculateFee({
+                account,
+                receiverAddress,
+                validatedInputs,
+            });
+            const maxAmount = amountNumber.minus(fee).toString();
+            return maxAmount;
+        });
+    }
+    calculateFee(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!BSNeo3Helper_1.BSNeo3Helper.isMainnet(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network))
+                throw new blockchain_service_1.BSError('Bridging to NeoX is only supported on mainnet', 'UNSUPPORTED_NETWORK');
+            try {
+                const { account } = params;
+                const { neonJsAccount } = yield __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").generateSigningCallback(account);
+                const invoker = yield neon_dappkit_1.NeonInvoker.init({
+                    rpcAddress: __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.url,
+                    account: neonJsAccount,
+                });
+                const contractInvocationMulti = __classPrivateFieldGet(this, _Neo3NeoXBridgeService_instances, "m", _Neo3NeoXBridgeService_buildCIM).call(this, params, neonJsAccount);
+                const { total } = yield invoker.calculateFee(contractInvocationMulti);
+                return total.toString();
+            }
+            catch (error) {
+                throw new blockchain_service_1.BSError(error.message, 'FEE_CALCULATION_ERROR');
+            }
+        });
+    }
+    bridge(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!BSNeo3Helper_1.BSNeo3Helper.isMainnet(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network))
+                throw new blockchain_service_1.BSError('Bridging to NeoX is only supported on mainnet', 'UNSUPPORTED_NETWORK');
+            const { account } = params;
+            const { neonJsAccount, signingCallback } = yield __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").generateSigningCallback(account);
+            const invoker = yield neon_dappkit_1.NeonInvoker.init({
+                rpcAddress: __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.url,
+                account: neonJsAccount,
+                signingCallback: signingCallback,
+            });
+            const contractInvocationMulti = __classPrivateFieldGet(this, _Neo3NeoXBridgeService_instances, "m", _Neo3NeoXBridgeService_buildCIM).call(this, params, neonJsAccount);
+            const transactionHash = yield invoker.invokeFunction(contractInvocationMulti);
+            return transactionHash;
+        });
+    }
+    validateInputs(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!BSNeo3Helper_1.BSNeo3Helper.isMainnet(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network))
+                throw new blockchain_service_1.BSError('Bridging to NeoX is only supported on mainnet', 'UNSUPPORTED_NETWORK');
+            const normalizedSelectedToken = blockchain_service_1.BSTokenHelper.normalizeToken(params.token);
+            const isGasToken = normalizedSelectedToken.hash === BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN.hash;
+            const isNeoToken = normalizedSelectedToken.hash === BSNeo3Constants_1.BSNeo3Constants.NEO_TOKEN.hash;
+            if (isGasToken) {
+                return __classPrivateFieldGet(this, _Neo3NeoXBridgeService_instances, "m", _Neo3NeoXBridgeService_validateGas).call(this, params);
+            }
+            else if (isNeoToken) {
+                return __classPrivateFieldGet(this, _Neo3NeoXBridgeService_instances, "m", _Neo3NeoXBridgeService_validateNeo).call(this, params);
+            }
+            else {
+                throw new blockchain_service_1.BSError('Only GAS and NEO tokens are supported for bridging', 'UNSUPPORTED_TOKEN');
+            }
+        });
+    }
+    wait(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!BSNeo3Helper_1.BSNeo3Helper.isMainnet(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network))
+                throw new blockchain_service_1.BSError('Bridging to NeoX is only supported on mainnet', 'UNSUPPORTED_NETWORK');
+            try {
+                const { transactionHash, validatedInputs } = params;
+                let nonce;
+                const log = yield blockchain_service_1.BSUtilsHelper.retry(() => DoraBDSNeo3_1.DoraNeoRest.log(transactionHash, __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.id), {
+                    retries: 10,
+                    delay: 30000,
+                });
+                if (log.vmstate !== 'HALT') {
+                    throw new Error();
+                }
+                const isGasToken = blockchain_service_1.BSTokenHelper.predicateByHash(validatedInputs.token)(BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN);
+                if (isGasToken) {
+                    const notification = log.notifications.find(item => item.event_name === 'NativeDeposit');
+                    nonce = notification === null || notification === void 0 ? void 0 : notification.state.value[0].value;
+                }
+                else {
+                    const notification = log.notifications.find(item => item.event_name === 'TokenDeposit');
+                    nonce = notification === null || notification === void 0 ? void 0 : notification.state.value[2].value;
+                }
+                if (!nonce) {
+                    throw new Error();
+                }
+                yield blockchain_service_1.BSUtilsHelper.retry(() => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    let url;
+                    if (isGasToken) {
+                        url = `${this.BRIDGE_NEOX_BASE_CONFIRMATION_URL}/${nonce}`;
+                    }
+                    else {
+                        url = `${this.BRIDGE_NEOX_BASE_CONFIRMATION_URL}/${this.BRIDGE_NEOX_NEO_TOKEN_HASH}/${nonce}`;
+                    }
+                    const response = yield axios_1.default.get(url);
+                    if (!((_a = response.data) === null || _a === void 0 ? void 0 : _a.txid)) {
+                        throw new blockchain_service_1.BSError('Transaction not found', 'TRANSACTION_NOT_FOUND');
+                    }
+                }), {
+                    retries: 10,
+                    delay: 30000,
+                });
+                return true;
+            }
+            catch (error) {
+                return false;
+            }
+        });
+    }
+}
+exports.Neo3NeoXBridgeService = Neo3NeoXBridgeService;
+_Neo3NeoXBridgeService_service = new WeakMap(), _Neo3NeoXBridgeService_instances = new WeakSet(), _Neo3NeoXBridgeService_buildGasCIM = function _Neo3NeoXBridgeService_buildGasCIM({ receiverAddress, validatedInputs }, neonJsAccount) {
+    return {
+        invocations: [
+            {
+                scriptHash: this.BRIDGE_SCRIPT_HASH,
+                operation: 'depositNative',
+                args: [
+                    { type: 'Hash160', value: neonJsAccount.address },
+                    { type: 'Hash160', value: receiverAddress },
+                    {
+                        type: 'Integer',
+                        value: blockchain_service_1.BSBigNumberHelper.toDecimals(blockchain_service_1.BSBigNumberHelper.fromNumber(validatedInputs.receiveAmount), validatedInputs.token.decimals),
+                    },
+                    {
+                        type: 'Integer',
+                        value: blockchain_service_1.BSBigNumberHelper.toDecimals(blockchain_service_1.BSBigNumberHelper.fromNumber(this.BRIDGE_GAS_FEE), BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN.decimals),
+                    },
+                ],
+            },
+        ],
+        signers: [
+            {
+                scopes: 16,
+                allowedContracts: [this.BRIDGE_SCRIPT_HASH, BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN.hash],
+            },
+        ],
+    };
+}, _Neo3NeoXBridgeService_buildNeoCIM = function _Neo3NeoXBridgeService_buildNeoCIM({ receiverAddress, validatedInputs }, neonJsAccount) {
+    return {
+        invocations: [
+            {
+                scriptHash: this.BRIDGE_SCRIPT_HASH,
+                operation: 'depositToken',
+                args: [
+                    { type: 'Hash160', value: BSNeo3Constants_1.BSNeo3Constants.NEO_TOKEN.hash },
+                    { type: 'Hash160', value: neonJsAccount.scriptHash },
+                    { type: 'Hash160', value: receiverAddress },
+                    {
+                        type: 'Integer',
+                        value: blockchain_service_1.BSBigNumberHelper.toDecimals(blockchain_service_1.BSBigNumberHelper.fromNumber(validatedInputs.receiveAmount), validatedInputs.token.decimals),
+                    },
+                    {
+                        type: 'Integer',
+                        value: blockchain_service_1.BSBigNumberHelper.toDecimals(blockchain_service_1.BSBigNumberHelper.fromNumber(this.BRIDGE_GAS_FEE), BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN.decimals),
+                    },
+                ],
+            },
+        ],
+        signers: [
+            {
+                scopes: 16,
+                allowedContracts: [this.BRIDGE_SCRIPT_HASH, BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN.hash, BSNeo3Constants_1.BSNeo3Constants.NEO_TOKEN.hash],
+            },
+        ],
+    };
+}, _Neo3NeoXBridgeService_buildCIM = function _Neo3NeoXBridgeService_buildCIM(params, neonJsAccount) {
+    const isGasToken = blockchain_service_1.BSTokenHelper.predicateByHash(params.validatedInputs.token)(BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN);
+    if (isGasToken) {
+        return __classPrivateFieldGet(this, _Neo3NeoXBridgeService_instances, "m", _Neo3NeoXBridgeService_buildGasCIM).call(this, params, neonJsAccount);
+    }
+    return __classPrivateFieldGet(this, _Neo3NeoXBridgeService_instances, "m", _Neo3NeoXBridgeService_buildNeoCIM).call(this, params, neonJsAccount);
+}, _Neo3NeoXBridgeService_validateGas = function _Neo3NeoXBridgeService_validateGas({ amount, balances, token, account, receiverAddress, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const gasBalance = balances.find(balance => blockchain_service_1.BSTokenHelper.predicateByHash(balance.token)(BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN));
+        if (!gasBalance) {
+            throw new blockchain_service_1.BSError('GAS is necessary to bridge', 'GAS_BALANCE_NOT_FOUND');
+        }
+        const amountNumber = blockchain_service_1.BSBigNumberHelper.fromNumber(amount);
+        const gasBalanceNumber = blockchain_service_1.BSBigNumberHelper.fromNumber(gasBalance.amount);
+        const validatedInputs = {
+            receiveAmount: amountNumber.minus(this.BRIDGE_GAS_FEE).toString(),
+            token,
+            amount,
+        };
+        if (amountNumber.isLessThan(this.BRIDGE_MIN_AMOUNT + this.BRIDGE_GAS_FEE)) {
+            throw new blockchain_service_1.BSError('Amount is less than the minimum amount plus bridge fee', 'AMOUNT_TOO_LOW');
+        }
+        if (amountNumber.isGreaterThan(gasBalanceNumber)) {
+            throw new blockchain_service_1.BSError('Amount is greater than your balance', 'INSUFFICIENT_GAS_BALANCE');
+        }
+        const fee = yield this.calculateFee({
+            account,
+            receiverAddress,
+            validatedInputs,
+        });
+        if (amountNumber.plus(fee).isGreaterThan(gasBalanceNumber)) {
+            throw new blockchain_service_1.BSError('Amount is greater than your balance plus fee', 'INSUFFICIENT_GAS_BALANCE_FEE');
+        }
+        return validatedInputs;
+    });
+}, _Neo3NeoXBridgeService_validateNeo = function _Neo3NeoXBridgeService_validateNeo({ amount, balances, token, account, receiverAddress, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const gasBalance = balances.find(balance => blockchain_service_1.BSTokenHelper.predicateByHash(balance.token)(BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN));
+        if (!gasBalance) {
+            throw new blockchain_service_1.BSError('GAS is necessary to bridge', 'GAS_BALANCE_NOT_FOUND');
+        }
+        const neoBalance = balances.find(balance => blockchain_service_1.BSTokenHelper.predicateByHash(balance.token)(BSNeo3Constants_1.BSNeo3Constants.NEO_TOKEN));
+        if (!neoBalance) {
+            throw new blockchain_service_1.BSError('NEO balance not found', 'NEO_BALANCE_NOT_FOUND');
+        }
+        const amountNumber = blockchain_service_1.BSBigNumberHelper.fromNumber(amount);
+        const gasBalanceNumber = blockchain_service_1.BSBigNumberHelper.fromNumber(gasBalance.amount);
+        const minGasBalanceNumber = blockchain_service_1.BSBigNumberHelper.fromNumber(this.BRIDGE_GAS_FEE);
+        const validatedInputs = {
+            receiveAmount: amount,
+            token,
+            amount,
+        };
+        if (amountNumber.isLessThan(this.BRIDGE_MIN_AMOUNT)) {
+            throw new blockchain_service_1.BSError('Amount is less than the minimum amount', 'AMOUNT_TOO_LOW');
+        }
+        if (amountNumber.isGreaterThan(neoBalance.amount)) {
+            throw new blockchain_service_1.BSError('Amount is greater than your balance', 'INSUFFICIENT_NEO_BALANCE');
+        }
+        if (gasBalanceNumber.isLessThan(minGasBalanceNumber)) {
+            throw new blockchain_service_1.BSError('GAS balance is less than bridge fee', 'INSUFFICIENT_GAS_BALANCE_BRIDGE_FEE');
+        }
+        const fee = yield this.calculateFee({
+            account,
+            receiverAddress,
+            validatedInputs,
+        });
+        if (minGasBalanceNumber.plus(fee).isGreaterThan(gasBalanceNumber)) {
+            throw new blockchain_service_1.BSError('GAS balance is less than fees', 'INSUFFICIENT_GAS_BALANCE_FEES');
+        }
+        return validatedInputs;
+    });
+};

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

@@ -25,6 +25,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 var _GhostMarketNDSNeo3_instances, _GhostMarketNDSNeo3_network, _GhostMarketNDSNeo3_treatGhostMarketImage, _GhostMarketNDSNeo3_getUrlWithParams, _GhostMarketNDSNeo3_parse;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GhostMarketNDSNeo3 = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
 const axios_1 = __importDefault(require("axios"));
 const query_string_1 = __importDefault(require("query-string"));
 const RpcNDSNeo3_1 = require("./RpcNDSNeo3");
@@ -51,7 +52,7 @@ class GhostMarketNDSNeo3 extends RpcNDSNeo3_1.RpcNDSNeo3 {
     getNft({ contractHash, tokenId }) {
         return __awaiter(this, void 0, void 0, function* () {
             const url = __classPrivateFieldGet(this, _GhostMarketNDSNeo3_instances, "m", _GhostMarketNDSNeo3_getUrlWithParams).call(this, {
-                contract: contractHash,
+                contract: blockchain_service_1.BSTokenHelper.normalizeHash(contractHash),
                 tokenIds: [tokenId],
             });
             const { data } = yield axios_1.default.get(url);
@@ -82,7 +83,7 @@ _GhostMarketNDSNeo3_network = new WeakMap(), _GhostMarketNDSNeo3_instances = new
     const nftResponse = {
         collectionImage: __classPrivateFieldGet(this, _GhostMarketNDSNeo3_instances, "m", _GhostMarketNDSNeo3_treatGhostMarketImage).call(this, (_a = data.collection) === null || _a === void 0 ? void 0 : _a.logoUrl),
         id: data.tokenId,
-        contractHash: data.contract.hash,
+        contractHash: blockchain_service_1.BSTokenHelper.normalizeHash(data.contract.hash),
         symbol: data.contract.symbol,
         collectionName: (_b = data.collection) === null || _b === void 0 ? void 0 : _b.name,
         image: __classPrivateFieldGet(this, _GhostMarketNDSNeo3_instances, "m", _GhostMarketNDSNeo3_treatGhostMarketImage).call(this, data.metadata.mediaUri),

package/dist/services/vote/DoraVoteServiceNeo3.js

@@ -73,6 +73,7 @@ class DoraVoteServiceNeo3 extends RpcVoteServiceNeo3_1.RpcVoteServiceNeo3 {
         });
     }
     getVoteDetailsByAddress(address) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             if (!BSNeo3Helper_1.BSNeo3Helper.isMainnet(__classPrivateFieldGet(this, _DoraVoteServiceNeo3_service, "f").network))
                 throw new Error('Only Mainnet is supported');
@@ -80,13 +81,12 @@ class DoraVoteServiceNeo3 extends RpcVoteServiceNeo3_1.RpcVoteServiceNeo3 {
                 throw new Error('Missing address');
             if (!__classPrivateFieldGet(this, _DoraVoteServiceNeo3_service, "f").validateAddress(address))
                 throw new Error('Invalid address');
-            const _a = (yield __classPrivateFieldGet(this, _DoraVoteServiceNeo3_doraAxiosInstance, "f").get(`/mainnet/voter/${address}`)).data, { candidatePubkey } = _a, data = __rest(_a, ["candidatePubkey"]);
-            if (!candidatePubkey)
-                throw new Error('There was a problem to get vote details by address');
+            const { data } = yield __classPrivateFieldGet(this, _DoraVoteServiceNeo3_doraAxiosInstance, "f").get(`/mainnet/voter/${address}`);
             return {
-                candidateName: data.candidate,
-                candidatePubKey: candidatePubkey,
+                candidateName: (_a = data.candidate) !== null && _a !== void 0 ? _a : undefined,
+                candidatePubKey: (_b = data.candidatePubkey) !== null && _b !== void 0 ? _b : undefined,
                 neoBalance: data.balance,
+                address,
             };
         });
     }

package/dist/services/vote/RpcVoteServiceNeo3.js

@@ -24,8 +24,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RpcVoteServiceNeo3 = void 0;
 const BSNeo3Helper_1 = require("../../helpers/BSNeo3Helper");
 const neon_dappkit_1 = require("@cityofzion/neon-dappkit");
-const blockchain_service_1 = require("@cityofzion/blockchain-service");
 const neon_js_1 = require("@cityofzion/neon-js");
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
 class RpcVoteServiceNeo3 {
     constructor(service) {
         _RpcVoteServiceNeo3_instances.add(this);
@@ -66,7 +66,7 @@ class RpcVoteServiceNeo3 {
                 address: account.address,
                 candidatePubKey,
             }));
-            return blockchain_service_1.BSNumberHelper.formatNumber(total, { decimals: __classPrivateFieldGet(this, _RpcVoteServiceNeo3_service, "f").feeToken.decimals });
+            return blockchain_service_1.BSBigNumberHelper.format(total, { decimals: __classPrivateFieldGet(this, _RpcVoteServiceNeo3_service, "f").feeToken.decimals });
         });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-neo3",
-  "version": "1.14.1",
+  "version": "1.15.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",
@@ -21,7 +21,7 @@
     "isomorphic-ws": "^5.0.0",
     "lodash.clonedeep": "^4.5.0",
     "date-fns": "~4.1.0",
-    "@cityofzion/blockchain-service": "1.18.2",
+    "@cityofzion/blockchain-service": "1.19.0",
     "@cityofzion/bs-asteroid-sdk": "0.9.1"
   },
   "devDependencies": {