@cityofzion/bs-neo3 1.2.0 → 1.3.0

package/dist/BSNeo3.d.ts

@@ -1,7 +1,7 @@
-import { BlockchainDataService, BlockchainService, BSClaimable, Account, ExchangeDataService, BDSClaimable, Token, BSWithNameService, Network, TransferParam, BSCalculableFee, NftDataService, BSWithNft, AccountWithDerivationPath, BSWithExplorerService, ExplorerService, BSWithLedger } from '@cityofzion/blockchain-service';
+import { Account, AccountWithDerivationPath, BDSClaimable, BlockchainDataService, BlockchainService, BSCalculableFee, BSClaimable, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft, ExchangeDataService, ExplorerService, Network, NftDataService, Token, TransferParam } from '@cityofzion/blockchain-service';
 import Transport from '@ledgerhq/hw-transport';
-import { BSNeo3NetworkId } from './BSNeo3Helper';
-import { NeonDappKitLedgerServiceNeo3 } from './NeonDappKitLedgerServiceNeo3';
+import { BSNeo3NetworkId } from './helpers/BSNeo3Helper';
+import { NeonDappKitLedgerServiceNeo3 } from './services/ledger/NeonDappKitLedgerServiceNeo3';
 export declare class BSNeo3<BSCustomName extends string = string> implements BlockchainService<BSCustomName, BSNeo3NetworkId>, BSClaimable, BSWithNameService, BSCalculableFee, BSWithNft, BSWithExplorerService, BSWithLedger {
     #private;
     blockchainName: BSCustomName;

package/dist/BSNeo3.js

@@ -16,15 +16,15 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _BSNeo3_instances, _BSNeo3_setTokens, _BSNeo3_buildTransferInvocation;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSNeo3 = void 0;
-const neon_js_1 = require("@cityofzion/neon-js");
-const neon_dappkit_1 = require("@cityofzion/neon-dappkit");
 const bs_asteroid_sdk_1 = require("@cityofzion/bs-asteroid-sdk");
-const BSNeo3Helper_1 = require("./BSNeo3Helper");
-const NeonDappKitLedgerServiceNeo3_1 = require("./NeonDappKitLedgerServiceNeo3");
-const DoraBDSNeo3_1 = require("./DoraBDSNeo3");
-const FlamingoEDSNeo3_1 = require("./FlamingoEDSNeo3");
-const GhostMarketNDSNeo3_1 = require("./GhostMarketNDSNeo3");
-const DoraESNeo3_1 = require("./DoraESNeo3");
+const neon_dappkit_1 = require("@cityofzion/neon-dappkit");
+const neon_js_1 = require("@cityofzion/neon-js");
+const BSNeo3Helper_1 = require("./helpers/BSNeo3Helper");
+const DoraBDSNeo3_1 = require("./services/blockchain-data/DoraBDSNeo3");
+const FlamingoEDSNeo3_1 = require("./services/exchange-data/FlamingoEDSNeo3");
+const DoraESNeo3_1 = require("./services/explorer/DoraESNeo3");
+const NeonDappKitLedgerServiceNeo3_1 = require("./services/ledger/NeonDappKitLedgerServiceNeo3");
+const GhostMarketNDSNeo3_1 = require("./services/nft-data/GhostMarketNDSNeo3");
 class BSNeo3 {
     constructor(blockchainName, network, getLedgerTransport) {
         _BSNeo3_instances.add(this);
@@ -195,7 +195,7 @@ _BSNeo3_instances = new WeakSet(), _BSNeo3_setTokens = function _BSNeo3_setToken
                         ? neon_js_1.u.BigInteger.fromDecimal(intent.amount, intent.tokenDecimals).toString()
                         : intent.amount,
                 },
-                { type: 'Any', value: '' },
+                { type: 'Any', value: null },
             ],
         };
     });

package/dist/builder/invocation/FlamingoSwapInvocationBuilderNeo3.d.ts

@@ -0,0 +1,7 @@
+import { SwapServiceSwapToReceiveArgs, SwapServiceSwapToUseArgs } from '@cityofzion/blockchain-service';
+import { ContractInvocationMulti } from '@cityofzion/neon-dappkit-types';
+import { BSNeo3NetworkId } from '../../helpers/BSNeo3Helper';
+export declare class FlamingoSwapInvocationBuilderNeo3 {
+    #private;
+    static swapInvocation(data: SwapServiceSwapToReceiveArgs<BSNeo3NetworkId> | SwapServiceSwapToUseArgs<BSNeo3NetworkId>): ContractInvocationMulti;
+}

package/dist/builder/invocation/FlamingoSwapInvocationBuilderNeo3.js

@@ -0,0 +1,95 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _a, _FlamingoSwapInvocationBuilderNeo3_buildSwapTokenToReceiveInvocation, _FlamingoSwapInvocationBuilderNeo3_buildSwapTokenToUseInvocation, _FlamingoSwapInvocationBuilderNeo3_mapRoutePathToArgs, _FlamingoSwapInvocationBuilderNeo3_getAllowedContracts, _FlamingoSwapInvocationBuilderNeo3_buildNEOTransferInvocation;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlamingoSwapInvocationBuilderNeo3 = void 0;
+const neon_core_1 = require("@cityofzion/neon-core");
+const FlamingoSwapConstants_1 = require("../../constants/FlamingoSwapConstants");
+const FlamingoSwapHelper_1 = require("../../helpers/FlamingoSwapHelper");
+const NeonDappKitInvocationBuilderNeo3_1 = require("./NeonDappKitInvocationBuilderNeo3");
+class FlamingoSwapInvocationBuilderNeo3 {
+    static swapInvocation(data) {
+        return data.type === 'swapTokenToReceive'
+            ? __classPrivateFieldGet(this, _a, "m", _FlamingoSwapInvocationBuilderNeo3_buildSwapTokenToReceiveInvocation).call(this, data)
+            : __classPrivateFieldGet(this, _a, "m", _FlamingoSwapInvocationBuilderNeo3_buildSwapTokenToUseInvocation).call(this, data);
+    }
+}
+exports.FlamingoSwapInvocationBuilderNeo3 = FlamingoSwapInvocationBuilderNeo3;
+_a = FlamingoSwapInvocationBuilderNeo3, _FlamingoSwapInvocationBuilderNeo3_buildSwapTokenToReceiveInvocation = function _FlamingoSwapInvocationBuilderNeo3_buildSwapTokenToReceiveInvocation({ address, amountToReceive, deadline, maximumSelling, network, routePath, }) {
+    const [tokenToUse] = routePath;
+    const tokenToReceive = routePath[routePath.length - 1];
+    const scriptHashes = FlamingoSwapHelper_1.FlamingoSwapHelper.getFlamingoSwapScriptHashes(network);
+    const tokenToReceiveOverrode = FlamingoSwapHelper_1.FlamingoSwapHelper.overrideToken(network, tokenToReceive);
+    const invocations = [];
+    const allowedContracts = __classPrivateFieldGet(this, _a, "m", _FlamingoSwapInvocationBuilderNeo3_getAllowedContracts).call(this, scriptHashes, routePath);
+    const amountToReceiveFormatted = FlamingoSwapHelper_1.FlamingoSwapHelper.formatAmount(amountToReceive, tokenToReceiveOverrode.decimals);
+    const maximumSellingFormatted = FlamingoSwapHelper_1.FlamingoSwapHelper.formatAmount(maximumSelling, tokenToUse.decimals);
+    const swapInvocation = NeonDappKitInvocationBuilderNeo3_1.NeonDappKitInvocationBuilderNeo3.swapTokenOutForTokenInContractInvocation({
+        routerScriptHash: scriptHashes.flamingoSwapRouter,
+        senderAddress: address,
+        amountToReceive: amountToReceiveFormatted,
+        maximumSelling: maximumSellingFormatted,
+        deadline,
+        args: __classPrivateFieldGet(this, _a, "m", _FlamingoSwapInvocationBuilderNeo3_mapRoutePathToArgs).call(this, routePath),
+    });
+    invocations.push(swapInvocation);
+    if (FlamingoSwapHelper_1.FlamingoSwapHelper.isNeoToken(network, tokenToReceive)) {
+        const amountToReceiveTransfer = neon_core_1.u.BigInteger.fromNumber(Number(amountToReceiveFormatted) * FlamingoSwapConstants_1.FlamingoSwapConstants.GAS_PER_NEO).toString();
+        const neoTransferInvocation = __classPrivateFieldGet(this, _a, "m", _FlamingoSwapInvocationBuilderNeo3_buildNEOTransferInvocation).call(this, address, amountToReceiveTransfer, network);
+        invocations.push(neoTransferInvocation);
+    }
+    return {
+        invocations,
+        signers: [{ scopes: neon_core_1.tx.WitnessScope.CustomContracts, allowedContracts }],
+    };
+}, _FlamingoSwapInvocationBuilderNeo3_buildSwapTokenToUseInvocation = function _FlamingoSwapInvocationBuilderNeo3_buildSwapTokenToUseInvocation({ address, amountToUse, deadline, minimumReceived, network, routePath, }) {
+    const [tokenToUse] = routePath;
+    const tokenToReceive = routePath[routePath.length - 1];
+    const scriptHashes = FlamingoSwapHelper_1.FlamingoSwapHelper.getFlamingoSwapScriptHashes(network);
+    const invocations = [];
+    const allowedContracts = __classPrivateFieldGet(this, _a, "m", _FlamingoSwapInvocationBuilderNeo3_getAllowedContracts).call(this, scriptHashes, routePath);
+    if (FlamingoSwapHelper_1.FlamingoSwapHelper.isNeoToken(network, tokenToUse)) {
+        const neoTransferInvocation = __classPrivateFieldGet(this, _a, "m", _FlamingoSwapInvocationBuilderNeo3_buildNEOTransferInvocation).call(this, address, amountToUse, network);
+        invocations.push(neoTransferInvocation);
+    }
+    const amountToUseFormatted = FlamingoSwapHelper_1.FlamingoSwapHelper.formatAmount(amountToUse, tokenToUse.decimals);
+    const minimumReceivedFormatted = FlamingoSwapHelper_1.FlamingoSwapHelper.formatAmount(minimumReceived, tokenToReceive.decimals);
+    const swapInvocation = NeonDappKitInvocationBuilderNeo3_1.NeonDappKitInvocationBuilderNeo3.swapTokenInForTokenOutContractInvocation({
+        routerScriptHash: scriptHashes.flamingoSwapRouter,
+        amountToUse: amountToUseFormatted,
+        minimumReceived: minimumReceivedFormatted,
+        senderAddress: address,
+        deadline,
+        args: __classPrivateFieldGet(this, _a, "m", _FlamingoSwapInvocationBuilderNeo3_mapRoutePathToArgs).call(this, routePath),
+    });
+    invocations.push(swapInvocation);
+    return {
+        invocations,
+        signers: [{ scopes: neon_core_1.tx.WitnessScope.CustomContracts, allowedContracts }],
+    };
+}, _FlamingoSwapInvocationBuilderNeo3_mapRoutePathToArgs = function _FlamingoSwapInvocationBuilderNeo3_mapRoutePathToArgs(routePath) {
+    return routePath.map(token => ({
+        type: 'Hash160',
+        value: token.hash,
+    }));
+}, _FlamingoSwapInvocationBuilderNeo3_getAllowedContracts = function _FlamingoSwapInvocationBuilderNeo3_getAllowedContracts(scriptHashes, routePath) {
+    return [
+        scriptHashes.flamingoSwapRouter,
+        scriptHashes.flamingoFactory,
+        scriptHashes.flamingoPairWhiteList,
+        ...routePath.map(token => token.hash),
+    ];
+}, _FlamingoSwapInvocationBuilderNeo3_buildNEOTransferInvocation = function _FlamingoSwapInvocationBuilderNeo3_buildNEOTransferInvocation(address, amount, network) {
+    const bNEO = FlamingoSwapHelper_1.FlamingoSwapHelper.getFlamingoSwapToken(network, 'bNEO');
+    const GAS = FlamingoSwapHelper_1.FlamingoSwapHelper.getFlamingoSwapToken(network, 'GAS');
+    return NeonDappKitInvocationBuilderNeo3_1.NeonDappKitInvocationBuilderNeo3.transferContractInvocation({
+        senderAddress: address,
+        amount,
+        tokenHash: bNEO.hash,
+        contractHash: GAS.hash,
+    });
+};

package/dist/builder/invocation/NeonDappKitInvocationBuilderNeo3.d.ts

@@ -0,0 +1,34 @@
+import { Arg, ContractInvocation } from '@cityofzion/neon-dappkit-types';
+export type GetReservesParams = {
+    routerScriptHash: string;
+    tokenToReceiveHash: string;
+    tokenToUseHash: string;
+};
+export type TokenOutForTokenInParams = {
+    routerScriptHash: string;
+    senderAddress: string;
+    amountToReceive: string;
+    maximumSelling: string;
+    deadline: string;
+    args: Arg[];
+};
+export type TokenInForTokenOutParams = {
+    routerScriptHash: string;
+    senderAddress: string;
+    amountToUse: string;
+    minimumReceived: string;
+    deadline: string;
+    args: Arg[];
+};
+export type TransferArgs = {
+    contractHash: string;
+    senderAddress: string;
+    tokenHash: string;
+    amount: string;
+};
+export declare class NeonDappKitInvocationBuilderNeo3 {
+    static getReservesContractInvocation({ routerScriptHash, tokenToReceiveHash, tokenToUseHash, }: GetReservesParams): ContractInvocation;
+    static swapTokenOutForTokenInContractInvocation({ routerScriptHash, senderAddress, amountToReceive, maximumSelling, deadline, args, }: TokenOutForTokenInParams): ContractInvocation;
+    static swapTokenInForTokenOutContractInvocation({ routerScriptHash, senderAddress, amountToUse, minimumReceived, deadline, args, }: TokenInForTokenOutParams): ContractInvocation;
+    static transferContractInvocation({ contractHash, senderAddress, tokenHash, amount, }: TransferArgs): ContractInvocation;
+}

package/dist/builder/invocation/NeonDappKitInvocationBuilderNeo3.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NeonDappKitInvocationBuilderNeo3 = void 0;
+class NeonDappKitInvocationBuilderNeo3 {
+    static getReservesContractInvocation({ routerScriptHash, tokenToReceiveHash, tokenToUseHash, }) {
+        return {
+            scriptHash: routerScriptHash,
+            operation: 'getReserves',
+            args: [
+                {
+                    type: 'Hash160',
+                    value: tokenToReceiveHash,
+                },
+                {
+                    type: 'Hash160',
+                    value: tokenToUseHash,
+                },
+            ],
+        };
+    }
+    static swapTokenOutForTokenInContractInvocation({ routerScriptHash, senderAddress, amountToReceive, maximumSelling, deadline, args, }) {
+        return {
+            scriptHash: routerScriptHash,
+            operation: 'swapTokenOutForTokenIn',
+            args: [
+                {
+                    type: 'Hash160',
+                    value: senderAddress,
+                },
+                {
+                    type: 'Integer',
+                    value: amountToReceive,
+                },
+                {
+                    type: 'Integer',
+                    value: maximumSelling,
+                },
+                {
+                    type: 'Array',
+                    value: args,
+                },
+                {
+                    type: 'Integer',
+                    value: deadline,
+                },
+            ],
+        };
+    }
+    static swapTokenInForTokenOutContractInvocation({ routerScriptHash, senderAddress, amountToUse, minimumReceived, deadline, args, }) {
+        return {
+            scriptHash: routerScriptHash,
+            operation: 'swapTokenInForTokenOut',
+            args: [
+                {
+                    type: 'Hash160',
+                    value: senderAddress,
+                },
+                {
+                    type: 'Integer',
+                    value: amountToUse,
+                },
+                {
+                    type: 'Integer',
+                    value: minimumReceived,
+                },
+                {
+                    type: 'Array',
+                    value: args,
+                },
+                {
+                    type: 'Integer',
+                    value: deadline,
+                },
+            ],
+        };
+    }
+    static transferContractInvocation({ contractHash, senderAddress, tokenHash, amount, }) {
+        return {
+            scriptHash: contractHash,
+            operation: 'transfer',
+            args: [
+                {
+                    type: 'Hash160',
+                    value: senderAddress,
+                },
+                {
+                    type: 'Hash160',
+                    value: tokenHash,
+                },
+                {
+                    type: 'Integer',
+                    value: amount,
+                },
+                {
+                    type: 'Any',
+                    value: null,
+                },
+            ],
+        };
+    }
+}
+exports.NeonDappKitInvocationBuilderNeo3 = NeonDappKitInvocationBuilderNeo3;

package/dist/constants/FlamingoSwapConstants.d.ts

@@ -0,0 +1,36 @@
+import { Token } from '@cityofzion/blockchain-service';
+import BigNumber from 'bignumber.js';
+import { BSNeo3NetworkId } from '../helpers/BSNeo3Helper';
+export type FlamingoSwapScriptHashes = {
+    flamingoSwapRouter: string;
+    flamingoPairWhiteList: string;
+    flamingoFactory: string;
+};
+export type FlamingoSwapPoolInfo = {
+    symbol: string;
+    decimals: number;
+    hash: string;
+    tokens: Token[];
+};
+export type FlamingoSwapPools = {
+    [key: string]: FlamingoSwapPoolInfo;
+};
+export type FlamingoSwapTokens = {
+    [key: string]: Token;
+};
+export declare const BLOCKCHAIN_WSS_URL = "wss://rpc10.n3.nspcc.ru:10331/ws";
+export declare class FlamingoSwapConstants {
+    static readonly BN_0: BigNumber;
+    static readonly BN_1: BigNumber;
+    static readonly BN_997: BigNumber;
+    static readonly BN_1000: BigNumber;
+    static readonly FEE_RATE: BigNumber;
+    static readonly GAS_PER_NEO = 0.001;
+    static readonly TESTNET_FLAMINGO_SWAP_TOKENS: FlamingoSwapTokens;
+    static readonly MAINNET_FLAMINGO_SWAP_TOKENS: FlamingoSwapTokens;
+    static readonly FLAMINGO_SWAP_TOKENS: Record<BSNeo3NetworkId, FlamingoSwapTokens>;
+    static readonly FLAMINGO_SWAP_SCRIPT_HASHES: Partial<Record<BSNeo3NetworkId, FlamingoSwapScriptHashes>>;
+    static readonly TESTNET_FLAMINGO_SWAP_POOLS: FlamingoSwapPools;
+    static readonly MAINNET_FLAMINGO_SWAP_POOLS: FlamingoSwapPools;
+    static readonly FLAMINGO_SWAP_POOLS: Record<BSNeo3NetworkId, FlamingoSwapPools>;
+}