@cityofzion/bs-neo3 1.16.3 → 1.16.4

package/dist/services/neo3neoXBridge/Neo3NeoXBridgeService.js

@@ -27,19 +27,16 @@ 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 axios_1 = __importDefault(require("axios"));
 const BSNeo3Helper_1 = require("../../helpers/BSNeo3Helper");
 const DoraBDSNeo3_1 = require("../blockchain-data/DoraBDSNeo3");
-const axios_1 = __importDefault(require("axios"));
+const BSNeo3NeonDappKitSingletonHelper_1 = require("../../helpers/BSNeo3NeonDappKitSingletonHelper");
 class Neo3NeoXBridgeService {
     constructor(service) {
-        this.BRIDGE_SCRIPT_HASH = '0xbb19cfc864b73159277e1fd39694b3fd5fc613d2';
         _Neo3NeoXBridgeService_service.set(this, void 0);
         __classPrivateFieldSet(this, _Neo3NeoXBridgeService_service, service, "f");
-        this.tokens = [
-            Object.assign(Object.assign({}, BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN), { multichainId: 'gas', blockchain: service.name }),
-            Object.assign(Object.assign({}, BSNeo3Constants_1.BSNeo3Constants.NEO_TOKEN), { multichainId: 'neo', blockchain: service.name }),
-        ];
+        this.gasToken = Object.assign(Object.assign({}, BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN), { blockchain: service.name, multichainId: 'gas' });
+        this.neoToken = Object.assign(Object.assign({}, BSNeo3Constants_1.BSNeo3Constants.NEO_TOKEN), { blockchain: service.name, multichainId: 'neo' });
     }
     getApprovalFee() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -48,33 +45,34 @@ class Neo3NeoXBridgeService {
     }
     getBridgeConstants(token) {
         return __awaiter(this, void 0, void 0, function* () {
-            const invoker = yield neon_dappkit_1.NeonInvoker.init({
+            const { TypeChecker, NeonInvoker } = BSNeo3NeonDappKitSingletonHelper_1.BSNeo3NeonDappKitSingletonHelper.getInstance();
+            const invoker = yield NeonInvoker.init({
                 rpcAddress: __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.url,
             });
             const isNativeToken = __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").tokenService.predicateByHash(token, BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN);
             let invocations;
             if (isNativeToken) {
                 invocations = [
-                    { operation: 'nativeDepositFee', scriptHash: this.BRIDGE_SCRIPT_HASH, args: [] },
-                    { operation: 'minNativeDeposit', scriptHash: this.BRIDGE_SCRIPT_HASH, args: [] },
-                    { operation: 'maxNativeDeposit', scriptHash: this.BRIDGE_SCRIPT_HASH, args: [] },
+                    { operation: 'nativeDepositFee', scriptHash: Neo3NeoXBridgeService.BRIDGE_SCRIPT_HASH, args: [] },
+                    { operation: 'minNativeDeposit', scriptHash: Neo3NeoXBridgeService.BRIDGE_SCRIPT_HASH, args: [] },
+                    { operation: 'maxNativeDeposit', scriptHash: Neo3NeoXBridgeService.BRIDGE_SCRIPT_HASH, args: [] },
                 ];
             }
             else {
                 invocations = [
                     {
                         operation: 'tokenDepositFee',
-                        scriptHash: this.BRIDGE_SCRIPT_HASH,
+                        scriptHash: Neo3NeoXBridgeService.BRIDGE_SCRIPT_HASH,
                         args: [{ type: 'Hash160', value: token.hash }],
                     },
                     {
                         operation: 'minTokenDeposit',
-                        scriptHash: this.BRIDGE_SCRIPT_HASH,
+                        scriptHash: Neo3NeoXBridgeService.BRIDGE_SCRIPT_HASH,
                         args: [{ type: 'Hash160', value: token.hash }],
                     },
                     {
                         operation: 'maxTokenDeposit',
-                        scriptHash: this.BRIDGE_SCRIPT_HASH,
+                        scriptHash: Neo3NeoXBridgeService.BRIDGE_SCRIPT_HASH,
                         args: [{ type: 'Hash160', value: token.hash }],
                     },
                 ];
@@ -83,9 +81,9 @@ class Neo3NeoXBridgeService {
                 invocations,
             });
             const [depositFeeItem, minDepositItem, maxDepositItem] = response.stack;
-            if (!neon_dappkit_1.TypeChecker.isStackTypeInteger(depositFeeItem) ||
-                !neon_dappkit_1.TypeChecker.isStackTypeInteger(minDepositItem) ||
-                !neon_dappkit_1.TypeChecker.isStackTypeInteger(maxDepositItem))
+            if (!TypeChecker.isStackTypeInteger(depositFeeItem) ||
+                !TypeChecker.isStackTypeInteger(minDepositItem) ||
+                !TypeChecker.isStackTypeInteger(maxDepositItem))
                 throw new blockchain_service_1.BSError('Invalid response', 'INVALID_RESPONSE');
             const bridgeFeeBn = blockchain_service_1.BSBigNumberHelper.fromDecimals(depositFeeItem.value, BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN.decimals).toString();
             const minAmountBn = blockchain_service_1.BSBigNumberHelper.fromDecimals(minDepositItem.value, token.decimals).toString();
@@ -101,19 +99,20 @@ class Neo3NeoXBridgeService {
         });
     }
     bridge(params) {
-        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!BSNeo3Helper_1.BSNeo3Helper.isMainnet(__classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network))
+            var _a, _b;
+            if (!BSNeo3Helper_1.BSNeo3Helper.isMainnetNetwork(__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({
+            const { NeonInvoker } = BSNeo3NeonDappKitSingletonHelper_1.BSNeo3NeonDappKitSingletonHelper.getInstance();
+            const invoker = yield NeonInvoker.init({
                 rpcAddress: __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.url,
                 account: neonJsAccount,
                 signingCallback: signingCallback,
             });
             const contractInvocation = {
-                scriptHash: this.BRIDGE_SCRIPT_HASH,
+                scriptHash: Neo3NeoXBridgeService.BRIDGE_SCRIPT_HASH,
                 operation: 'depositNative',
                 args: [
                     { type: 'Hash160', value: neonJsAccount.address },
@@ -130,7 +129,7 @@ class Neo3NeoXBridgeService {
             };
             const signer = {
                 scopes: 16,
-                allowedContracts: [this.BRIDGE_SCRIPT_HASH, BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN.hash],
+                allowedContracts: [Neo3NeoXBridgeService.BRIDGE_SCRIPT_HASH, BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN.hash],
             };
             const isNativeToken = __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").tokenService.predicateByHash(params.token, BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN);
             if (!isNativeToken) {
@@ -144,11 +143,12 @@ class Neo3NeoXBridgeService {
         });
     }
     getNonce(params) {
-        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             let log;
             try {
-                log = yield DoraBDSNeo3_1.DoraNeoRest.log(params.transactionHash, __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.id);
+                const api = DoraBDSNeo3_1.DoraBDSNeo3.getClient();
+                log = yield api.log(params.transactionHash, __classPrivateFieldGet(this, _Neo3NeoXBridgeService_service, "f").network.id);
             }
             catch (error) {
                 throw new blockchain_service_1.BSError('Failed to get nonce from transaction log', 'FAILED_TO_GET_NONCE', error);
@@ -181,7 +181,7 @@ class Neo3NeoXBridgeService {
                     jsonrpc: '2.0',
                     method: 'GetBridgeTxByNonce',
                     params: {
-                        ContractHash: this.BRIDGE_SCRIPT_HASH,
+                        ContractHash: Neo3NeoXBridgeService.BRIDGE_SCRIPT_HASH,
                         TokenHash: isNativeToken ? '' : BSNeo3Constants_1.BSNeo3Constants.NEO_TOKEN.hash,
                         Nonce: Number(params.nonce),
                     },
@@ -207,3 +207,4 @@ class Neo3NeoXBridgeService {
 }
 exports.Neo3NeoXBridgeService = Neo3NeoXBridgeService;
 _Neo3NeoXBridgeService_service = new WeakMap();
+Neo3NeoXBridgeService.BRIDGE_SCRIPT_HASH = '0xbb19cfc864b73159277e1fd39694b3fd5fc613d2';

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

@@ -1,13 +1,9 @@
-import { GetNftParam, GetNftsByAddressParams, Network, NftResponse, NftsResponse } from '@cityofzion/blockchain-service';
-import { BSNeo3NetworkId } from '../../constants/BSNeo3Constants';
-import { RpcNDSNeo3 } from './RpcNDSNeo3';
-export declare class GhostMarketNDSNeo3 extends RpcNDSNeo3 {
+import { GhostMarketNDS, THasTokenParam } from '@cityofzion/blockchain-service';
+import { IBSNeo3, TBSNeo3NetworkId } from '../../types';
+export declare class GhostMarketNDSNeo3<N extends string> extends GhostMarketNDS {
     #private;
-    static CONFIG_BY_NETWORK_ID: Partial<Record<BSNeo3NetworkId, {
-        url: string;
-        chain: string;
-    }>>;
-    constructor(network: Network<BSNeo3NetworkId>);
-    getNftsByAddress({ address, size, cursor }: GetNftsByAddressParams): Promise<NftsResponse>;
-    getNft({ collectionHash, tokenHash }: GetNftParam): Promise<NftResponse>;
+    static readonly CHAIN_BY_NETWORK_ID: Record<TBSNeo3NetworkId, string>;
+    constructor(service: IBSNeo3<N>);
+    hasToken({ collectionHash, address }: THasTokenParam): Promise<boolean>;
+    getChain(): string;
 }

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

@@ -19,91 +19,53 @@ 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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _GhostMarketNDSNeo3_instances, _GhostMarketNDSNeo3_network, _GhostMarketNDSNeo3_treatGhostMarketImage, _GhostMarketNDSNeo3_getUrlWithParams, _GhostMarketNDSNeo3_parse;
+var _GhostMarketNDSNeo3_service;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GhostMarketNDSNeo3 = void 0;
-const axios_1 = __importDefault(require("axios"));
-const query_string_1 = __importDefault(require("query-string"));
-const RpcNDSNeo3_1 = require("./RpcNDSNeo3");
-class GhostMarketNDSNeo3 extends RpcNDSNeo3_1.RpcNDSNeo3 {
-    constructor(network) {
-        super(network);
-        _GhostMarketNDSNeo3_instances.add(this);
-        _GhostMarketNDSNeo3_network.set(this, void 0);
-        __classPrivateFieldSet(this, _GhostMarketNDSNeo3_network, network, "f");
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
+const BSNeo3NeonDappKitSingletonHelper_1 = require("../../helpers/BSNeo3NeonDappKitSingletonHelper");
+class GhostMarketNDSNeo3 extends blockchain_service_1.GhostMarketNDS {
+    constructor(service) {
+        super();
+        _GhostMarketNDSNeo3_service.set(this, void 0);
+        __classPrivateFieldSet(this, _GhostMarketNDSNeo3_service, service, "f");
     }
-    getNftsByAddress({ address, size = 18, cursor }) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const url = __classPrivateFieldGet(this, _GhostMarketNDSNeo3_instances, "m", _GhostMarketNDSNeo3_getUrlWithParams).call(this, {
-                size,
-                owners: [address],
-                cursor: cursor,
-            });
-            const { data } = yield axios_1.default.get(url);
-            const nfts = (_a = data.assets) !== null && _a !== void 0 ? _a : [];
-            return { nextCursor: data.next, items: nfts.map(__classPrivateFieldGet(this, _GhostMarketNDSNeo3_instances, "m", _GhostMarketNDSNeo3_parse).bind(this)) };
+    hasToken(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ collectionHash, address }) {
+            const { NeonParser, NeonInvoker } = BSNeo3NeonDappKitSingletonHelper_1.BSNeo3NeonDappKitSingletonHelper.getInstance();
+            const invoker = yield NeonInvoker.init({ rpcAddress: __classPrivateFieldGet(this, _GhostMarketNDSNeo3_service, "f").network.url });
+            try {
+                const result = yield invoker.testInvoke({
+                    invocations: [
+                        {
+                            scriptHash: collectionHash,
+                            operation: 'balanceOf',
+                            args: [
+                                {
+                                    type: 'Hash160',
+                                    value: address,
+                                },
+                            ],
+                        },
+                    ],
+                });
+                return NeonParser.parseRpcResponse(result.stack[0], { type: 'Integer' }) > 0;
+            }
+            catch (_b) {
+                throw new Error(`Token not found: ${collectionHash}`);
+            }
         });
     }
-    getNft({ collectionHash, tokenHash }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const url = __classPrivateFieldGet(this, _GhostMarketNDSNeo3_instances, "m", _GhostMarketNDSNeo3_getUrlWithParams).call(this, {
-                contract: collectionHash,
-                tokenIds: [tokenHash],
-            });
-            const { data } = yield axios_1.default.get(url);
-            return __classPrivateFieldGet(this, _GhostMarketNDSNeo3_instances, "m", _GhostMarketNDSNeo3_parse).call(this, data.assets[0]);
-        });
+    getChain() {
+        const chain = GhostMarketNDSNeo3.CHAIN_BY_NETWORK_ID[__classPrivateFieldGet(this, _GhostMarketNDSNeo3_service, "f").network.id];
+        if (!chain)
+            throw new Error('Network not supported');
+        return chain;
     }
 }
 exports.GhostMarketNDSNeo3 = GhostMarketNDSNeo3;
-_GhostMarketNDSNeo3_network = new WeakMap(), _GhostMarketNDSNeo3_instances = new WeakSet(), _GhostMarketNDSNeo3_treatGhostMarketImage = function _GhostMarketNDSNeo3_treatGhostMarketImage(srcImage) {
-    if (!srcImage) {
-        return;
-    }
-    if (srcImage.startsWith('ipfs://')) {
-        const splitImage = srcImage.split('/');
-        const imageId = splitImage.slice(-2).filter(Boolean).join('/');
-        return `https://ghostmarket.mypinata.cloud/ipfs/${imageId}`;
-    }
-    return srcImage;
-}, _GhostMarketNDSNeo3_getUrlWithParams = function _GhostMarketNDSNeo3_getUrlWithParams(params) {
-    const config = GhostMarketNDSNeo3.CONFIG_BY_NETWORK_ID[__classPrivateFieldGet(this, _GhostMarketNDSNeo3_network, "f").id];
-    const chain = config === null || config === void 0 ? void 0 : config.chain;
-    if (!chain)
-        throw new Error('GhostMarketNDSNeo3 does not support this network');
-    const parameters = query_string_1.default.stringify(Object.assign({ chain, ownersChains: [chain] }, params), { arrayFormat: 'bracket' });
-    return `${config.url}/assets?${parameters}`;
-}, _GhostMarketNDSNeo3_parse = function _GhostMarketNDSNeo3_parse(data) {
-    var _a, _b;
-    const nftResponse = {
-        hash: data.tokenId,
-        collection: {
-            hash: data.contract.hash,
-            name: (_a = data.collection) === null || _a === void 0 ? void 0 : _a.name,
-            image: __classPrivateFieldGet(this, _GhostMarketNDSNeo3_instances, "m", _GhostMarketNDSNeo3_treatGhostMarketImage).call(this, (_b = data.collection) === null || _b === void 0 ? void 0 : _b.logoUrl),
-        },
-        symbol: data.contract.symbol,
-        image: __classPrivateFieldGet(this, _GhostMarketNDSNeo3_instances, "m", _GhostMarketNDSNeo3_treatGhostMarketImage).call(this, data.metadata.mediaUri),
-        isSVG: String(data.metadata.mediaType).includes('svg+xml'),
-        name: data.metadata.name,
-        creator: {
-            address: data.creator.address,
-            name: data.creator.offchainName,
-        },
-    };
-    return nftResponse;
-};
-GhostMarketNDSNeo3.CONFIG_BY_NETWORK_ID = {
-    mainnet: {
-        url: 'https://api.ghostmarket.io/api/v2',
-        chain: 'n3',
-    },
-    testnet: {
-        url: 'https://api.ghostmarket.io/api/v2',
-        chain: 'n3t',
-    },
+_GhostMarketNDSNeo3_service = new WeakMap();
+GhostMarketNDSNeo3.CHAIN_BY_NETWORK_ID = {
+    mainnet: 'n3',
+    testnet: 'n3t',
 };

package/dist/services/vote/DoraVoteServiceNeo3.d.ts

@@ -1,31 +1,10 @@
-import { RpcVoteServiceNeo3 } from './RpcVoteServiceNeo3';
-import { GetCandidatesToVoteResponse, GetVoteDetailsByAddressResponse } from '../../interfaces';
-import { BSNeo3 } from '../../BSNeo3';
-type AxiosCandidate = {
-    scripthash: string;
-    name: string;
-    description: string;
-    location: string;
-    website: string;
-    email: string;
-    github: string;
-    telegram: string;
-    twitter: string;
-    logo: string;
-    votes: number;
-    pubkey: string;
-};
-export type AxiosGetCandidatesToVoteResponse = AxiosCandidate[];
-export type AxiosGetVoteDetailsByAddressResponse = {
-    vote: string;
-    candidate: string;
-    candidatePubkey: string;
-    balance: number;
-};
-export declare class DoraVoteServiceNeo3<BSName extends string> extends RpcVoteServiceNeo3<BSName> {
+import { IBSNeo3, IVoteService, TVoteServiceCandidate, TVoteServiceDetailsByAddressResponse, TVoteServiceVoteParams } from '../../types';
+export declare class DoraVoteServiceNeo3<N extends string> implements IVoteService<N> {
     #private;
-    constructor(service: BSNeo3<BSName>);
-    getCandidatesToVote(): Promise<GetCandidatesToVoteResponse>;
-    getVoteDetailsByAddress(address: string): Promise<GetVoteDetailsByAddressResponse>;
+    readonly _service: IBSNeo3<N>;
+    constructor(service: IBSNeo3<N>);
+    getCandidatesToVote(): Promise<TVoteServiceCandidate[]>;
+    getVoteDetailsByAddress(address: string): Promise<TVoteServiceDetailsByAddressResponse>;
+    vote({ account, candidatePubKey }: TVoteServiceVoteParams<N>): Promise<string>;
+    calculateVoteFee({ account, candidatePubKey }: TVoteServiceVoteParams<N>): Promise<string>;
 }
-export {};

package/dist/services/vote/DoraVoteServiceNeo3.js

@@ -8,17 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+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 __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 __rest = (this && this.__rest) || function (s, e) {
     var t = {};
     for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
@@ -33,26 +33,25 @@ var __rest = (this && this.__rest) || function (s, e) {
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _DoraVoteServiceNeo3_service, _DoraVoteServiceNeo3_doraAxiosInstance;
+var _DoraVoteServiceNeo3_instances, _DoraVoteServiceNeo3_apiInstance, _DoraVoteServiceNeo3_api_get, _DoraVoteServiceNeo3_getVoteCIM;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DoraVoteServiceNeo3 = void 0;
-const BSNeo3Helper_1 = require("../../helpers/BSNeo3Helper");
 const blockchain_service_1 = require("@cityofzion/blockchain-service");
 const axios_1 = __importDefault(require("axios"));
-const RpcVoteServiceNeo3_1 = require("./RpcVoteServiceNeo3");
-class DoraVoteServiceNeo3 extends RpcVoteServiceNeo3_1.RpcVoteServiceNeo3 {
+const BSNeo3Helper_1 = require("../../helpers/BSNeo3Helper");
+const BSNeo3NeonJsSingletonHelper_1 = require("../../helpers/BSNeo3NeonJsSingletonHelper");
+const BSNeo3NeonDappKitSingletonHelper_1 = require("../../helpers/BSNeo3NeonDappKitSingletonHelper");
+class DoraVoteServiceNeo3 {
     constructor(service) {
-        super(service);
-        _DoraVoteServiceNeo3_service.set(this, void 0);
-        _DoraVoteServiceNeo3_doraAxiosInstance.set(this, void 0);
-        __classPrivateFieldSet(this, _DoraVoteServiceNeo3_service, service, "f");
-        __classPrivateFieldSet(this, _DoraVoteServiceNeo3_doraAxiosInstance, axios_1.default.create({ baseURL: `${blockchain_service_1.BSCommonConstants.DORA_URL}/api/v2/neo3` }), "f");
+        _DoraVoteServiceNeo3_instances.add(this);
+        _DoraVoteServiceNeo3_apiInstance.set(this, void 0);
+        this._service = service;
     }
     getCandidatesToVote() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!BSNeo3Helper_1.BSNeo3Helper.isMainnet(__classPrivateFieldGet(this, _DoraVoteServiceNeo3_service, "f").network))
+            if (!BSNeo3Helper_1.BSNeo3Helper.isMainnetNetwork(this._service.network))
                 throw new Error('Only Mainnet is supported');
-            const { data } = yield __classPrivateFieldGet(this, _DoraVoteServiceNeo3_doraAxiosInstance, "f").get('/mainnet/committee');
+            const { data } = yield __classPrivateFieldGet(this, _DoraVoteServiceNeo3_instances, "a", _DoraVoteServiceNeo3_api_get).get('/mainnet/committee');
             return data.map((_a, index) => {
                 var { logo } = _a, candidate = __rest(_a, ["logo"]);
                 const position = index + 1;
@@ -73,15 +72,15 @@ 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))
+            var _a, _b;
+            if (!BSNeo3Helper_1.BSNeo3Helper.isMainnetNetwork(this._service.network))
                 throw new Error('Only Mainnet is supported');
             if (!address)
                 throw new Error('Missing address');
-            if (!__classPrivateFieldGet(this, _DoraVoteServiceNeo3_service, "f").validateAddress(address))
+            if (!this._service.validateAddress(address))
                 throw new Error('Invalid address');
-            const { data } = yield __classPrivateFieldGet(this, _DoraVoteServiceNeo3_doraAxiosInstance, "f").get(`/mainnet/voter/${address}`);
+            const { data } = yield __classPrivateFieldGet(this, _DoraVoteServiceNeo3_instances, "a", _DoraVoteServiceNeo3_api_get).get(`/mainnet/voter/${address}`);
             return {
                 candidateName: (_a = data.candidate) !== null && _a !== void 0 ? _a : undefined,
                 candidatePubKey: (_b = data.candidatePubkey) !== null && _b !== void 0 ? _b : undefined,
@@ -90,6 +89,67 @@ class DoraVoteServiceNeo3 extends RpcVoteServiceNeo3_1.RpcVoteServiceNeo3 {
             };
         });
     }
+    vote(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ account, candidatePubKey }) {
+            if (!BSNeo3Helper_1.BSNeo3Helper.isMainnetNetwork(this._service.network))
+                throw new Error('Only Mainnet is supported');
+            if (!candidatePubKey)
+                throw new Error('Missing candidatePubKey param');
+            const { neonJsAccount, signingCallback } = yield this._service.generateSigningCallback(account);
+            const { NeonInvoker } = BSNeo3NeonDappKitSingletonHelper_1.BSNeo3NeonDappKitSingletonHelper.getInstance();
+            const invoker = yield NeonInvoker.init({
+                rpcAddress: this._service.network.url,
+                account: neonJsAccount,
+                signingCallback,
+            });
+            const cim = __classPrivateFieldGet(this, _DoraVoteServiceNeo3_instances, "m", _DoraVoteServiceNeo3_getVoteCIM).call(this, {
+                address: account.address,
+                candidatePubKey,
+            });
+            const transactionHash = yield invoker.invokeFunction(cim);
+            return transactionHash;
+        });
+    }
+    calculateVoteFee(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ account, candidatePubKey }) {
+            if (!BSNeo3Helper_1.BSNeo3Helper.isMainnetNetwork(this._service.network))
+                throw new Error('Only Mainnet is supported');
+            if (!candidatePubKey)
+                throw new Error('Missing candidatePubKey param');
+            const { neonJsAccount } = yield this._service.generateSigningCallback(account);
+            const { NeonInvoker } = BSNeo3NeonDappKitSingletonHelper_1.BSNeo3NeonDappKitSingletonHelper.getInstance();
+            const invoker = yield NeonInvoker.init({
+                rpcAddress: this._service.network.url,
+                account: neonJsAccount,
+            });
+            const cim = __classPrivateFieldGet(this, _DoraVoteServiceNeo3_instances, "m", _DoraVoteServiceNeo3_getVoteCIM).call(this, {
+                address: account.address,
+                candidatePubKey,
+            });
+            const { total } = yield invoker.calculateFee(cim);
+            return blockchain_service_1.BSBigNumberHelper.format(total, { decimals: this._service.feeToken.decimals });
+        });
+    }
 }
 exports.DoraVoteServiceNeo3 = DoraVoteServiceNeo3;
-_DoraVoteServiceNeo3_service = new WeakMap(), _DoraVoteServiceNeo3_doraAxiosInstance = new WeakMap();
+_DoraVoteServiceNeo3_apiInstance = new WeakMap(), _DoraVoteServiceNeo3_instances = new WeakSet(), _DoraVoteServiceNeo3_api_get = function _DoraVoteServiceNeo3_api_get() {
+    if (!__classPrivateFieldGet(this, _DoraVoteServiceNeo3_apiInstance, "f")) {
+        __classPrivateFieldSet(this, _DoraVoteServiceNeo3_apiInstance, axios_1.default.create({ baseURL: `${blockchain_service_1.BSCommonConstants.DORA_URL}/api/v2/neo3` }), "f");
+    }
+    return __classPrivateFieldGet(this, _DoraVoteServiceNeo3_apiInstance, "f");
+}, _DoraVoteServiceNeo3_getVoteCIM = function _DoraVoteServiceNeo3_getVoteCIM({ address, candidatePubKey }) {
+    const { tx } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
+    return {
+        invocations: [
+            {
+                scriptHash: 'ef4073a0f2b305a38ec4050e4d3d28bc40ea63f5',
+                operation: 'vote',
+                args: [
+                    { type: 'Hash160', value: address },
+                    { type: 'PublicKey', value: candidatePubKey },
+                ],
+            },
+        ],
+        signers: [{ scopes: tx.WitnessScope.CalledByEntry }],
+    };
+};

package/dist/types.d.ts

@@ -0,0 +1,84 @@
+import { TBSAccount, IBlockchainService, IBSWithClaim, IBSWithEncryption, IBSWithExplorer, IBSWithFee, IBSWithLedger, IBSWithNameService, IBSWithNeo3NeoXBridge, IBSWithNft, TBSNetworkId } from '@cityofzion/blockchain-service';
+import { wallet, api } from './helpers/BSNeo3NeonJsSingletonHelper';
+export type TBSNeo3NetworkId = TBSNetworkId<'mainnet' | 'testnet'>;
+export interface IBSNeo3<N extends string = string> extends IBlockchainService<N, TBSNeo3NetworkId>, IBSWithClaim<N>, IBSWithNameService, IBSWithFee<N>, IBSWithNft, IBSWithExplorer, IBSWithLedger<N>, IBSWithNeo3NeoXBridge<N>, IBSWithEncryption<N> {
+    generateSigningCallback(account: TBSAccount<N>): Promise<{
+        neonJsAccount: wallet.Account;
+        signingCallback: api.SigningFunction;
+    }>;
+}
+export type TVoteServiceCandidate = {
+    position: number;
+    name: string;
+    description: string;
+    location: string;
+    email: string;
+    website: string;
+    hash: string;
+    pubKey: string;
+    votes: number;
+    logoUrl?: string;
+    type: 'consensus' | 'council';
+};
+export type TVoteServiceDetailsByAddressResponse = {
+    candidateName?: string;
+    candidatePubKey?: string;
+    neoBalance: number;
+    address: string;
+};
+export type TVoteServiceVoteParams<BSName extends string> = {
+    account: TBSAccount<BSName>;
+    candidatePubKey: string;
+};
+export type TDoraVoteServiceNeo3GetVoteCIMParams = {
+    address: string;
+    candidatePubKey: string;
+};
+export type TDoraVoteServiceNeo3GetCommitteeApiResponse = {
+    scripthash: string;
+    name: string;
+    description: string;
+    location: string;
+    website: string;
+    email: string;
+    github: string;
+    telegram: string;
+    twitter: string;
+    logo: string;
+    votes: number;
+    pubkey: string;
+};
+export type TDoraVoteServiceNeo3GetVoteDetailsByAddressApiResponse = {
+    vote: string;
+    candidate: string;
+    candidatePubkey: string;
+    balance: number;
+};
+export interface IVoteService<BSName extends string> {
+    getCandidatesToVote(): Promise<TVoteServiceCandidate[]>;
+    getVoteDetailsByAddress(address: string): Promise<TVoteServiceDetailsByAddressResponse>;
+    vote(params: TVoteServiceVoteParams<BSName>): Promise<string>;
+    calculateVoteFee(params: TVoteServiceVoteParams<BSName>): Promise<string>;
+}
+export type TRpcVoteServiceNeo3GetVoteCIMParams = {
+    address: string;
+    candidatePubKey: string;
+};
+export type TNeo3NeoXBridgeServiceGetBridgeTxByNonceApiResponse = {
+    result: {
+        Vmstate: string;
+        txid: string;
+    };
+};
+export declare enum ENeonDappKitLedgerServiceNeo3Status {
+    OK = 36864
+}
+export declare enum ENeonDappKitLedgerServiceNeo3Command {
+    GET_APP_NAME = 0,
+    GET_PUBLIC_KEY = 4,
+    SIGN = 2
+}
+export declare enum ENeonDappKitLedgerServiceNeo3SecondParameter {
+    MORE_DATA = 128,
+    LAST_DATA = 0
+}

package/dist/types.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENeonDappKitLedgerServiceNeo3SecondParameter = exports.ENeonDappKitLedgerServiceNeo3Command = exports.ENeonDappKitLedgerServiceNeo3Status = void 0;
+var ENeonDappKitLedgerServiceNeo3Status;
+(function (ENeonDappKitLedgerServiceNeo3Status) {
+    ENeonDappKitLedgerServiceNeo3Status[ENeonDappKitLedgerServiceNeo3Status["OK"] = 36864] = "OK";
+})(ENeonDappKitLedgerServiceNeo3Status || (exports.ENeonDappKitLedgerServiceNeo3Status = ENeonDappKitLedgerServiceNeo3Status = {}));
+var ENeonDappKitLedgerServiceNeo3Command;
+(function (ENeonDappKitLedgerServiceNeo3Command) {
+    ENeonDappKitLedgerServiceNeo3Command[ENeonDappKitLedgerServiceNeo3Command["GET_APP_NAME"] = 0] = "GET_APP_NAME";
+    ENeonDappKitLedgerServiceNeo3Command[ENeonDappKitLedgerServiceNeo3Command["GET_PUBLIC_KEY"] = 4] = "GET_PUBLIC_KEY";
+    ENeonDappKitLedgerServiceNeo3Command[ENeonDappKitLedgerServiceNeo3Command["SIGN"] = 2] = "SIGN";
+})(ENeonDappKitLedgerServiceNeo3Command || (exports.ENeonDappKitLedgerServiceNeo3Command = ENeonDappKitLedgerServiceNeo3Command = {}));
+var ENeonDappKitLedgerServiceNeo3SecondParameter;
+(function (ENeonDappKitLedgerServiceNeo3SecondParameter) {
+    ENeonDappKitLedgerServiceNeo3SecondParameter[ENeonDappKitLedgerServiceNeo3SecondParameter["MORE_DATA"] = 128] = "MORE_DATA";
+    ENeonDappKitLedgerServiceNeo3SecondParameter[ENeonDappKitLedgerServiceNeo3SecondParameter["LAST_DATA"] = 0] = "LAST_DATA";
+})(ENeonDappKitLedgerServiceNeo3SecondParameter || (exports.ENeonDappKitLedgerServiceNeo3SecondParameter = ENeonDappKitLedgerServiceNeo3SecondParameter = {}));