@cityofzion/bs-neo-legacy 1.13.4 → 1.13.5

package/dist/BSNeoLegacy.d.ts

@@ -1,62 +1,46 @@
-import { Account, BDSClaimable, BlockchainDataService, BlockchainService, BSClaimable, ExchangeDataService, Token, Network, TransferParam, BSWithExplorerService, ExplorerService, BSWithLedger, GetLedgerTransport, BalanceResponse, BSWithEncryption, ITokenService } from '@cityofzion/blockchain-service';
-import { BSNeoLegacyNetworkId } from './constants/BSNeoLegacyConstants';
+import { TBSAccount, TBSToken, TTransferParam, TGetLedgerTransport, ITokenService, TBSNetwork, IClaimDataService, IBlockchainDataService, IExchangeDataService, IExplorerService, TPingNetworkResponse } from '@cityofzion/blockchain-service';
 import { NeonJsLedgerServiceNeoLegacy } from './services/ledger/NeonJsLedgerServiceNeoLegacy';
-export type MigrateParams<BSName extends string = string> = {
-    account: Account<BSName>;
-    neo3Address: string;
-    neoLegacyMigrationAmounts: CalculateNeoLegacyMigrationAmountsResponse;
-};
-export type CalculateNeo3MigrationAmountsResponse = {
-    gasMigrationTotalFees?: string;
-    neoMigrationTotalFees?: string;
-    gasMigrationReceiveAmount?: string;
-    neoMigrationReceiveAmount?: string;
-};
-export type CalculateNeoLegacyMigrationAmountsResponse = {
-    hasEnoughGasBalance: boolean;
-    hasEnoughNeoBalance: boolean;
-    gasBalance?: BalanceResponse;
-    neoBalance?: BalanceResponse;
-};
-export declare class BSNeoLegacy<BSName extends string = string> implements BlockchainService<BSName, BSNeoLegacyNetworkId>, BSClaimable<BSName>, BSWithExplorerService, BSWithLedger<BSName>, BSWithEncryption<BSName> {
+import { IBSNeoLegacy, TBSNeoLegacyNetworkId, TSigningCallback } from './types';
+import { Neo3NeoLegacyMigrationService } from './services/migration/Neo3NeoLegacyMigrationService';
+export declare class BSNeoLegacy<N extends string = string> implements IBSNeoLegacy<N> {
     #private;
-    NATIVE_ASSETS: {
-        symbol: string;
-        name: string;
-        hash: string;
-        decimals: number;
-    }[];
-    readonly name: BSName;
+    readonly name: N;
     readonly bip44DerivationPath: string;
-    nativeTokens: Token[];
-    feeToken: Token;
-    claimToken: Token;
-    burnToken: Token;
-    blockchainDataService: BlockchainDataService & BDSClaimable;
-    exchangeDataService: ExchangeDataService;
-    ledgerService: NeonJsLedgerServiceNeoLegacy<BSName>;
-    explorerService: ExplorerService;
-    tokenService: ITokenService;
-    tokens: Token[];
-    network: Network<BSNeoLegacyNetworkId>;
+    readonly isMultiTransferSupported = true;
+    readonly isCustomNetworkSupported = false;
+    readonly tokens: TBSToken[];
+    readonly nativeTokens: TBSToken[];
+    readonly feeToken: TBSToken;
+    readonly claimToken: TBSToken;
+    readonly burnToken: TBSToken;
+    network: TBSNetwork<TBSNeoLegacyNetworkId>;
+    availableNetworkURLs: string[];
     legacyNetwork: string;
-    constructor(name: BSName, network?: Network<BSNeoLegacyNetworkId>, getLedgerTransport?: GetLedgerTransport<BSName>);
-    testNetwork(network: Network<BSNeoLegacyNetworkId>): Promise<void>;
-    setNetwork(network: Network<BSNeoLegacyNetworkId>): void;
+    readonly defaultNetwork: TBSNetwork<TBSNeoLegacyNetworkId>;
+    readonly availableNetworks: TBSNetwork<TBSNeoLegacyNetworkId>[];
+    blockchainDataService: IBlockchainDataService;
+    exchangeDataService: IExchangeDataService;
+    ledgerService: NeonJsLedgerServiceNeoLegacy<N>;
+    explorerService: IExplorerService;
+    tokenService: ITokenService;
+    claimDataService: IClaimDataService;
+    neo3NeoLegacyMigrationService: Neo3NeoLegacyMigrationService<N>;
+    constructor(name: N, network?: TBSNetwork<TBSNeoLegacyNetworkId>, getLedgerTransport?: TGetLedgerTransport<N>);
+    sendTransfer(config: any, nep5ScriptBuilder?: any): Promise<any>;
+    generateSigningCallback(account: TBSAccount<N>): Promise<{
+        neonJsAccount: any;
+        signingCallback: TSigningCallback;
+    }>;
+    setNetwork(network: TBSNetwork<TBSNeoLegacyNetworkId>): void;
+    pingNetwork(network: TBSNetwork<TBSNeoLegacyNetworkId>): Promise<TPingNetworkResponse>;
     validateAddress(address: string): boolean;
     validateEncrypted(key: string): boolean;
     validateKey(key: string): boolean;
-    generateAccountFromMnemonic(mnemonic: string[] | string, index: number): Account<BSName>;
-    generateAccountFromKey(key: string): Account<BSName>;
-    generateAccountFromPublicKey(publicKey: string): Account<BSName>;
-    decrypt(encryptedKey: string, password: string): Promise<Account<BSName>>;
+    generateAccountFromMnemonic(mnemonic: string[] | string, index: number): TBSAccount<N>;
+    generateAccountFromKey(key: string): TBSAccount<N>;
+    generateAccountFromPublicKey(publicKey: string): TBSAccount<N>;
+    decrypt(encryptedKey: string, password: string): Promise<TBSAccount<N>>;
     encrypt(key: string, password: string): Promise<string>;
-    transfer({ intents, senderAccount, tipIntent, ...params }: TransferParam<BSName>): Promise<string[]>;
-    claim(account: Account<BSName>): Promise<string>;
-    migrate({ account, neo3Address, neoLegacyMigrationAmounts }: MigrateParams<BSName>): Promise<string>;
-    /**
-     * Reference: https://github.com/CityOfZion/legacy-n3-swap-service/blob/master/policy/policy.go
-     */
-    calculateNeo3MigrationAmounts(neoLegacyMigrationAmounts: CalculateNeoLegacyMigrationAmountsResponse): CalculateNeo3MigrationAmountsResponse;
-    calculateNeoLegacyMigrationAmounts(balance: BalanceResponse[]): CalculateNeoLegacyMigrationAmountsResponse;
+    transfer({ intents, senderAccount, tipIntent, ...params }: TTransferParam<N>): Promise<string[]>;
+    claim(account: TBSAccount<N>): Promise<string>;
 }

package/dist/BSNeoLegacy.js

@@ -24,74 +24,145 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-var _BSNeoLegacy_instances, _BSNeoLegacy_generateSigningCallback, _BSNeoLegacy_setTokens, _BSNeoLegacy_hasTransactionMoreThanMaxSize, _BSNeoLegacy_getRequiredTransactionFeeConfig, _BSNeoLegacy_signTransfer, _BSNeoLegacy_sendTransfer, _BSNeoLegacy_signClaim, _BSNeoLegacy_sendClaim;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _BSNeoLegacy_instances, _BSNeoLegacy_hasTransactionMoreThanMaxSize, _BSNeoLegacy_getRequiredTransactionFeeConfig, _BSNeoLegacy_signClaim, _BSNeoLegacy_sendClaim, _BSNeoLegacy_signTransfer;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSNeoLegacy = void 0;
 const blockchain_service_1 = require("@cityofzion/blockchain-service");
-const neon_js_1 = require("@cityofzion/neon-js");
-const bs_asteroid_sdk_1 = require("@cityofzion/bs-asteroid-sdk");
 const BSNeoLegacyConstants_1 = require("./constants/BSNeoLegacyConstants");
-const BSNeoLegacyHelper_1 = require("./helpers/BSNeoLegacyHelper");
 const CryptoCompareEDSNeoLegacy_1 = require("./services/exchange-data/CryptoCompareEDSNeoLegacy");
 const DoraBDSNeoLegacy_1 = require("./services/blockchain-data/DoraBDSNeoLegacy");
 const NeoTubeESNeoLegacy_1 = require("./services/explorer/NeoTubeESNeoLegacy");
 const NeonJsLedgerServiceNeoLegacy_1 = require("./services/ledger/NeonJsLedgerServiceNeoLegacy");
 const TokenServiceNeoLegacy_1 = require("./services/token/TokenServiceNeoLegacy");
+const DoraCDSNeoLegacy_1 = require("./services/claim-data/DoraCDSNeoLegacy");
+const Neo3NeoLegacyMigrationService_1 = require("./services/migration/Neo3NeoLegacyMigrationService");
+const BSNeoLegacyNeonJsSingletonHelper_1 = require("./helpers/BSNeoLegacyNeonJsSingletonHelper");
+const axios_1 = __importDefault(require("axios"));
 class BSNeoLegacy {
     constructor(name, network, getLedgerTransport) {
         _BSNeoLegacy_instances.add(this);
-        this.NATIVE_ASSETS = BSNeoLegacyConstants_1.BSNeoLegacyConstants.NATIVE_ASSETS;
-        network = network !== null && network !== void 0 ? network : BSNeoLegacyConstants_1.BSNeoLegacyConstants.DEFAULT_NETWORK;
+        this.isMultiTransferSupported = true;
+        this.isCustomNetworkSupported = false;
         this.name = name;
-        this.legacyNetwork = BSNeoLegacyConstants_1.BSNeoLegacyConstants.LEGACY_NETWORK_BY_NETWORK_ID[network.id];
         this.ledgerService = new NeonJsLedgerServiceNeoLegacy_1.NeonJsLedgerServiceNeoLegacy(this, getLedgerTransport);
         this.bip44DerivationPath = BSNeoLegacyConstants_1.BSNeoLegacyConstants.DEFAULT_BIP44_DERIVATION_PATH;
-        this.setNetwork(network);
+        this.nativeTokens = BSNeoLegacyConstants_1.BSNeoLegacyConstants.NATIVE_ASSETS;
+        this.feeToken = BSNeoLegacyConstants_1.BSNeoLegacyConstants.GAS_ASSET;
+        this.burnToken = BSNeoLegacyConstants_1.BSNeoLegacyConstants.NEO_ASSET;
+        this.claimToken = BSNeoLegacyConstants_1.BSNeoLegacyConstants.GAS_ASSET;
+        this.tokens = this.nativeTokens;
+        this.availableNetworks = BSNeoLegacyConstants_1.BSNeoLegacyConstants.ALL_NETWORKS;
+        this.defaultNetwork = BSNeoLegacyConstants_1.BSNeoLegacyConstants.MAINNET_NETWORK;
+        this.setNetwork(network !== null && network !== void 0 ? network : this.defaultNetwork);
     }
-    testNetwork(network) {
+    sendTransfer(config, nep5ScriptBuilder) {
         return __awaiter(this, void 0, void 0, function* () {
-            const blockchainDataServiceClone = new DoraBDSNeoLegacy_1.DoraBDSNeoLegacy(network, this.feeToken, this.claimToken, this.tokens, this.explorerService, this.tokenService);
-            yield blockchainDataServiceClone.getBlockHeight();
+            const { api } = BSNeoLegacyNeonJsSingletonHelper_1.BSNeoLegacyNeonJsSingletonHelper.getInstance();
+            const sharedConfig = yield api.fillBalance(config);
+            let signedConfig = yield __classPrivateFieldGet(this, _BSNeoLegacy_instances, "m", _BSNeoLegacy_signTransfer).call(this, Object.assign({}, sharedConfig), nep5ScriptBuilder);
+            if (__classPrivateFieldGet(this, _BSNeoLegacy_instances, "m", _BSNeoLegacy_hasTransactionMoreThanMaxSize).call(this, signedConfig)) {
+                signedConfig = yield __classPrivateFieldGet(this, _BSNeoLegacy_instances, "m", _BSNeoLegacy_signTransfer).call(this, __classPrivateFieldGet(this, _BSNeoLegacy_instances, "m", _BSNeoLegacy_getRequiredTransactionFeeConfig).call(this, sharedConfig), nep5ScriptBuilder);
+            }
+            signedConfig = yield api.sendTx(signedConfig);
+            return signedConfig.response.txid;
+        });
+    }
+    generateSigningCallback(account) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { wallet, api } = BSNeoLegacyNeonJsSingletonHelper_1.BSNeoLegacyNeonJsSingletonHelper.getInstance();
+            const neonJsAccount = new wallet.Account(account.key);
+            if (account.isHardware) {
+                if (!this.ledgerService.getLedgerTransport)
+                    throw new Error('You must provide a getLedgerTransport function to use Ledger');
+                if (typeof account.bip44Path !== 'string')
+                    throw new Error('Your account must have bip44 path to use Ledger');
+                const ledgerTransport = yield this.ledgerService.getLedgerTransport(account);
+                return {
+                    neonJsAccount,
+                    signingCallback: this.ledgerService.getSigningCallback(ledgerTransport, account),
+                };
+            }
+            return {
+                neonJsAccount,
+                signingCallback: api.signWithPrivateKey(neonJsAccount.privateKey),
+            };
         });
     }
     setNetwork(network) {
-        if (!BSNeoLegacyConstants_1.BSNeoLegacyConstants.ALL_NETWORK_IDS.includes(network.id))
-            throw new Error('Custom network is not supported');
-        __classPrivateFieldGet(this, _BSNeoLegacy_instances, "m", _BSNeoLegacy_setTokens).call(this, network);
+        const availableURLs = BSNeoLegacyConstants_1.BSNeoLegacyConstants.RPC_LIST_BY_NETWORK_ID[network.id] || [];
+        const isValidNetwork = blockchain_service_1.BSUtilsHelper.validateNetwork(network, this.availableNetworks, availableURLs);
+        if (!isValidNetwork) {
+            throw new Error(`Network with id ${network.id} is not available for ${this.name}`);
+        }
         this.network = network;
+        this.legacyNetwork = BSNeoLegacyConstants_1.BSNeoLegacyConstants.LEGACY_NETWORK_BY_NETWORK_ID[network.id];
+        this.availableNetworkURLs = availableURLs;
         this.tokenService = new TokenServiceNeoLegacy_1.TokenServiceNeoLegacy();
-        this.explorerService = new NeoTubeESNeoLegacy_1.NeoTubeESNeoLegacy(network, this.tokenService);
-        this.blockchainDataService = new DoraBDSNeoLegacy_1.DoraBDSNeoLegacy(network, this.feeToken, this.claimToken, this.tokens, this.explorerService, this.tokenService);
-        this.exchangeDataService = new CryptoCompareEDSNeoLegacy_1.CryptoCompareEDSNeoLegacy(network);
+        this.explorerService = new NeoTubeESNeoLegacy_1.NeoTubeESNeoLegacy(this);
+        this.blockchainDataService = new DoraBDSNeoLegacy_1.DoraBDSNeoLegacy(this);
+        this.exchangeDataService = new CryptoCompareEDSNeoLegacy_1.CryptoCompareEDSNeoLegacy(this);
+        this.claimDataService = new DoraCDSNeoLegacy_1.DoraCDSNeoLegacy(this);
+        this.neo3NeoLegacyMigrationService = new Neo3NeoLegacyMigrationService_1.Neo3NeoLegacyMigrationService(this);
+    }
+    // This method is done manually because we need to ensure that the request is aborted after timeout
+    pingNetwork(network) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const abortController = new AbortController();
+            const timeout = setTimeout(() => {
+                abortController.abort();
+            }, 5000);
+            const timeStart = Date.now();
+            const response = yield axios_1.default.post(network.url, {
+                jsonrpc: '2.0',
+                method: 'getblockcount',
+                params: [],
+                id: 1234,
+            }, { timeout: 5000, signal: abortController.signal });
+            clearTimeout(timeout);
+            const latency = Date.now() - timeStart;
+            return {
+                latency,
+                url: network.url,
+                height: response.data.result,
+            };
+        });
     }
     validateAddress(address) {
-        return neon_js_1.wallet.isAddress(address);
+        const { wallet } = BSNeoLegacyNeonJsSingletonHelper_1.BSNeoLegacyNeonJsSingletonHelper.getInstance();
+        return wallet.isAddress(address);
     }
     validateEncrypted(key) {
-        return neon_js_1.wallet.isNEP2(key);
+        const { wallet } = BSNeoLegacyNeonJsSingletonHelper_1.BSNeoLegacyNeonJsSingletonHelper.getInstance();
+        return wallet.isNEP2(key);
     }
     validateKey(key) {
-        return neon_js_1.wallet.isWIF(key) || neon_js_1.wallet.isPrivateKey(key);
+        const { wallet } = BSNeoLegacyNeonJsSingletonHelper_1.BSNeoLegacyNeonJsSingletonHelper.getInstance();
+        return wallet.isWIF(key) || wallet.isPrivateKey(key);
     }
     generateAccountFromMnemonic(mnemonic, index) {
-        bs_asteroid_sdk_1.keychain.importMnemonic(Array.isArray(mnemonic) ? mnemonic.join(' ') : mnemonic);
+        const mnemonicStr = Array.isArray(mnemonic) ? mnemonic.join(' ') : mnemonic;
         const bip44Path = this.bip44DerivationPath.replace('?', index.toString());
-        const childKey = bs_asteroid_sdk_1.keychain.generateChildKey('neo', bip44Path);
-        const key = childKey.getWIF();
-        const { address } = new neon_js_1.wallet.Account(key);
-        return { address, key, type: 'wif', bip44Path, blockchain: this.name };
+        const key = blockchain_service_1.BSKeychainHelper.generateNeoPrivateKeyFromMnemonic(mnemonicStr, bip44Path);
+        const { wallet } = BSNeoLegacyNeonJsSingletonHelper_1.BSNeoLegacyNeonJsSingletonHelper.getInstance();
+        const { address, WIF } = new wallet.Account(key);
+        return { address, key: WIF, type: 'wif', bip44Path, blockchain: this.name };
     }
     generateAccountFromKey(key) {
-        const type = neon_js_1.wallet.isWIF(key) ? 'wif' : neon_js_1.wallet.isPrivateKey(key) ? 'privateKey' : undefined;
+        const { wallet } = BSNeoLegacyNeonJsSingletonHelper_1.BSNeoLegacyNeonJsSingletonHelper.getInstance();
+        const type = wallet.isWIF(key) ? 'wif' : wallet.isPrivateKey(key) ? 'privateKey' : undefined;
         if (!type)
             throw new Error('Invalid key');
-        const { address } = new neon_js_1.wallet.Account(key);
+        const { address } = new wallet.Account(key);
         return { address, key, type, blockchain: this.name };
     }
     generateAccountFromPublicKey(publicKey) {
-        if (!neon_js_1.wallet.isPublicKey(publicKey))
+        const { wallet } = BSNeoLegacyNeonJsSingletonHelper_1.BSNeoLegacyNeonJsSingletonHelper.getInstance();
+        if (!wallet.isPublicKey(publicKey))
             throw new Error('Invalid public key');
-        const account = new neon_js_1.wallet.Account(publicKey);
+        const account = new wallet.Account(publicKey);
         return {
             address: account.address,
             key: account.publicKey,
@@ -101,40 +172,43 @@ class BSNeoLegacy {
     }
     decrypt(encryptedKey, password) {
         return __awaiter(this, void 0, void 0, function* () {
-            const key = yield neon_js_1.wallet.decrypt(encryptedKey, password);
+            const { wallet } = BSNeoLegacyNeonJsSingletonHelper_1.BSNeoLegacyNeonJsSingletonHelper.getInstance();
+            const key = yield wallet.decrypt(encryptedKey, password);
             return this.generateAccountFromKey(key);
         });
     }
     encrypt(key, password) {
-        return neon_js_1.wallet.encrypt(key, password);
+        const { wallet } = BSNeoLegacyNeonJsSingletonHelper_1.BSNeoLegacyNeonJsSingletonHelper.getInstance();
+        return wallet.encrypt(key, password);
     }
     transfer(_a) {
-        var _b, _c;
-        var { intents, senderAccount, tipIntent } = _a, params = __rest(_a, ["intents", "senderAccount", "tipIntent"]);
         return __awaiter(this, void 0, void 0, function* () {
-            const { neonJsAccount, signingCallback } = yield __classPrivateFieldGet(this, _BSNeoLegacy_instances, "m", _BSNeoLegacy_generateSigningCallback).call(this, senderAccount);
-            const apiProvider = new neon_js_1.api.neoCli.instance(this.network.url);
+            var _b, _c;
+            var { intents, senderAccount, tipIntent } = _a, params = __rest(_a, ["intents", "senderAccount", "tipIntent"]);
+            const { neonJsAccount, signingCallback } = yield this.generateSigningCallback(senderAccount);
+            const { api, sc, u, wallet } = BSNeoLegacyNeonJsSingletonHelper_1.BSNeoLegacyNeonJsSingletonHelper.getInstance();
+            const apiProvider = new api.neoCli.instance(this.network.url);
             const priorityFee = Number((_b = params.priorityFee) !== null && _b !== void 0 ? _b : 0);
             const nativeIntents = [];
-            const nep5ScriptBuilder = new neon_js_1.sc.ScriptBuilder();
+            const nep5ScriptBuilder = new sc.ScriptBuilder();
             const concatIntents = [...intents, ...(tipIntent ? [tipIntent] : [])];
             for (const intent of concatIntents) {
                 const normalizeTokenHash = this.tokenService.normalizeHash(intent.tokenHash);
-                const nativeAsset = this.NATIVE_ASSETS.find(token => this.tokenService.predicateByHash(normalizeTokenHash, token));
+                const nativeAsset = this.nativeTokens.find(token => this.tokenService.predicateByHash(normalizeTokenHash, token));
                 if (nativeAsset) {
-                    nativeIntents.push(...neon_js_1.api.makeIntent({ [nativeAsset.symbol]: Number(intent.amount) }, intent.receiverAddress));
+                    nativeIntents.push(...api.makeIntent({ [nativeAsset.symbol]: Number(intent.amount) }, intent.receiverAddress));
                     continue;
                 }
                 nep5ScriptBuilder.emitAppCall(normalizeTokenHash, 'transfer', [
-                    neon_js_1.u.reverseHex(neon_js_1.wallet.getScriptHashFromAddress(neonJsAccount.address)),
-                    neon_js_1.u.reverseHex(neon_js_1.wallet.getScriptHashFromAddress(intent.receiverAddress)),
-                    neon_js_1.sc.ContractParam.integer(new neon_js_1.u.Fixed8(intent.amount)
+                    u.reverseHex(wallet.getScriptHashFromAddress(neonJsAccount.address)),
+                    u.reverseHex(wallet.getScriptHashFromAddress(intent.receiverAddress)),
+                    sc.ContractParam.integer(new u.Fixed8(intent.amount)
                         .div(Math.pow(10, 8 - ((_c = intent.tokenDecimals) !== null && _c !== void 0 ? _c : 8)))
                         .toRawNumber()
                         .toString()),
                 ]);
             }
-            const hash = yield __classPrivateFieldGet(this, _BSNeoLegacy_instances, "m", _BSNeoLegacy_sendTransfer).call(this, {
+            const hash = yield this.sendTransfer({
                 account: neonJsAccount,
                 api: apiProvider,
                 url: this.network.url,
@@ -147,8 +221,9 @@ class BSNeoLegacy {
     }
     claim(account) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { neonJsAccount, signingCallback } = yield __classPrivateFieldGet(this, _BSNeoLegacy_instances, "m", _BSNeoLegacy_generateSigningCallback).call(this, account);
-            const apiProvider = new neon_js_1.api.neoCli.instance(this.legacyNetwork);
+            const { neonJsAccount, signingCallback } = yield this.generateSigningCallback(account);
+            const { api } = BSNeoLegacyNeonJsSingletonHelper_1.BSNeoLegacyNeonJsSingletonHelper.getInstance();
+            const apiProvider = new api.neoCli.instance(this.legacyNetwork);
             return yield __classPrivateFieldGet(this, _BSNeoLegacy_instances, "m", _BSNeoLegacy_sendClaim).call(this, {
                 api: apiProvider,
                 account: neonJsAccount,
@@ -157,128 +232,9 @@ class BSNeoLegacy {
             });
         });
     }
-    migrate({ account, neo3Address, neoLegacyMigrationAmounts }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!BSNeoLegacyHelper_1.BSNeoLegacyHelper.isMainnet(this.network)) {
-                throw new Error('Must use Mainnet network');
-            }
-            if ((!neoLegacyMigrationAmounts.hasEnoughGasBalance && !neoLegacyMigrationAmounts.hasEnoughNeoBalance) ||
-                (!neoLegacyMigrationAmounts.gasBalance && !neoLegacyMigrationAmounts.neoBalance)) {
-                throw new Error('Must have at least 0.1 GAS or 2 NEO');
-            }
-            const { neonJsAccount, signingCallback } = yield __classPrivateFieldGet(this, _BSNeoLegacy_instances, "m", _BSNeoLegacy_generateSigningCallback).call(this, account);
-            const provider = new neon_js_1.api.neoCli.instance(this.network.url);
-            const intents = [];
-            if (neoLegacyMigrationAmounts.hasEnoughGasBalance && neoLegacyMigrationAmounts.gasBalance)
-                intents.push(...neon_js_1.api.makeIntent({ [BSNeoLegacyConstants_1.BSNeoLegacyConstants.GAS_ASSET.symbol]: Number(neoLegacyMigrationAmounts.gasBalance.amount) }, BSNeoLegacyConstants_1.BSNeoLegacyConstants.MIGRATION_COZ_LEGACY_ADDRESS));
-            if (neoLegacyMigrationAmounts.hasEnoughNeoBalance && neoLegacyMigrationAmounts.neoBalance)
-                intents.push(...neon_js_1.api.makeIntent({ [BSNeoLegacyConstants_1.BSNeoLegacyConstants.NEO_ASSET.symbol]: Number(neoLegacyMigrationAmounts.neoBalance.amount) }, BSNeoLegacyConstants_1.BSNeoLegacyConstants.MIGRATION_COZ_LEGACY_ADDRESS));
-            return yield __classPrivateFieldGet(this, _BSNeoLegacy_instances, "m", _BSNeoLegacy_sendTransfer).call(this, {
-                url: this.network.url,
-                api: provider,
-                account: neonJsAccount,
-                intents,
-                signingFunction: signingCallback,
-                override: {
-                    attributes: [
-                        new neon_js_1.tx.TransactionAttribute({
-                            usage: neon_js_1.tx.TxAttrUsage.Remark14,
-                            data: neon_js_1.u.str2hexstring(neo3Address),
-                        }),
-                        new neon_js_1.tx.TransactionAttribute({
-                            usage: neon_js_1.tx.TxAttrUsage.Remark15,
-                            data: neon_js_1.u.str2hexstring('Neon Desktop Migration'),
-                        }),
-                    ],
-                },
-            });
-        });
-    }
-    /**
-     * Reference: https://github.com/CityOfZion/legacy-n3-swap-service/blob/master/policy/policy.go
-     */
-    calculateNeo3MigrationAmounts(neoLegacyMigrationAmounts) {
-        const response = {
-            gasMigrationReceiveAmount: undefined,
-            gasMigrationTotalFees: undefined,
-            neoMigrationReceiveAmount: undefined,
-            neoMigrationTotalFees: undefined,
-        };
-        if (neoLegacyMigrationAmounts.gasBalance && neoLegacyMigrationAmounts.hasEnoughGasBalance) {
-            // Two transfers fee and one transfer fee left over
-            const allNep17TransfersFee = BSNeoLegacyConstants_1.BSNeoLegacyConstants.MIGRATION_NEP_17_TRANSFER_FEE * 3;
-            const gasMigrationAmountNumber = Number(neoLegacyMigrationAmounts.gasBalance.amount);
-            // Necessary to calculate the COZ fee
-            const gasAmountNumberLessAllNep17TransfersFee = gasMigrationAmountNumber - allNep17TransfersFee;
-            // Example: ~0.06635710 * 0.01 = ~0.00066357
-            const cozFee = gasAmountNumberLessAllNep17TransfersFee * BSNeoLegacyConstants_1.BSNeoLegacyConstants.MIGRATION_COZ_FEE;
-            // Example: ~0.06635710 - ~0.00066357 = ~0.06569352
-            const gasAmountNumberLessCozFee = gasAmountNumberLessAllNep17TransfersFee - cozFee;
-            const allGasFeeNumberThatUserWillPay = cozFee + BSNeoLegacyConstants_1.BSNeoLegacyConstants.MIGRATION_NEP_17_TRANSFER_FEE * 2;
-            const allGasAmountNumberThatUserWillReceive = gasAmountNumberLessCozFee + BSNeoLegacyConstants_1.BSNeoLegacyConstants.MIGRATION_NEP_17_TRANSFER_FEE;
-            response.gasMigrationTotalFees = blockchain_service_1.BSBigNumberHelper.format(allGasFeeNumberThatUserWillPay, {
-                decimals: BSNeoLegacyConstants_1.BSNeoLegacyConstants.GAS_ASSET.decimals,
-            });
-            response.gasMigrationReceiveAmount = blockchain_service_1.BSBigNumberHelper.format(allGasAmountNumberThatUserWillReceive, {
-                decimals: BSNeoLegacyConstants_1.BSNeoLegacyConstants.GAS_ASSET.decimals,
-            });
-        }
-        if (neoLegacyMigrationAmounts.neoBalance && neoLegacyMigrationAmounts.hasEnoughNeoBalance) {
-            const neoMigrationAmountNumber = Number(neoLegacyMigrationAmounts.neoBalance.amount);
-            response.neoMigrationTotalFees = blockchain_service_1.BSBigNumberHelper.format(Math.ceil(neoMigrationAmountNumber * BSNeoLegacyConstants_1.BSNeoLegacyConstants.MIGRATION_COZ_FEE), { decimals: BSNeoLegacyConstants_1.BSNeoLegacyConstants.NEO_ASSET.decimals });
-            response.neoMigrationReceiveAmount = blockchain_service_1.BSBigNumberHelper.format(neoMigrationAmountNumber - Number(response.neoMigrationTotalFees), { decimals: BSNeoLegacyConstants_1.BSNeoLegacyConstants.NEO_ASSET.decimals });
-        }
-        return response;
-    }
-    calculateNeoLegacyMigrationAmounts(balance) {
-        const gasBalance = balance.find(({ token }) => this.tokenService.predicateByHash(BSNeoLegacyConstants_1.BSNeoLegacyConstants.GAS_ASSET, token));
-        const neoBalance = balance.find(({ token }) => this.tokenService.predicateByHash(BSNeoLegacyConstants_1.BSNeoLegacyConstants.NEO_ASSET, token));
-        let hasEnoughGasBalance = false;
-        let hasEnoughNeoBalance = false;
-        if (gasBalance) {
-            const gasBalanceNumber = blockchain_service_1.BSBigNumberHelper.fromNumber(gasBalance.amount);
-            hasEnoughGasBalance = gasBalanceNumber.isGreaterThanOrEqualTo(BSNeoLegacyConstants_1.BSNeoLegacyConstants.MIGRATION_MIN_GAS);
-        }
-        if (neoBalance) {
-            const neoBalanceNumber = blockchain_service_1.BSBigNumberHelper.fromNumber(neoBalance.amount);
-            hasEnoughNeoBalance = neoBalanceNumber.isGreaterThanOrEqualTo(BSNeoLegacyConstants_1.BSNeoLegacyConstants.MIGRATION_MIN_NEO);
-        }
-        return {
-            gasBalance,
-            neoBalance,
-            hasEnoughGasBalance,
-            hasEnoughNeoBalance,
-        };
-    }
 }
 exports.BSNeoLegacy = BSNeoLegacy;
-_BSNeoLegacy_instances = new WeakSet(), _BSNeoLegacy_generateSigningCallback = function _BSNeoLegacy_generateSigningCallback(account) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const neonJsAccount = new neon_js_1.wallet.Account(account.key);
-        if (account.isHardware) {
-            if (!this.ledgerService.getLedgerTransport)
-                throw new Error('You must provide a getLedgerTransport function to use Ledger');
-            if (typeof account.bip44Path !== 'string')
-                throw new Error('Your account must have bip44 path to use Ledger');
-            const ledgerTransport = yield this.ledgerService.getLedgerTransport(account);
-            return {
-                neonJsAccount,
-                signingCallback: this.ledgerService.getSigningCallback(ledgerTransport, account),
-            };
-        }
-        return {
-            neonJsAccount,
-            signingCallback: neon_js_1.api.signWithPrivateKey(neonJsAccount.privateKey),
-        };
-    });
-}, _BSNeoLegacy_setTokens = function _BSNeoLegacy_setTokens(network) {
-    const tokens = BSNeoLegacyHelper_1.BSNeoLegacyHelper.getTokens(network);
-    this.nativeTokens = BSNeoLegacyConstants_1.BSNeoLegacyConstants.NATIVE_ASSETS;
-    this.tokens = tokens;
-    this.feeToken = tokens.find(token => token.symbol === 'GAS');
-    this.burnToken = tokens.find(token => token.symbol === 'NEO');
-    this.claimToken = tokens.find(token => token.symbol === 'GAS');
-}, _BSNeoLegacy_hasTransactionMoreThanMaxSize = function _BSNeoLegacy_hasTransactionMoreThanMaxSize(config) {
+_BSNeoLegacy_instances = new WeakSet(), _BSNeoLegacy_hasTransactionMoreThanMaxSize = function _BSNeoLegacy_hasTransactionMoreThanMaxSize(config) {
     if (!config.fees || config.fees < BSNeoLegacyConstants_1.BSNeoLegacyConstants.FEE_APPLIED_TO_PLAYABLE_TRANSACTION) {
         const serializedTransaction = config.tx.serialize(true);
         const transactionSize = serializedTransaction.length / 2;
@@ -295,47 +251,40 @@ _BSNeoLegacy_instances = new WeakSet(), _BSNeoLegacy_generateSigningCallback = f
         gasIntent.value = gasIntent.value.sub(BSNeoLegacyConstants_1.BSNeoLegacyConstants.FEE_APPLIED_TO_PLAYABLE_TRANSACTION);
     }
     return config;
-}, _BSNeoLegacy_signTransfer = function _BSNeoLegacy_signTransfer(config, nep5ScriptBuilder) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!nep5ScriptBuilder || nep5ScriptBuilder.isEmpty()) {
-            config = yield neon_js_1.api.createContractTx(config);
-        }
-        else {
-            config.script = nep5ScriptBuilder.str;
-            config = yield neon_js_1.api.createInvocationTx(config);
-        }
-        config = yield neon_js_1.api.modifyTransactionForEmptyTransaction(config);
-        config = yield neon_js_1.api.addAttributeIfExecutingAsSmartContract(config);
-        config = yield neon_js_1.api.signTx(config);
-        config = yield neon_js_1.api.addSignatureIfExecutingAsSmartContract(config);
-        return config;
-    });
-}, _BSNeoLegacy_sendTransfer = function _BSNeoLegacy_sendTransfer(config, nep5ScriptBuilder) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const sharedConfig = yield neon_js_1.api.fillBalance(config);
-        let signedConfig = yield __classPrivateFieldGet(this, _BSNeoLegacy_instances, "m", _BSNeoLegacy_signTransfer).call(this, Object.assign({}, sharedConfig), nep5ScriptBuilder);
-        if (__classPrivateFieldGet(this, _BSNeoLegacy_instances, "m", _BSNeoLegacy_hasTransactionMoreThanMaxSize).call(this, signedConfig)) {
-            signedConfig = yield __classPrivateFieldGet(this, _BSNeoLegacy_instances, "m", _BSNeoLegacy_signTransfer).call(this, __classPrivateFieldGet(this, _BSNeoLegacy_instances, "m", _BSNeoLegacy_getRequiredTransactionFeeConfig).call(this, sharedConfig), nep5ScriptBuilder);
-        }
-        signedConfig = yield neon_js_1.api.sendTx(signedConfig);
-        return signedConfig.response.txid;
-    });
 }, _BSNeoLegacy_signClaim = function _BSNeoLegacy_signClaim(config) {
     return __awaiter(this, void 0, void 0, function* () {
-        config = yield neon_js_1.api.createClaimTx(config);
-        config = yield neon_js_1.api.addAttributeIfExecutingAsSmartContract(config);
-        config = yield neon_js_1.api.signTx(config);
-        config = yield neon_js_1.api.addSignatureIfExecutingAsSmartContract(config);
+        const { api } = BSNeoLegacyNeonJsSingletonHelper_1.BSNeoLegacyNeonJsSingletonHelper.getInstance();
+        config = yield api.createClaimTx(config);
+        config = yield api.addAttributeIfExecutingAsSmartContract(config);
+        config = yield api.signTx(config);
+        config = yield api.addSignatureIfExecutingAsSmartContract(config);
         return config;
     });
 }, _BSNeoLegacy_sendClaim = function _BSNeoLegacy_sendClaim(config) {
     return __awaiter(this, void 0, void 0, function* () {
-        const sharedConfig = yield neon_js_1.api.fillClaims(config);
+        const { api } = BSNeoLegacyNeonJsSingletonHelper_1.BSNeoLegacyNeonJsSingletonHelper.getInstance();
+        const sharedConfig = yield api.fillClaims(config);
         let signedConfig = yield __classPrivateFieldGet(this, _BSNeoLegacy_instances, "m", _BSNeoLegacy_signClaim).call(this, Object.assign({}, sharedConfig));
         if (__classPrivateFieldGet(this, _BSNeoLegacy_instances, "m", _BSNeoLegacy_hasTransactionMoreThanMaxSize).call(this, signedConfig)) {
             signedConfig = yield __classPrivateFieldGet(this, _BSNeoLegacy_instances, "m", _BSNeoLegacy_signClaim).call(this, __classPrivateFieldGet(this, _BSNeoLegacy_instances, "m", _BSNeoLegacy_getRequiredTransactionFeeConfig).call(this, sharedConfig));
         }
-        signedConfig = yield neon_js_1.api.sendTx(signedConfig);
+        signedConfig = yield api.sendTx(signedConfig);
         return signedConfig.response.txid;
     });
+}, _BSNeoLegacy_signTransfer = function _BSNeoLegacy_signTransfer(config, nep5ScriptBuilder) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { api } = BSNeoLegacyNeonJsSingletonHelper_1.BSNeoLegacyNeonJsSingletonHelper.getInstance();
+        if (!nep5ScriptBuilder || nep5ScriptBuilder.isEmpty()) {
+            config = yield api.createContractTx(config);
+        }
+        else {
+            config.script = nep5ScriptBuilder.str;
+            config = yield api.createInvocationTx(config);
+        }
+        config = yield api.modifyTransactionForEmptyTransaction(config);
+        config = yield api.addAttributeIfExecutingAsSmartContract(config);
+        config = yield api.signTx(config);
+        config = yield api.addSignatureIfExecutingAsSmartContract(config);
+        return config;
+    });
 };

package/dist/constants/BSNeoLegacyConstants.d.ts

@@ -1,42 +1,21 @@
-import { Network, NetworkId, Token } from '@cityofzion/blockchain-service';
-export type BSNeoLegacyNetworkId = NetworkId<'mainnet' | 'testnet'>;
+import { TBSNetwork, TBSToken } from '@cityofzion/blockchain-service';
+import { TBSNeoLegacyNetworkId } from '../types';
 export declare class BSNeoLegacyConstants {
-    #private;
-    static EXTRA_TOKENS_BY_NETWORK_ID: Partial<Record<BSNeoLegacyNetworkId, Token[]>>;
-    static NATIVE_ASSETS: {
-        symbol: string;
-        name: string;
-        hash: string;
-        decimals: number;
-    }[];
-    static GAS_ASSET: {
-        symbol: string;
-        name: string;
-        hash: string;
-        decimals: number;
-    };
-    static NEO_ASSET: {
-        symbol: string;
-        name: string;
-        hash: string;
-        decimals: number;
-    };
-    static RPC_LIST_BY_NETWORK_ID: Record<BSNeoLegacyNetworkId, string[]>;
-    static LEGACY_NETWORK_BY_NETWORK_ID: Record<BSNeoLegacyNetworkId, string>;
-    static MAINNET_NETWORK_IDS: BSNeoLegacyNetworkId[];
-    static TESTNET_NETWORK_IDS: BSNeoLegacyNetworkId[];
-    static ALL_NETWORK_IDS: BSNeoLegacyNetworkId[];
-    static MAINNET_NETWORKS: Network<BSNeoLegacyNetworkId>[];
-    static TESTNET_NETWORKS: Network<BSNeoLegacyNetworkId>[];
-    static ALL_NETWORKS: Network<BSNeoLegacyNetworkId>[];
-    static DEFAULT_BIP44_DERIVATION_PATH: string;
-    static DEFAULT_NETWORK: Network<BSNeoLegacyNetworkId>;
+    static readonly GAS_ASSET: TBSToken;
+    static readonly NEO_ASSET: TBSToken;
+    static readonly NATIVE_ASSETS: TBSToken[];
+    static readonly RPC_LIST_BY_NETWORK_ID: Record<TBSNeoLegacyNetworkId, string[]>;
+    static readonly LEGACY_NETWORK_BY_NETWORK_ID: Record<TBSNeoLegacyNetworkId, string>;
+    static readonly MAINNET_NETWORK: TBSNetwork<TBSNeoLegacyNetworkId>;
+    static readonly TESTNET_NETWORK: TBSNetwork<TBSNeoLegacyNetworkId>;
+    static readonly ALL_NETWORKS: TBSNetwork<TBSNeoLegacyNetworkId>[];
+    static readonly DEFAULT_BIP44_DERIVATION_PATH = "m/44'/888'/0'/0/?";
     static readonly MIGRATION_COZ_LEGACY_ADDRESS = "AaT27thuyPaqERPwERhk7QhfKrbj4xoyAV";
     static readonly MIGRATION_COZ_FEE = 0.01;
     static readonly MIGRATION_NEP_17_TRANSFER_FEE = 0.0112143;
     static readonly MIGRATION_MIN_GAS = 0.1;
     static readonly MIGRATION_MIN_NEO = 2;
     static readonly MIGRATION_COZ_NEO3_ADDRESS = "NLMsicDapULKFDmAzTsbhwrZjYZ83j53Ty";
-    static MAX_TRANSACTION_SIZE_WITHOUT_FEE: number;
-    static FEE_APPLIED_TO_PLAYABLE_TRANSACTION: number;
+    static readonly MAX_TRANSACTION_SIZE_WITHOUT_FEE = 1024;
+    static readonly FEE_APPLIED_TO_PLAYABLE_TRANSACTION = 0.05;
 }