@cityofzion/bs-neo3 1.13.2 → 1.14.1

package/dist/BSNeo3.d.ts

@@ -1,8 +1,7 @@
 import { Account, BDSClaimable, BlockchainDataService, BlockchainService, BSCalculableFee, BSClaimable, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft, ExchangeDataService, ExplorerService, GetLedgerTransport, Network, NftDataService, Token, TransferParam } from '@cityofzion/blockchain-service';
-import Neon from '@cityofzion/neon-core';
-import { api } from '@cityofzion/neon-js';
 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> {
     #private;
     name: BSName;
@@ -17,12 +16,10 @@ export declare class BSNeo3<BSName extends string = string> implements Blockchai
     ledgerService: NeonDappKitLedgerServiceNeo3<BSName>;
     exchangeDataService: ExchangeDataService;
     explorerService: ExplorerService;
+    voteService: VoteService<BSName>;
     network: Network<BSNeo3NetworkId>;
     constructor(name: BSName, network?: Network<BSNeo3NetworkId>, getLedgerTransport?: GetLedgerTransport<BSName>);
-    generateSigningCallback(account: Account<BSName>): Promise<{
-        neonJsAccount: Neon.wallet.Account;
-        signingCallback: api.SigningFunction;
-    }>;
+    generateSigningCallback(account: Account<BSName>): Promise<GenerateSigningCallbackResponse>;
     testNetwork(network: Network<BSNeo3NetworkId>): Promise<void>;
     setNetwork(network: Network<BSNeo3NetworkId>): void;
     validateAddress(address: string): boolean;

package/dist/BSNeo3.js

@@ -27,6 +27,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 DoraVoteServiceNeo3_1 = require("./services/vote/DoraVoteServiceNeo3");
 class BSNeo3 {
     constructor(name, network, getLedgerTransport) {
         _BSNeo3_instances.add(this);
@@ -67,6 +68,7 @@ class BSNeo3 {
         this.network = network;
         this.nftDataService = new GhostMarketNDSNeo3_1.GhostMarketNDSNeo3(network);
         this.explorerService = new DoraESNeo3_1.DoraESNeo3(network);
+        this.voteService = new DoraVoteServiceNeo3_1.DoraVoteServiceNeo3(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);
     }

package/dist/interfaces.d.ts

@@ -0,0 +1,41 @@
+import { Account } from '@cityofzion/blockchain-service';
+import Neon from '@cityofzion/neon-core';
+import { api } from '@cityofzion/neon-js';
+export type GenerateSigningCallbackResponse = {
+    neonJsAccount: Neon.wallet.Account;
+    signingCallback: api.SigningFunction;
+};
+type Candidate = {
+    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 GetCandidatesToVoteResponse = Candidate[];
+export type GetVoteDetailsByAddressResponse = {
+    candidateName: string;
+    candidatePubKey: string;
+    neoBalance: number;
+};
+export type VoteParams<BSName extends string> = {
+    account: Account<BSName>;
+    candidatePubKey: string;
+};
+export type VoteResponse = {
+    transactionHash: string;
+};
+export type CalculateVoteFeeParams<BSName extends string> = VoteParams<BSName>;
+export interface VoteService<BSName extends string> {
+    getCandidatesToVote(): Promise<GetCandidatesToVoteResponse>;
+    getVoteDetailsByAddress(address: string): Promise<GetVoteDetailsByAddressResponse>;
+    vote(params: VoteParams<BSName>): Promise<VoteResponse>;
+    calculateVoteFee(params: CalculateVoteFeeParams<BSName>): Promise<string>;
+}
+export {};

package/dist/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -30,7 +30,7 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-var _DoraBDSNeo3_instances, _DoraBDSNeo3_supportedNep11Standards, _DoraBDSNeo3_nftDataService, _DoraBDSNeo3_explorerService, _DoraBDSNeo3_validateFullTransactionsByAddressParams, _DoraBDSNeo3_validateGetFullTransactionsByAddressParams;
+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;
 const blockchain_service_1 = require("@cityofzion/blockchain-service");
@@ -342,11 +342,13 @@ class DoraBDSNeo3 extends RpcBDSNeo3_1.RpcBDSNeo3 {
     }
 }
 exports.DoraBDSNeo3 = DoraBDSNeo3;
-_DoraBDSNeo3_supportedNep11Standards = new WeakMap(), _DoraBDSNeo3_nftDataService = new WeakMap(), _DoraBDSNeo3_explorerService = new WeakMap(), _DoraBDSNeo3_instances = new WeakSet(), _DoraBDSNeo3_validateFullTransactionsByAddressParams = function _DoraBDSNeo3_validateFullTransactionsByAddressParams(params) {
+_DoraBDSNeo3_supportedNep11Standards = new WeakMap(), _DoraBDSNeo3_nftDataService = new WeakMap(), _DoraBDSNeo3_explorerService = new WeakMap(), _DoraBDSNeo3_instances = new WeakSet(), _DoraBDSNeo3_validateAddress = function _DoraBDSNeo3_validateAddress(address) {
+    return neon_js_1.wallet.isAddress(address, 53);
+}, _DoraBDSNeo3_validateFullTransactionsByAddressParams = function _DoraBDSNeo3_validateFullTransactionsByAddressParams(params) {
     if (BSNeo3Helper_1.BSNeo3Helper.isCustomNet(this._network))
         throw new Error('Only Mainnet and Testnet are supported');
     blockchain_service_1.BSFullTransactionsByAddressHelper.validateFullTransactionsByAddressParams(params);
-    if (!neon_js_1.wallet.isAddress(params.address))
+    if (!__classPrivateFieldGet(this, _DoraBDSNeo3_instances, "m", _DoraBDSNeo3_validateAddress).call(this, params.address))
         throw new Error('Invalid address param');
 }, _DoraBDSNeo3_validateGetFullTransactionsByAddressParams = function _DoraBDSNeo3_validateGetFullTransactionsByAddressParams(_a) {
     var { pageSize } = _a, params = __rest(_a, ["pageSize"]);

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

@@ -0,0 +1,31 @@
+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> {
+    #private;
+    constructor(service: BSNeo3<BSName>);
+    getCandidatesToVote(): Promise<GetCandidatesToVoteResponse>;
+    getVoteDetailsByAddress(address: string): Promise<GetVoteDetailsByAddressResponse>;
+}
+export {};

package/dist/services/vote/DoraVoteServiceNeo3.js

@@ -0,0 +1,95 @@
+"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 __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)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _DoraVoteServiceNeo3_service, _DoraVoteServiceNeo3_doraAxiosInstance;
+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 {
+    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");
+    }
+    getCandidatesToVote() {
+        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');
+            const { data } = yield __classPrivateFieldGet(this, _DoraVoteServiceNeo3_doraAxiosInstance, "f").get('/mainnet/committee');
+            return data.map((_a, index) => {
+                var { logo } = _a, candidate = __rest(_a, ["logo"]);
+                const position = index + 1;
+                return {
+                    position,
+                    name: candidate.name,
+                    description: candidate.description,
+                    location: candidate.location,
+                    email: candidate.email,
+                    website: candidate.website,
+                    hash: candidate.scripthash,
+                    pubKey: candidate.pubkey,
+                    votes: candidate.votes,
+                    logoUrl: logo.startsWith('https://') ? logo : undefined,
+                    type: position <= 7 ? 'consensus' : 'council',
+                };
+            });
+        });
+    }
+    getVoteDetailsByAddress(address) {
+        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');
+            if (!address)
+                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');
+            return {
+                candidateName: data.candidate,
+                candidatePubKey: candidatePubkey,
+                neoBalance: data.balance,
+            };
+        });
+    }
+}
+exports.DoraVoteServiceNeo3 = DoraVoteServiceNeo3;
+_DoraVoteServiceNeo3_service = new WeakMap(), _DoraVoteServiceNeo3_doraAxiosInstance = new WeakMap();

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

@@ -0,0 +1,10 @@
+import { CalculateVoteFeeParams, GetCandidatesToVoteResponse, GetVoteDetailsByAddressResponse, VoteParams, VoteResponse, VoteService } from '../../interfaces';
+import { BSNeo3 } from '../../BSNeo3';
+export declare abstract class RpcVoteServiceNeo3<BSName extends string> implements VoteService<BSName> {
+    #private;
+    protected constructor(service: BSNeo3<BSName>);
+    abstract getCandidatesToVote(): Promise<GetCandidatesToVoteResponse>;
+    abstract getVoteDetailsByAddress(_address: string): Promise<GetVoteDetailsByAddressResponse>;
+    vote({ account, candidatePubKey }: VoteParams<BSName>): Promise<VoteResponse>;
+    calculateVoteFee({ account, candidatePubKey }: CalculateVoteFeeParams<BSName>): Promise<string>;
+}

package/dist/services/vote/RpcVoteServiceNeo3.js

@@ -0,0 +1,88 @@
+"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 _RpcVoteServiceNeo3_instances, _RpcVoteServiceNeo3_service, _RpcVoteServiceNeo3_getVoteCIM;
+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");
+class RpcVoteServiceNeo3 {
+    constructor(service) {
+        _RpcVoteServiceNeo3_instances.add(this);
+        _RpcVoteServiceNeo3_service.set(this, void 0);
+        __classPrivateFieldSet(this, _RpcVoteServiceNeo3_service, service, "f");
+    }
+    vote({ account, candidatePubKey }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!BSNeo3Helper_1.BSNeo3Helper.isMainnet(__classPrivateFieldGet(this, _RpcVoteServiceNeo3_service, "f").network))
+                throw new Error('Only Mainnet is supported');
+            if (!candidatePubKey)
+                throw new Error('Missing candidatePubKey param');
+            const { neonJsAccount, signingCallback } = yield __classPrivateFieldGet(this, _RpcVoteServiceNeo3_service, "f").generateSigningCallback(account);
+            const invoker = yield neon_dappkit_1.NeonInvoker.init({
+                rpcAddress: __classPrivateFieldGet(this, _RpcVoteServiceNeo3_service, "f").network.url,
+                account: neonJsAccount,
+                signingCallback,
+            });
+            const transactionHash = yield invoker.invokeFunction(__classPrivateFieldGet(this, _RpcVoteServiceNeo3_instances, "m", _RpcVoteServiceNeo3_getVoteCIM).call(this, {
+                address: account.address,
+                candidatePubKey,
+            }));
+            return { transactionHash };
+        });
+    }
+    calculateVoteFee({ account, candidatePubKey }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!BSNeo3Helper_1.BSNeo3Helper.isMainnet(__classPrivateFieldGet(this, _RpcVoteServiceNeo3_service, "f").network))
+                throw new Error('Only Mainnet is supported');
+            if (!candidatePubKey)
+                throw new Error('Missing candidatePubKey param');
+            const { neonJsAccount } = yield __classPrivateFieldGet(this, _RpcVoteServiceNeo3_service, "f").generateSigningCallback(account);
+            const invoker = yield neon_dappkit_1.NeonInvoker.init({
+                rpcAddress: __classPrivateFieldGet(this, _RpcVoteServiceNeo3_service, "f").network.url,
+                account: neonJsAccount,
+            });
+            const { total } = yield invoker.calculateFee(__classPrivateFieldGet(this, _RpcVoteServiceNeo3_instances, "m", _RpcVoteServiceNeo3_getVoteCIM).call(this, {
+                address: account.address,
+                candidatePubKey,
+            }));
+            return blockchain_service_1.BSNumberHelper.formatNumber(total, { decimals: __classPrivateFieldGet(this, _RpcVoteServiceNeo3_service, "f").feeToken.decimals });
+        });
+    }
+}
+exports.RpcVoteServiceNeo3 = RpcVoteServiceNeo3;
+_RpcVoteServiceNeo3_service = new WeakMap(), _RpcVoteServiceNeo3_instances = new WeakSet(), _RpcVoteServiceNeo3_getVoteCIM = function _RpcVoteServiceNeo3_getVoteCIM({ address, candidatePubKey }) {
+    return {
+        invocations: [
+            {
+                scriptHash: 'ef4073a0f2b305a38ec4050e4d3d28bc40ea63f5',
+                operation: 'vote',
+                args: [
+                    { type: 'Hash160', value: address },
+                    { type: 'PublicKey', value: candidatePubKey },
+                ],
+            },
+        ],
+        signers: [{ scopes: neon_js_1.tx.WitnessScope.CalledByEntry }],
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-neo3",
-  "version": "1.13.2",
+  "version": "1.14.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",