@tatumio/flow 2.0.1-alpha.351 → 2.0.1-alpha.353

package/src/lib/services/flow.tx.js

@@ -1,33 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.flowTxService = exports.FLOW_MAINNET_ADDRESSES = exports.FLOW_TESTNET_ADDRESSES = void 0;
+exports.flowTxService = void 0;
 const tslib_1 = require("tslib");
 const elliptic = tslib_1.__importStar(require("elliptic"));
 const fcl = tslib_1.__importStar(require("@onflow/fcl"));
 const types = tslib_1.__importStar(require("@onflow/types"));
 const util_encode_key_1 = require("@onflow/util-encode-key");
 const sha3_1 = tslib_1.__importDefault(require("sha3"));
-const shared_core_1 = require("@tatumio/shared-core");
 const flow_tx_templates_1 = require("./flow.tx.templates");
 const flow_sdk_wallet_1 = require("./flow.sdk.wallet");
-const flow_blockchain_1 = require("./flow.blockchain");
 const flow_sdk_errors_1 = require("../flow.sdk.errors");
 const shared_abstract_sdk_1 = require("@tatumio/shared-abstract-sdk");
-exports.FLOW_TESTNET_ADDRESSES = {
-    FlowToken: '0x7e60df042a9c0868',
-    FungibleToken: '0x9a0766d93b6608b7',
-    FUSD: '0xe223d8a629e49c68',
-    TatumMultiNFT: '0x87fe4ebd0cddde06',
-};
-exports.FLOW_MAINNET_ADDRESSES = {
-    FlowToken: '0x1654653399040a61',
-    FungibleToken: '0xf233dcee88fe0abe',
-    FUSD: '0x3c5959b568896393',
-    TatumMultiNFT: '0x354e6721564ccd2c',
-};
-const flowTxService = (args) => {
+const flow_constants_1 = require("../flow.constants");
+const shared_core_1 = require("@tatumio/shared-core");
+const api_client_1 = require("@tatumio/api-client");
+const bignumber_js_1 = tslib_1.__importDefault(require("bignumber.js"));
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const flowTxService = (provider, apiCalls) => {
     const flowSdkWallet = (0, flow_sdk_wallet_1.flowWallet)();
-    const flowSdkBlockchain = (0, flow_blockchain_1.flowBlockchain)(args);
     const txTemplates = (0, flow_tx_templates_1.flowTxTemplates)();
     const sign = (pk, msg) => {
         const keyPair = new elliptic.ec('secp256k1').keyFromPrivate(pk);
@@ -38,34 +28,261 @@ const flowTxService = (args) => {
     };
     const getSigner = (pk, address, keyId = 0) => {
         return {
-            signer: (account) => {
-                return Object.assign(Object.assign({}, account), { tempId: `${address}-${keyId}`, addr: fcl.sansPrefix(address), keyId: Number(keyId), signingFunction: (data) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            signer: (account) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                return Object.assign(Object.assign({}, account), { tempId: `${address}-${keyId}`, addr: fcl.sansPrefix(address), keyId: Number(keyId), signingFunction: (data) => {
                         return {
                             addr: fcl.withPrefix(address),
                             keyId: Number(keyId),
                             signature: sign(pk, Buffer.from(data.message, 'hex')),
                         };
-                    }) });
-            },
+                    } });
+            }),
         };
     };
     const getApiSigner = (isPayer) => {
-        const keyHash = Date.now();
+        const hash = Date.now();
+        const keyHash = `FLOW_PROPOSAL_KEY_${hash}`;
         const signer = (account) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-            const { address, keyId } = yield flowSdkBlockchain.getSignKey(isPayer);
+            const { address, keyId } = yield getProposalKeyOrFetch(keyHash, isPayer);
             if (!isPayer) {
-                process.env[`FLOW_PROPOSAL_KEY_${keyHash}`] = `${keyId}`;
+                storeProposalKey(keyHash, address, keyId);
             }
             return Object.assign(Object.assign({}, account), { tempId: `${address}-${keyId}`, addr: fcl.sansPrefix(address), keyId, signingFunction: (data) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                     return {
                         addr: fcl.withPrefix(address),
                         keyId: Number(keyId),
-                        signature: (yield flowSdkBlockchain.signWithKey(data.message, isPayer)).signature,
+                        signature: (yield apiCalls.signWithKey(data.message, isPayer)).signature,
                     };
                 }) });
         });
-        return { signer, keyHash: `FLOW_PROPOSAL_KEY_${keyHash}` };
+        return { signer, keyHash: keyHash };
     };
+    const sendCreateAccountFromPublicKey = (body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const code = txTemplates.prepareCreateAccountWithFUSDFromPublicKeyTxTemplate(provider.isTestnet());
+        const encodedPublicKey = (0, util_encode_key_1.encodeKey)(body.publicKey, util_encode_key_1.ECDSA_secp256k1, util_encode_key_1.SHA3_256, 1000);
+        const txArgs = [{ type: 'String', value: encodedPublicKey }];
+        const pk = yield getPrivateKey(body);
+        if (!pk)
+            throw new flow_sdk_errors_1.FlowSdkError({ code: shared_abstract_sdk_1.SdkErrorCode.FLOW_MISSING_PRIVATE_KEY });
+        const auth = getSigner(pk, body.account).signer;
+        const { signer: proposalSigner, keyHash } = proposer ? proposer(false) : getApiSigner(false);
+        const { signer: payerSigner } = payer ? payer(true) : getApiSigner(true);
+        const result = yield _sendTransaction({
+            code,
+            txArgs,
+            proposer: proposalSigner,
+            authorizations: [auth],
+            payer: payerSigner,
+            keyHash,
+        });
+        return {
+            txId: result.id,
+            address: (_a = result.events.find((e) => e.type === 'flow.AccountCreated')) === null || _a === void 0 ? void 0 : _a.data.address,
+        };
+    });
+    const sendAddPublicKeyToAccount = (body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        const code = txTemplates.prepareAddPublicKeyToAccountTxTemplate();
+        const encodedPublicKey = (0, util_encode_key_1.encodeKey)(body.publicKey, util_encode_key_1.ECDSA_secp256k1, util_encode_key_1.SHA3_256, body.weight || 0);
+        const txArgs = [{ type: 'String', value: encodedPublicKey }];
+        const pk = yield getPrivateKey(body);
+        if (!pk)
+            throw new flow_sdk_errors_1.FlowSdkError({ code: shared_abstract_sdk_1.SdkErrorCode.FLOW_MISSING_PRIVATE_KEY });
+        const auth = getSigner(pk, body.account).signer;
+        const { signer: proposalSigner, keyHash } = proposer ? proposer(false) : getApiSigner(false);
+        const { signer: payerSigner } = payer ? payer(true) : getApiSigner(true);
+        const result = yield _sendTransaction({
+            code,
+            txArgs,
+            proposer: proposalSigner,
+            authorizations: [auth],
+            keyHash,
+            payer: payerSigner,
+        });
+        return { txId: result.id, address: result.events[0].data.address };
+    });
+    const getNftMetadata = (account, id, contractAddress) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        const code = txTemplates.metadataNftTokenScript(provider.isTestnet());
+        const scriptArgs = [
+            { type: 'Address', value: account },
+            { type: 'UInt64', value: id },
+            { type: 'String', value: contractAddress },
+        ];
+        return sendScript(code, scriptArgs);
+    });
+    const getNftTokenByAddress = (account, tokenType) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        const code = txTemplates.tokenByAddressNftTokenScript(provider.isTestnet());
+        const scriptArgs = [
+            { type: 'Address', value: account },
+            { type: 'String', value: tokenType },
+        ];
+        return sendScript(code, scriptArgs);
+    });
+    const sendNftMintToken = (body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        var _b;
+        const bodyWithChain = Object.assign(Object.assign({}, body), { chain: shared_core_1.Blockchain.FLOW });
+        const code = txTemplates.mintNftTokenTxTemplate(provider.isTestnet());
+        const { url, contractAddress: tokenType, to, account } = bodyWithChain;
+        const txArgs = [
+            { type: 'Address', value: to },
+            { type: 'String', value: url },
+            { type: 'String', value: tokenType },
+        ];
+        const pk = yield getPrivateKey(bodyWithChain);
+        if (!pk)
+            throw new flow_sdk_errors_1.FlowSdkError({ code: shared_abstract_sdk_1.SdkErrorCode.FLOW_MISSING_PRIVATE_KEY });
+        const auth = getSigner(pk, account).signer;
+        const { signer: proposalSigner, keyHash } = proposer ? proposer(false) : getApiSigner(false);
+        const { signer: payerSigner } = payer ? payer(true) : getApiSigner(true);
+        const result = yield _sendTransaction({
+            code,
+            txArgs,
+            proposer: proposalSigner,
+            authorizations: [auth],
+            keyHash,
+            payer: payerSigner,
+        });
+        return {
+            txId: result.id,
+            tokenId: `${(_b = result.events.find((e) => e.type.includes('TatumMultiNFT.Minted'))) === null || _b === void 0 ? void 0 : _b.data.id}`,
+        };
+    });
+    const sendNftMintMultipleToken = (body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        const bodyWithChain = Object.assign(Object.assign({}, body), { chain: shared_core_1.Blockchain.FLOW });
+        const code = txTemplates.mintMultipleNftTokenTxTemplate(provider.isTestnet());
+        const { url, contractAddress: tokenType, to, account } = bodyWithChain;
+        const txArgs = [
+            { type: 'Array', subType: 'Address', value: to },
+            {
+                type: 'Array',
+                subType: 'String',
+                value: url,
+            },
+            { type: 'String', value: tokenType },
+        ];
+        const pk = yield getPrivateKey(bodyWithChain);
+        if (!pk)
+            throw new flow_sdk_errors_1.FlowSdkError({ code: shared_abstract_sdk_1.SdkErrorCode.FLOW_MISSING_PRIVATE_KEY });
+        const auth = getSigner(pk, account).signer;
+        const { signer: proposalSigner, keyHash } = proposer ? proposer(false) : getApiSigner(false);
+        const { signer: payerSigner } = payer ? payer(true) : getApiSigner(true);
+        const result = yield _sendTransaction({
+            code,
+            txArgs,
+            proposer: proposalSigner,
+            authorizations: [auth],
+            payer: payerSigner,
+            keyHash,
+        });
+        return {
+            txId: result.id,
+            tokenId: result.events
+                .filter((e) => e.type.includes('TatumMultiNFT.Minted'))
+                .map((e) => e.data.id),
+        };
+    });
+    const sendNftTransferToken = (body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        const bodyWithChain = Object.assign(Object.assign({}, body), { chain: shared_core_1.Blockchain.FLOW });
+        const code = txTemplates.transferNftTokenTxTemplate(provider.isTestnet());
+        const { tokenId, to, account } = bodyWithChain;
+        const txArgs = [
+            { type: 'Address', value: to },
+            { type: 'UInt64', value: tokenId },
+        ];
+        const pk = yield getPrivateKey(bodyWithChain);
+        if (!pk)
+            throw new flow_sdk_errors_1.FlowSdkError({ code: shared_abstract_sdk_1.SdkErrorCode.FLOW_MISSING_PRIVATE_KEY });
+        const auth = getSigner(pk, account).signer;
+        const { signer: proposalSigner, keyHash } = proposer ? proposer(false) : getApiSigner(false);
+        const { signer: payerSigner } = payer ? payer(true) : getApiSigner(true);
+        const result = yield _sendTransaction({
+            code,
+            txArgs,
+            proposer: proposalSigner,
+            authorizations: [auth],
+            payer: payerSigner,
+            keyHash,
+        });
+        return { txId: result.id };
+    });
+    const sendNftBurnToken = (body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        const bodyWithChain = Object.assign(Object.assign({}, body), { chain: shared_core_1.Blockchain.FLOW });
+        const code = txTemplates.burnNftTokenTxTemplate(provider.isTestnet());
+        const { tokenId, contractAddress: tokenType, account } = bodyWithChain;
+        const txArgs = [
+            { type: 'UInt64', value: tokenId },
+            { type: 'String', value: tokenType },
+        ];
+        const pk = yield getPrivateKey(bodyWithChain);
+        if (!pk)
+            throw new flow_sdk_errors_1.FlowSdkError({ code: shared_abstract_sdk_1.SdkErrorCode.FLOW_MISSING_PRIVATE_KEY });
+        const auth = getSigner(pk, account).signer;
+        const { signer: proposalSigner, keyHash } = proposer ? proposer(false) : getApiSigner(false);
+        const { signer: payerSigner } = payer ? payer(true) : getApiSigner(true);
+        const result = yield _sendTransaction({
+            code,
+            txArgs,
+            proposer: proposalSigner,
+            authorizations: [auth],
+            payer: payerSigner,
+            keyHash,
+        });
+        return { txId: result.id };
+    });
+    const sendCustomTransaction = (body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        const pk = yield getPrivateKey(body);
+        if (!pk)
+            throw new flow_sdk_errors_1.FlowSdkError({ code: shared_abstract_sdk_1.SdkErrorCode.FLOW_MISSING_PRIVATE_KEY });
+        const auth = getSigner(pk, body.account).signer;
+        const { signer: proposalSigner, keyHash } = proposer ? proposer(false) : getApiSigner(false);
+        const { signer: payerSigner } = payer ? payer(true) : getApiSigner(true);
+        const result = yield _sendTransaction({
+            code: body.transaction,
+            txArgs: body.args,
+            proposer: proposalSigner,
+            authorizations: [auth],
+            keyHash,
+            payer: payerSigner,
+        });
+        return { txId: result.id, events: result.events };
+    });
+    const sendTransaction = (body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        const testnet = provider.isTestnet();
+        let tokenAddress;
+        let tokenName;
+        let tokenStorage;
+        if (body.currency === shared_core_1.Blockchain.FLOW) {
+            tokenAddress = testnet ? flow_constants_1.FLOW_TESTNET_ADDRESSES.FlowToken : flow_constants_1.FLOW_MAINNET_ADDRESSES.FlowToken;
+            tokenName = 'FlowToken';
+            tokenStorage = 'flowToken';
+        }
+        else {
+            tokenAddress = testnet ? flow_constants_1.FLOW_TESTNET_ADDRESSES.FUSD : flow_constants_1.FLOW_MAINNET_ADDRESSES.FUSD;
+            tokenName = 'FUSD';
+            tokenStorage = 'fusd';
+        }
+        const code = txTemplates.prepareTransferTxTemplate(testnet, tokenAddress, tokenName, tokenStorage);
+        const txArgs = [
+            { value: parseFloat(body.amount).toFixed(8), type: 'UFix64' },
+            { value: body.to, type: 'Address' },
+        ];
+        const pk = yield getPrivateKey(body);
+        if (!pk)
+            throw new flow_sdk_errors_1.FlowSdkError({ code: shared_abstract_sdk_1.SdkErrorCode.FLOW_MISSING_PRIVATE_KEY });
+        yield checkBalanceOrThrow(body.account, tokenAddress, tokenName, tokenStorage, body.amount);
+        const auth = getSigner(pk, body.account).signer;
+        const { signer: proposalSigner, keyHash } = proposer ? proposer(false) : getApiSigner(false);
+        const { signer: payerSigner } = payer ? payer(true) : getApiSigner(true);
+        const result = yield _sendTransaction({
+            code,
+            txArgs,
+            proposer: proposalSigner,
+            authorizations: [auth],
+            payer: payerSigner,
+            keyHash,
+        });
+        return { txId: result.id };
+    });
     return {
         sign,
         getSigner,
@@ -73,294 +290,124 @@ const flowTxService = (args) => {
         /**
          * Create account on the FLOW network. It automatically creates 100 0-weight proposal keys, which are managed by Tatum API - index 1-100.
          * Main 1000 weight authorizer key is stored as a first one on index 0.
-         * @param testnet if we use testnet or not
-         * @param publicKey public key to assign to address as authorizer (1000 weight) key
-         * @param signerAddress address of the authorizer creator of the address on the chain
-         * @param signerPrivateKey private key of the authorizer creator of the address on the chain
-         * @param proposer function to obtain proposer key from
-         * @param payer function to obtain payer key from
-         */
-        createAccountFromPublicKey: (testnet, publicKey, signerAddress, signerPrivateKey, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            const code = txTemplates.prepareCreateAccountWithFUSDFromPublicKeyTxTemplate(testnet);
-            const encodedPublicKey = (0, util_encode_key_1.encodeKey)(publicKey, util_encode_key_1.ECDSA_secp256k1, util_encode_key_1.SHA3_256, 1000);
-            const args = [{ type: 'String', value: encodedPublicKey }];
-            const auth = getSigner(signerPrivateKey, signerAddress).signer;
-            const { signer: proposalSigner, keyHash } = proposer ? proposer(false) : getApiSigner(false);
-            const result = yield _sendTransaction(testnet, {
-                code,
-                args,
-                proposer: proposer ? proposer(false) : proposalSigner,
-                authorizations: [auth],
-                payer: payer ? payer(true) : getApiSigner(true).signer,
-                keyHash,
-            });
-            return {
-                txId: result.id,
-                address: (_a = result.events.find((e) => e.type === 'flow.AccountCreated')) === null || _a === void 0 ? void 0 : _a.data.address,
-            };
-        }),
-        /**
-         * Add public key to existing blockchain address with defined weight
-         * @param testnet
-         * @param publicKey key to add
-         * @param signerAddress address of the authorizer key
-         * @param signerPrivateKey key of the authorize key
-         * @param weight defaults to 1000 - weight of the key
-         * @param proposer function to obtain proposer key from
-         * @param payer function to obtain payer key from
-         */
-        addPublicKeyToAccount: (testnet, publicKey, signerAddress, signerPrivateKey, weight = 0, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-            const code = txTemplates.prepareAddPublicKeyToAccountTxTemplate();
-            const encodedPublicKey = (0, util_encode_key_1.encodeKey)(publicKey, util_encode_key_1.ECDSA_secp256k1, util_encode_key_1.SHA3_256, weight);
-            const args = [{ type: 'String', value: encodedPublicKey }];
-            const auth = getSigner(signerPrivateKey, signerAddress).signer;
-            const { signer: proposalSigner, keyHash } = proposer ? proposer(false) : getApiSigner(false);
-            const result = yield _sendTransaction(testnet, {
-                code,
-                args,
-                proposer: proposer ? proposer(false) : proposalSigner,
-                authorizations: [auth],
-                keyHash,
-                payer: payer ? payer(true) : getApiSigner(true).signer,
-            });
-            return { txId: result.id, address: result.events[0].data.address };
-        }),
-        getNftMetadata: (testnet, account, id, contractAddress) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-            const code = txTemplates.metadataNftTokenScript(testnet);
-            const args = [
-                { type: 'Address', value: account },
-                { type: 'UInt64', value: id },
-                { type: 'String', value: contractAddress },
-            ];
-            return sendScript(testnet, code, args);
-        }),
-        getNftTokenByAddress: (testnet, account, tokenType) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-            const code = txTemplates.tokenByAddressNftTokenScript(testnet);
-            const args = [
-                { type: 'Address', value: account },
-                { type: 'String', value: tokenType },
-            ];
-            return sendScript(testnet, code, args);
-        }),
-        /**
-         * Send Flow NFT mint token transaction to the blockchain. This method broadcasts signed transaction to the blockchain.
-         * This operation is irreversible.
-         * @param testnet
-         * @param body content of the transaction to broadcast
-         * @param proposer function to obtain proposer key from
-         * @param payer function to obtain payer key from
-         * @returns txId id of the transaction in the blockchain
-         */
-        sendNftMintToken: (testnet, body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-            var _b;
-            const bodyWithChain = Object.assign(Object.assign({}, body), { chain: shared_core_1.Blockchain.FLOW });
-            const code = txTemplates.mintNftTokenTxTemplate(testnet);
-            const { url, contractAddress: tokenType, to, account } = bodyWithChain;
-            const args = [
-                { type: 'Address', value: to },
-                { type: 'String', value: url },
-                { type: 'String', value: tokenType },
-            ];
-            const pk = yield getPrivateKey(bodyWithChain);
-            if (!pk)
-                throw new flow_sdk_errors_1.FlowSdkError(shared_abstract_sdk_1.SdkErrorCode.FLOW_MISSING_PRIVATE_KEY);
-            const auth = getSigner(pk, account).signer;
-            const { signer: proposalSigner, keyHash } = proposer ? proposer(false) : getApiSigner(false);
-            const result = yield _sendTransaction(testnet, {
-                code,
-                args,
-                proposer: proposer ? proposer(false) : proposalSigner,
-                authorizations: [auth],
-                keyHash,
-                payer: payer ? payer(true) : getApiSigner(true).signer,
-            });
-            return {
-                txId: result.id,
-                tokenId: `${(_b = result.events.find((e) => e.type.includes('TatumMultiNFT.Minted'))) === null || _b === void 0 ? void 0 : _b.data.id}`,
-            };
-        }),
-        /**
-         * Send Flow NFT mint multiple tokens transaction to the blockchain. This method broadcasts signed transaction to the blockchain.
-         * This operation is irreversible.
-         * @param testnet
          * @param body content of the transaction to broadcast
          * @param proposer function to obtain proposer key from
          * @param payer function to obtain payer key from
-         * @returns txId id of the transaction in the blockchain
          */
-        sendNftMintMultipleToken: (testnet, body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-            const bodyWithChain = Object.assign(Object.assign({}, body), { chain: shared_core_1.Blockchain.FLOW });
-            const code = txTemplates.mintMultipleNftTokenTxTemplate(testnet);
-            const { url, contractAddress: tokenType, to, account } = bodyWithChain;
-            const args = [
-                { type: 'Array', subType: 'Address', value: to },
-                {
-                    type: 'Array',
-                    subType: 'String',
-                    value: url,
-                },
-                { type: 'String', value: tokenType },
-            ];
-            const pk = yield getPrivateKey(bodyWithChain);
-            if (!pk)
-                throw new flow_sdk_errors_1.FlowSdkError(shared_abstract_sdk_1.SdkErrorCode.FLOW_MISSING_PRIVATE_KEY);
-            const { signer: proposalSigner, keyHash } = proposer ? proposer(false) : getApiSigner(false);
-            const auth = getSigner(pk, account).signer;
-            const result = yield _sendTransaction(testnet, {
-                code,
-                args,
-                proposer: proposer ? proposer(false) : proposalSigner,
-                authorizations: [auth],
-                payer: payer ? payer(true) : getApiSigner(true).signer,
-                keyHash,
-            });
-            return {
-                txId: result.id,
-                tokenId: result.events
-                    .filter((e) => e.type.includes('TatumMultiNFT.Minted'))
-                    .map((e) => e.data.id),
-            };
+        createAccountFromPublicKey: (body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            if (body.signatureId) {
+                return api_client_1.ApiServices.blockchain.flow.flowCreateAddressFromPubKey(body);
+            }
+            return sendCreateAccountFromPublicKey(body, proposer, payer);
         }),
         /**
-         * Send Flow NFT transfer token transaction to the blockchain. This method broadcasts signed transaction to the blockchain.
-         * This operation is irreversible.
-         * @param testnet
+         * Add public key to existing blockchain address with defined weight
          * @param body content of the transaction to broadcast
          * @param proposer function to obtain proposer key from
          * @param payer function to obtain payer key from
-         * @returns {txId: string, events: any[]} id of the transaction in the blockchain and events this tx produced
          */
-        sendNftTransferToken: (testnet, body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-            const bodyWithChain = Object.assign(Object.assign({}, body), { chain: shared_core_1.Blockchain.FLOW });
-            const code = txTemplates.transferNftTokenTxTemplate(testnet);
-            const { tokenId, to, account } = bodyWithChain;
-            const args = [
-                { type: 'Address', value: to },
-                { type: 'UInt64', value: tokenId },
-            ];
-            const pk = yield getPrivateKey(bodyWithChain);
-            if (!pk)
-                throw new flow_sdk_errors_1.FlowSdkError(shared_abstract_sdk_1.SdkErrorCode.FLOW_MISSING_PRIVATE_KEY);
-            const { signer: proposalSigner, keyHash } = proposer ? proposer(false) : getApiSigner(false);
-            const auth = getSigner(pk, account).signer;
-            const result = yield _sendTransaction(testnet, {
-                code,
-                args,
-                proposer: proposer ? proposer(false) : proposalSigner,
-                authorizations: [auth],
-                payer: payer ? payer(true) : getApiSigner(true).signer,
-                keyHash,
-            });
-            return { txId: result.id };
+        addPublicKeyToAccount: (body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            if (body.signatureId) {
+                return api_client_1.ApiServices.blockchain.flow.flowAddPubKeyToAddress(body);
+            }
+            return sendAddPublicKeyToAccount(body, proposer, payer);
         }),
+        nft: {
+            getNftMetadata,
+            getNftTokenByAddress,
+            /**
+             * Send Flow NFT mint token transaction to the blockchain. This method broadcasts signed transaction to the blockchain.
+             * This operation is irreversible.
+             * @param body content of the transaction to broadcast
+             * @param proposer function to obtain proposer key from
+             * @param payer function to obtain payer key from
+             * @returns txId id of the transaction in the blockchain
+             */
+            sendNftMintToken: (body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                if (body.signatureId) {
+                    return api_client_1.NftErc721OrCompatibleService.nftMintErc721(body);
+                }
+                return sendNftMintToken(body, proposer, payer);
+            }),
+            /**
+             * Send Flow NFT mint multiple tokens transaction to the blockchain. This method broadcasts signed transaction to the blockchain.
+             * This operation is irreversible.
+             * @param body content of the transaction to broadcast
+             * @param proposer function to obtain proposer key from
+             * @param payer function to obtain payer key from
+             * @returns txId id of the transaction in the blockchain
+             */
+            sendNftMintMultipleToken: (body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                if (body.signatureId) {
+                    return api_client_1.NftErc721OrCompatibleService.nftMintMultipleErc721(body);
+                }
+                return sendNftMintMultipleToken(body, proposer, payer);
+            }),
+            /**
+             * Send Flow NFT transfer token transaction to the blockchain. This method broadcasts signed transaction to the blockchain.
+             * This operation is irreversible.
+             * @param body content of the transaction to broadcast
+             * @param proposer function to obtain proposer key from
+             * @param payer function to obtain payer key from
+             * @returns {txId: string, events: any[]} id of the transaction in the blockchain and events this tx produced
+             */
+            sendNftTransferToken: (body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                if (body.signatureId) {
+                    return api_client_1.NftErc721OrCompatibleService.nftTransferErc721(body);
+                }
+                return sendNftTransferToken(body, proposer, payer);
+            }),
+            /**
+             * Send Flow NFT burn token transaction to the blockchain. This method broadcasts signed transaction to the blockchain.
+             * This operation is irreversible.
+             * @param body content of the transaction to broadcast
+             * @param proposer function to obtain proposer key from
+             * @param payer function to obtain payer key from
+             * @returns txId id of the transaction in the blockchain
+             */
+            sendNftBurnToken: (body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                if (body.signatureId) {
+                    return api_client_1.NftErc721OrCompatibleService.nftBurnErc721(body);
+                }
+                return sendNftBurnToken(body, proposer, payer);
+            }),
+        },
         /**
-         * Send Flow NFT burn token transaction to the blockchain. This method broadcasts signed transaction to the blockchain.
-         * This operation is irreversible.
-         * @param testnet
+         * Send FLOW or FUSD from account to account.
          * @param body content of the transaction to broadcast
          * @param proposer function to obtain proposer key from
          * @param payer function to obtain payer key from
          * @returns txId id of the transaction in the blockchain
          */
-        sendNftBurnToken: (testnet, body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-            const bodyWithChain = Object.assign(Object.assign({}, body), { chain: shared_core_1.Blockchain.FLOW });
-            const code = txTemplates.burnNftTokenTxTemplate(testnet);
-            const { tokenId, contractAddress: tokenType, account } = bodyWithChain;
-            const args = [
-                { type: 'UInt64', value: tokenId },
-                { type: 'String', value: tokenType },
-            ];
-            const pk = yield getPrivateKey(bodyWithChain);
-            if (!pk)
-                throw new flow_sdk_errors_1.FlowSdkError(shared_abstract_sdk_1.SdkErrorCode.FLOW_MISSING_PRIVATE_KEY);
-            const { signer: proposalSigner, keyHash } = proposer ? proposer(false) : getApiSigner(false);
-            const auth = getSigner(pk, account).signer;
-            const result = yield _sendTransaction(testnet, {
-                code,
-                args,
-                proposer: proposer ? proposer(false) : proposalSigner,
-                authorizations: [auth],
-                payer: payer ? payer(true) : getApiSigner(true).signer,
-                keyHash,
-            });
-            return { txId: result.id };
+        sendTransaction: (body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            if (body.signatureId) {
+                return api_client_1.ApiServices.blockchain.flow.flowTransferBlockchain(body);
+            }
+            return sendTransaction(body, proposer, payer);
         }),
         /**
          * Send custom transaction to the FLOW network
-         * @param testnet
-         * @param body content of the transaction to broadcast
-         * @param proposer function to obtain proposer key from
-         * @param payer function to obtain payer key from
-         * @returns txId id of the transaction in the blockchain
-         */
-        sendCustomTransaction: (testnet, body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-            const pk = yield getPrivateKey(body);
-            if (!pk)
-                throw new flow_sdk_errors_1.FlowSdkError(shared_abstract_sdk_1.SdkErrorCode.FLOW_MISSING_PRIVATE_KEY);
-            const auth = getSigner(pk, body.account).signer;
-            const { signer: proposalSigner, keyHash } = proposer ? proposer(false) : getApiSigner(false);
-            const result = yield _sendTransaction(testnet, {
-                code: body.transaction,
-                args: body.args,
-                proposer: proposer ? proposer(false) : proposalSigner,
-                authorizations: [auth],
-                keyHash,
-                payer: payer ? payer(true) : getApiSigner(true).signer,
-            });
-            return { txId: result.id, events: result.events };
-        }),
-        /**
-         * Send FLOW or FUSD from account to account.
-         * @param testnet
          * @param body content of the transaction to broadcast
          * @param proposer function to obtain proposer key from
          * @param payer function to obtain payer key from
          * @returns txId id of the transaction in the blockchain
          */
-        sendTransaction: (testnet, body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-            let tokenAddress;
-            let tokenName;
-            let tokenStorage;
-            if (body.currency === shared_core_1.Blockchain.FLOW) {
-                tokenAddress = testnet ? exports.FLOW_TESTNET_ADDRESSES.FlowToken : exports.FLOW_MAINNET_ADDRESSES.FlowToken;
-                tokenName = 'FlowToken';
-                tokenStorage = 'flowToken';
-            }
-            else {
-                tokenAddress = testnet ? exports.FLOW_TESTNET_ADDRESSES.FUSD : exports.FLOW_MAINNET_ADDRESSES.FUSD;
-                tokenName = 'FUSD';
-                tokenStorage = 'fusd';
+        sendCustomTransaction: (body, proposer, payer) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            if (body.signatureId) {
+                return api_client_1.ApiServices.blockchain.flow.flowTransferCustomBlockchain(body);
             }
-            const code = txTemplates.prepareTransferTxTemplate(testnet, tokenAddress, tokenName, tokenStorage);
-            const args = [
-                { value: parseFloat(body.amount).toFixed(8), type: 'UFix64' },
-                { value: body.to, type: 'Address' },
-            ];
-            const pk = yield getPrivateKey(body);
-            if (!pk)
-                throw new flow_sdk_errors_1.FlowSdkError(shared_abstract_sdk_1.SdkErrorCode.FLOW_MISSING_PRIVATE_KEY);
-            const { signer: proposalSigner, keyHash } = proposer ? proposer(false) : getApiSigner(false);
-            const auth = getSigner(pk, body.account).signer;
-            const result = yield _sendTransaction(testnet, {
-                code,
-                args,
-                proposer: proposer ? proposer(false) : proposalSigner,
-                authorizations: [auth],
-                payer: payer ? payer(true) : getApiSigner(true).signer,
-                keyHash,
-            });
-            return { txId: result.id };
+            return sendCustomTransaction(body, proposer, payer);
         }),
+        templates: Object.assign({}, txTemplates),
     };
-    function _sendTransaction(testnet, { code, args, proposer, authorizations, payer, keyHash }) {
+    function _sendTransaction({ code, txArgs, proposer, authorizations, payer, keyHash, }) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            fcl.config().put('accessNode.api', networkUrl(testnet));
+            fcl.config().put('accessNode.api', provider.getProvider());
             let response;
             try {
                 response = yield fcl.send([
                     fcl.transaction(code),
-                    fcl.args(args.map((arg) => fcl.arg(UInt64ArgValue(arg), ArrayArgValue(arg)))),
+                    fcl.args(txArgs.map((arg) => fcl.arg(arg.value, ArrayArgValue(arg)))),
                     fcl.proposer(proposer),
                     fcl.authorizations(authorizations),
                     fcl.payer(payer),
@@ -368,22 +415,14 @@ const flowTxService = (args) => {
                 ]);
             }
             catch (e) {
-                try {
-                    if (keyHash) {
-                        yield flowSdkBlockchain.broadcast('', undefined, proposalKey(keyHash));
-                        delete process.env[keyHash];
-                    }
-                }
-                catch (_) {
-                    throw new flow_sdk_errors_1.FlowSdkError(_);
-                }
-                throw new flow_sdk_errors_1.FlowSdkError(e);
+                yield unlockProposalKey(keyHash);
+                throw new flow_sdk_errors_1.FlowSdkError({ error: e });
             }
             const { transactionId } = response;
             try {
                 const { error, events } = yield fcl.tx(response).onceSealed();
                 if (error) {
-                    throw new flow_sdk_errors_1.FlowSdkError(error);
+                    throw new flow_sdk_errors_1.FlowSdkError({ error: error });
                 }
                 return {
                     id: transactionId,
@@ -391,12 +430,28 @@ const flowTxService = (args) => {
                 };
             }
             catch (e) {
-                throw new flow_sdk_errors_1.FlowSdkError(e);
+                throw new flow_sdk_errors_1.FlowSdkError({ error: e });
             }
             finally {
-                if (keyHash) {
-                    yield flowSdkBlockchain.broadcast(transactionId, undefined, proposalKey(keyHash));
-                    delete process.env[keyHash];
+                yield unlockProposalKey(keyHash);
+            }
+        });
+    }
+    function checkBalanceOrThrow(account, tokenAddress, tokenName, tokenStorage, amount) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const balanceTx = txTemplates.prepareBalanceTxTemplate(provider.isTestnet(), tokenAddress, tokenName, tokenStorage);
+            const balanceArgs = [{ value: account, type: 'Address' }];
+            let result;
+            try {
+                result = yield sendScript(balanceTx, balanceArgs);
+            }
+            catch (_e) { }
+            if (result) {
+                if (new bignumber_js_1.default(result).lt(new bignumber_js_1.default(amount))) {
+                    throw new flow_sdk_errors_1.FlowSdkError({
+                        code: shared_abstract_sdk_1.SdkErrorCode.INSUFFICIENT_FUNDS,
+                        error: new Error(`Insufficient funds. Balance: ${result} on account ${account} is less than ${amount.toString()}`),
+                    });
                 }
             }
         });
@@ -408,36 +463,63 @@ const flowTxService = (args) => {
                 return privateKey;
             }
             else {
-                if (mnemonic && index && index >= 0) {
+                if (mnemonic && !lodash_1.default.isNil(index) && index >= 0) {
                     return flowSdkWallet.generatePrivateKeyFromMnemonic(mnemonic, index);
                 }
                 else
-                    throw new flow_sdk_errors_1.FlowSdkError(shared_abstract_sdk_1.SdkErrorCode.FLOW_MISSING_MNEMONIC);
+                    throw new flow_sdk_errors_1.FlowSdkError({ code: shared_abstract_sdk_1.SdkErrorCode.FLOW_MISSING_MNEMONIC });
             }
         });
     }
-    function sendScript(testnet, code, args) {
+    function sendScript(code, scriptArgs) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            fcl.config().put('accessNode.api', networkUrl(testnet));
+            fcl.config().put('accessNode.api', provider.getProvider());
             const response = yield fcl.send([
                 fcl.script(code),
-                fcl.args(args.map((arg) => fcl.arg(UInt64ArgValue(arg), types[arg.type]))),
+                fcl.args(scriptArgs.map((arg) => fcl.arg(arg.value, types[arg.type]))),
             ]);
             return fcl.decode(response);
         });
     }
-    function proposalKey(keyHash) {
-        return keyHash ? parseInt(process.env[keyHash] || '0') : undefined;
+    function getProposalKeyOrFetch(keyHash, isPayer) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const value = process.env[keyHash];
+            if (value) {
+                return JSON.parse(value);
+            }
+            else {
+                return apiCalls.getSignKey(isPayer);
+            }
+        });
     }
-    function networkUrl(testnet) {
-        return testnet ? 'https://access-testnet.onflow.org' : 'https://access-mainnet-beta.onflow.org';
+    function storeProposalKey(keyHash, address, keyId) {
+        process.env[keyHash] = JSON.stringify({ address, keyId });
     }
-    function UInt64ArgValue(arg) {
-        return arg.type === 'UInt64' ? parseInt(arg.value) : arg.value;
+    function proposalKey(keyHash) {
+        const value = process.env[keyHash];
+        if (!value)
+            return undefined;
+        return keyHash ? JSON.parse(value) : undefined;
     }
     function ArrayArgValue(arg) {
         return arg.type === 'Array' ? types[arg.type](types[arg.subType]) : types[arg.type];
     }
+    function unlockProposalKey(keyHash) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                if (keyHash) {
+                    const key = proposalKey(keyHash);
+                    if (key) {
+                        yield apiCalls.broadcast('', undefined, key.keyId);
+                        delete process.env[keyHash];
+                    }
+                }
+            }
+            catch (e) {
+                throw new flow_sdk_errors_1.FlowSdkError({ error: e });
+            }
+        });
+    }
 };
 exports.flowTxService = flowTxService;
 //# sourceMappingURL=flow.tx.js.map