/*
 * Copyright 2025 Circle Internet Group, Inc. All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


package com.cybavo.reactnative.wallet.service;

import androidx.fragment.app.FragmentActivity;

import com.cybavo.wallet.service.auth.PinSecret;
import com.cybavo.wallet.service.auth.results.BiometricsType;
import com.cybavo.wallet.service.auth.results.GetActionTokenResult;
import com.cybavo.wallet.service.auth.results.GetSignedActionTokenResult;
import com.cybavo.wallet.service.auth.results.OtpType;
import com.cybavo.wallet.service.auth.results.RegisterPubkeyResult;
import com.cybavo.wallet.service.auth.results.UpdateDeviceInfoResult;
import com.cybavo.wallet.service.wallet.AddressTags;
import com.cybavo.wallet.service.wallet.ApiHistoryItem;
import com.cybavo.wallet.service.wallet.Balance;
import com.cybavo.wallet.service.wallet.BalanceAddress;
import com.cybavo.wallet.service.wallet.ChainInfo;
import com.cybavo.wallet.service.wallet.EosResourceTransactionType;
import com.cybavo.wallet.service.wallet.FinancialBonus;
import com.cybavo.wallet.service.wallet.FinancialHistory;
import com.cybavo.wallet.service.wallet.FinancialProduct;
import com.cybavo.wallet.service.wallet.TokenUri;
import com.cybavo.wallet.service.wallet.Transaction;
import com.cybavo.wallet.service.wallet.TransactionExplain;
import com.cybavo.wallet.service.wallet.Wallet;
import com.cybavo.wallet.service.wallet.Wallets;
import com.cybavo.wallet.service.wallet.results.AddContractCurrenciesResult;
import com.cybavo.wallet.service.wallet.results.CallAbiFunctionResult;
import com.cybavo.wallet.service.wallet.results.ClearSecureTokenResult;
import com.cybavo.wallet.service.wallet.results.CreateTransactionResult;
import com.cybavo.wallet.service.wallet.results.CreateWalletResult;
import com.cybavo.wallet.service.wallet.results.EstimateTransactionResult;
import com.cybavo.wallet.service.wallet.results.ExportPrivateKeyResult;
import com.cybavo.wallet.service.wallet.results.GetAddressesTagsResult;
import com.cybavo.wallet.service.wallet.results.GetFinancialBonusResult;
import com.cybavo.wallet.service.wallet.results.GetFinancialHistoryResult;
import com.cybavo.wallet.service.wallet.results.GetFinancialOrderResult;
import com.cybavo.wallet.service.wallet.results.GetFinancialProductsResult;
import com.cybavo.wallet.service.wallet.results.GetWalletConnectSignedTxResult;
import com.cybavo.wallet.service.wallet.results.GetWalletConnectUnsignedDataResult;
import com.cybavo.wallet.service.wallet.results.GetApiHistoryResult;
import com.cybavo.wallet.service.wallet.results.GetBalancesResult;
import com.cybavo.wallet.service.wallet.results.GetCurrenciesResult;
import com.cybavo.wallet.service.wallet.results.GetCurrencyPriceResult;
import com.cybavo.wallet.service.wallet.results.GetCurrencyTraitsResult;
import com.cybavo.wallet.service.wallet.results.GetEosRamPriceResult;
import com.cybavo.wallet.service.wallet.results.GetEosResourcesStateResult;
import com.cybavo.wallet.service.wallet.results.GetEstimateGasResult;
import com.cybavo.wallet.service.wallet.results.GetHistoryResult;
import com.cybavo.wallet.service.wallet.results.GetMarketInfosResult;
import com.cybavo.wallet.service.wallet.results.GetSolNftTokensResult;
import com.cybavo.wallet.service.wallet.results.GetMultipleTokenUriResult;
import com.cybavo.wallet.service.wallet.results.GetNonceResult;
import com.cybavo.wallet.service.wallet.results.GetSameCurrencyWalletLimitResult;
import com.cybavo.wallet.service.wallet.results.GetTransactionFeeResult;
import com.cybavo.wallet.service.wallet.results.GetTransactionInfoResult;
import com.cybavo.wallet.service.wallet.results.GetTransactionsInfoResult;
import com.cybavo.wallet.service.wallet.results.GetWalletResult;
import com.cybavo.wallet.service.wallet.results.GetWalletUsageResult;
import com.cybavo.wallet.service.wallet.results.GetWalletsResult;
import com.cybavo.wallet.service.wallet.results.QueryCoinTypeResult;
import com.cybavo.wallet.service.wallet.results.RegisterTokenIdsResult;
import com.cybavo.wallet.service.wallet.results.RenameWalletResult;
import com.cybavo.wallet.service.wallet.results.ReplaceTransactionResult;
import com.cybavo.wallet.service.wallet.results.RequestSecureTokenResult;
import com.cybavo.wallet.service.wallet.results.SendSignedTxResult;
import com.cybavo.wallet.service.wallet.results.SetSolTokenAccountTransactionResult;
import com.cybavo.wallet.service.wallet.results.SignedRawTxResult;
import com.cybavo.wallet.service.wallet.results.TokenStandard;
import com.cybavo.wallet.service.wallet.results.ValidateEosAccountResult;
import com.cybavo.wallet.service.wallet.results.SignMessageResult;
import com.cybavo.wallet.service.wallet.results.WalletConnectGetSupportedChainResult;
import com.cybavo.wallet.service.wallet.results.WalletConnectSyncResult;
import com.facebook.react.bridge.Arguments;
import com.facebook.react.bridge.Promise;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.bridge.ReactContextBaseJavaModule;
import com.facebook.react.bridge.ReactMethod;
import com.facebook.react.bridge.ReadableArray;
import com.facebook.react.bridge.ReadableMap;
import com.facebook.react.bridge.ReadableMapKeySetIterator;
import com.facebook.react.bridge.WritableMap;

import java.util.HashMap;
import java.util.Map;

public class CybavoWalletsModule extends ReactContextBaseJavaModule {

    private final ReactApplicationContext mReactContext;

    private Wallets mWallets;

    private Wallets getWallets() {
        if (mWallets == null) {
            mWallets = Wallets.getInstance();
        }
        return mWallets;
    }

    public CybavoWalletsModule(ReactApplicationContext reactContext) {
        super(reactContext);
        this.mReactContext = reactContext;
    }

    @Override
    public String getName() {
        return "Wallets";
    }

    @Override
    public Map<String, Object> getConstants() {
        final Map<String, Object> constants = new HashMap<>();

        // Wallet.Type
        final WritableMap walletType = Arguments.createMap();
        walletType.putInt("REGULAR", Wallet.Type.REGULAR);
        walletType.putInt("MAPPED_WALLET", Wallet.Type.MAPPED_WALLET);
        final WritableMap wallet = Arguments.createMap();
        wallet.putMap("Type", walletType);
        constants.put("Wallet", wallet);

        // Transaction
        constants.put("Transaction", getTransactionEnumMap());

        // EosResourceTransactionType
        final WritableMap eosResourceTransactionType = Arguments.createMap();
        for (EosResourceTransactionType eosResTxType : EosResourceTransactionType.values()) {
            eosResourceTransactionType.putInt(eosResTxType.name(), eosResTxType.toInteger());
        }
        constants.put("EosResourceTransactionType", eosResourceTransactionType);

        // ApiHistoryItem.Status
        final WritableMap status = Arguments.createMap();
        for (ApiHistoryItem.Status s : ApiHistoryItem.Status.values()) {
            status.putInt(s.name(), s.ordinal());
        }
        final WritableMap apiHistoryItem = Arguments.createMap();
        apiHistoryItem.putMap("Status", status);
        constants.put("ApiHistoryItem", apiHistoryItem);

        // OtpType
        final WritableMap otpType = Arguments.createMap();
        for (OtpType t : OtpType.values()) {
            otpType.putInt(t.name(), t.ordinal());
        }
        constants.put("OtpType", otpType);

        // BiometricsType
        final WritableMap biometricsType = Arguments.createMap();
        for (BiometricsType t : BiometricsType.values()) {
            biometricsType.putInt(t.name(), t.ordinal());
        }
        constants.put("BiometricsType", biometricsType);

        // TokenStandard
        final WritableMap tokenStandard = Arguments.createMap();
        for (TokenStandard t : TokenStandard.values()) {
            tokenStandard.putInt(t.name(), t.getValue());
        }
        constants.put("TokenStandard", tokenStandard);

        // FinancialProduct
        constants.put("FinancialProduct", getFinancialProductEnumMap());

        // FinancialHistory
        constants.put("FinancialHistory", getFinancialHistoryEnumMap());

        // FinancialBonus
        constants.put("FinancialBonus", getFinancialBonusEnumMap());

        //TransactionExplain
        constants.put("TransactionExplain", getTransactionExplainEnumMap());

        return constants;
    }
    private WritableMap getTransactionEnumMap(){
        final WritableMap l21 = Arguments.createMap();
        final WritableMap l22 = Arguments.createMap();
        for (Transaction.Direction e : Transaction.Direction.values()) {
            l21.putInt(e.name(), e.ordinal());
        }
        for (Transaction.Type e : Transaction.Type.values()) {
            l22.putInt(e.name(), e.getValue());
        }
        final WritableMap l1 = Arguments.createMap();
        l1.putMap("Direction", l21);
        l1.putMap("Type", l22);
        return l1;
    }
    private WritableMap getFinancialProductEnumMap(){
        final WritableMap l21 = Arguments.createMap();
        final WritableMap l22 = Arguments.createMap();
        for (FinancialProduct.Kind e : FinancialProduct.Kind.values()) {
            l21.putInt(e.name(), e.getValue());
        }
        for (FinancialProduct.ListKind e : FinancialProduct.ListKind.values()) {
            l22.putInt(e.name(), e.getValue());
        }
        final WritableMap l1 = Arguments.createMap();
        l1.putMap("Kind", l21);
        l1.putMap("ListKind", l22);
        return l1;
    }
    private WritableMap getFinancialHistoryEnumMap(){
        final WritableMap l21 = Arguments.createMap();
        final WritableMap l22 = Arguments.createMap();
        for (FinancialHistory.Status e : FinancialHistory.Status.values()) {
            l21.putInt(e.name(), e.getValue());
        }
        for (FinancialHistory.ListKind e : FinancialHistory.ListKind.values()) {
            l22.putInt(e.name(), e.getValue());
        }
        final WritableMap l1 = Arguments.createMap();
        l1.putMap("Status", l21);
        l1.putMap("ListKind", l22);
        return l1;
    }
    private WritableMap getFinancialBonusEnumMap(){
        final WritableMap l21 = Arguments.createMap();
        for (FinancialBonus.Kind e : FinancialBonus.Kind.values()) {
            l21.putInt(e.name(), e.getValue());
        }
        final WritableMap l1 = Arguments.createMap();
        l1.putMap("Kind", l21);
        return l1;
    }
    private WritableMap getTransactionExplainEnumMap(){
        final WritableMap l21 = Arguments.createMap();
        for (TransactionExplain.Kind e : TransactionExplain.Kind.values()) {
            l21.putInt(e.name(), e.getValue());
        }
        final WritableMap l1 = Arguments.createMap();
        l1.putMap("Kind", l21);
        return l1;
    }
    @ReactMethod
    public void getMarketInfos(final Promise promise) {
        getWallets().getMarketInfos(new PromiseCallback<GetMarketInfosResult>(promise));
    }

    @ReactMethod
    public void getSolNftTokens(final double walletId, final Promise promise) {
        getWallets().getSolNftTokens((long) walletId, new PromiseCallback<GetSolNftTokensResult>(promise));
    }

    @ReactMethod
    public void getCurrencies(final Promise promise) {
        getWallets().getCurrencies(new PromiseCallback<GetCurrenciesResult>(promise));
    }

    @ReactMethod
    public void createWalletWithPinSecret(final double currency, final String tokenAddress,
                                          final double parentWalletId, final String name,
                                          final ReadableMap pinSecretMap,
                                          final ReadableMap extraAttributes,
                                          final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        final Map<String, String> extras = new HashMap<>();
        if (extraAttributes != null) {
            final ReadableMapKeySetIterator itor = extraAttributes.keySetIterator();
            while (itor.hasNextKey()) {
                final String key = itor.nextKey();
                // create wallets has only Strings currently
                extras.put(key, extraAttributes.getString(key));
            }
        }

        getWallets().createWallet((long) currency, tokenAddress,
                (long) parentWalletId, name, pinSecret, extras,
                new PromiseCallback<CreateWalletResult>(promise));
    }

    @ReactMethod
    public void addContractCurrencyWithPinSecret(final double currency, final String contractAddress,
                                                 final ReadableMap pinSecretMap,
                                                 final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().addContractCurrency((long) currency, contractAddress,
                pinSecret, new PromiseCallback<AddContractCurrenciesResult>(promise));
    }
    @ReactMethod
    public void addContractCurrenciesWithPinSecret(final ReadableArray currency, final ReadableArray contractAddress,
                                                 final ReadableMap pinSecretMap,
                                                 final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }
        long[] currencyArr = new long[currency.size()];
        for (int i = 0; i < currencyArr.length; i++) {
            currencyArr[i] = (long) currency.getDouble(i);
        }
        String[] contractAddressArr = new String[contractAddress.size()];
        for (int i = 0; i < contractAddressArr.length; i++) {
            contractAddressArr[i] = contractAddress.getString(i);
        }
        getWallets().addContractCurrencies(currencyArr, contractAddressArr,
                pinSecret, new PromiseCallback<AddContractCurrenciesResult>(promise));
    }
    /** Deprecated */
    @ReactMethod
    public void addContractCurrency(final double currency, final String contractAddress,
                                                 final String pinCode,
                                                 final Promise promise) {
        getWallets().addContractCurrency((long) currency, contractAddress,
                pinCode, new PromiseCallback<AddContractCurrenciesResult>(promise));
    }
    /** Deprecated */
    @ReactMethod
    public void addContractCurrencies(final ReadableArray currency, final ReadableArray contractAddress,
                                                   final String pinCode,
                                                   final Promise promise) {
        long[] currencyArr = new long[currency.size()];
        for (int i = 0; i < currencyArr.length; i++) {
            currencyArr[i] = (long) currency.getDouble(i);
        }
        String[] contractAddressArr = new String[contractAddress.size()];
        for (int i = 0; i < contractAddressArr.length; i++) {
            contractAddressArr[i] = contractAddress.getString(i);
        }
        getWallets().addContractCurrencies(currencyArr, contractAddressArr,
                pinCode, new PromiseCallback<AddContractCurrenciesResult>(promise));
    }
    @ReactMethod
    public void getWallets(final Promise promise) {
        getWallets().getWallets(new PromiseCallback<GetWalletsResult>(promise));
    }

    @ReactMethod
    public void getWalletsByChainIds(final ReadableArray chainIds, final Promise promise) {

        long[] chainIdsArr = new long[chainIds.size()];
        for (int i = 0; i < chainIdsArr.length; i++) {
            chainIdsArr[i] = (long) chainIds.getDouble(i);
        }
        getWallets().getWalletsByChainIds(chainIdsArr, new PromiseCallback<GetWalletsResult>(promise));
    }

    @ReactMethod
    public void getWalletsByCaip2ChainIds(final ReadableArray caip2ChainIds, final Promise promise) {

        String[] chainIdsArr = new String[caip2ChainIds.size()];
        for (int i = 0; i < chainIdsArr.length; i++) {
            chainIdsArr[i] = caip2ChainIds.getString(i);
        }
        getWallets().getWalletsByCaip2ChainIds(chainIdsArr, new PromiseCallback<GetWalletsResult>(promise));
    }

    @ReactMethod
    public void queryCoinType(final String address, final Promise promise){
        getWallets().queryCoinType(address, new PromiseCallback<QueryCoinTypeResult>(promise));
    }

    @ReactMethod
    public void getCurrencyTraits(final double currency, final String tokenAddress, final double tokenVersion, final String walletAddress, final Promise promise){
        getWallets().getCurrencyTraits((long) currency, tokenAddress, (long) tokenVersion, walletAddress, new PromiseCallback<GetCurrencyTraitsResult>(promise){
            @Override
            public void onResult(GetCurrencyTraitsResult result) {
                WritableMap map = BridgeHelper.objectToMap(result);
                promise.resolve(map);

            }
        });
    }

    @ReactMethod
    public void walletConnectGetSupportedChain(final Promise promise){
        getWallets().walletConnectGetSupportedChain(new PromiseCallback<WalletConnectGetSupportedChainResult>(promise){
            @Override
            public void onResult(WalletConnectGetSupportedChainResult result) {
                promise.resolve(getChainMap(result));

            }
        });
    }

    @ReactMethod
    public void getEstimateGas(final double walletId, final String content, final Promise promise){
        getWallets().getEstimateGas((long) walletId, content, new PromiseCallback<GetEstimateGasResult>(promise){
            @Override
            public void onResult(GetEstimateGasResult result) {
                WritableMap map = BridgeHelper.objectToMap(result);
                promise.resolve(map);

            }
        });
    }

    @ReactMethod
    public void getSameCurrencyWalletLimit(final Promise promise){
        getWallets().getSameCurrencyWalletLimit(new PromiseCallback<GetSameCurrencyWalletLimitResult>(promise){
            @Override
            public void onResult(GetSameCurrencyWalletLimitResult result) {
                WritableMap map = BridgeHelper.objectToMap(result);
                promise.resolve(map);

            }
        });
    }

    @ReactMethod
    public void getAddressesTags(final double currency, final ReadableArray addresses, final Promise promise){

        String[] addressArr = new String[addresses.size()];
        for (int i = 0; i < addressArr.length; i++) {
            addressArr[i] = addresses.getString(i);
        }
        getWallets().getAddressesTags((long) currency, addressArr, new PromiseCallback<GetAddressesTagsResult>(promise){
            @Override
            public void onResult(GetAddressesTagsResult result) {

                final WritableMap map = Arguments.createMap();
                for (Map.Entry<String, AddressTags> entry : result.addressTagMap.entrySet()) {
                    map.putMap(entry.getKey(),BridgeHelper.objectToMap(entry.getValue()));
                }
                final WritableMap resultMap = Arguments.createMap();
                resultMap.putMap("addressTagMap", map);
                promise.resolve(resultMap);
            }
        });
    }

    @ReactMethod
    public void getMultipleTokenUri(final double currency, final ReadableArray tokenAddresses, final ReadableArray tokenIds, final Promise promise){

        String[] tokenAddressesArr = new String[tokenAddresses.size()];
        for (int i = 0; i < tokenAddressesArr.length; i++) {
            tokenAddressesArr[i] = tokenAddresses.getString(i);
        }
        String[] tokenIdsArr = new String[tokenIds.size()];
        for (int i = 0; i < tokenIdsArr.length; i++) {
            tokenIdsArr[i] = tokenIds.getString(i);
        }
        getWallets().getMultipleTokenUri((long) currency, tokenAddressesArr, tokenIdsArr, new PromiseCallback<GetMultipleTokenUriResult>(promise){
            @Override
            public void onResult(GetMultipleTokenUriResult result) {

                final WritableMap map = Arguments.createMap();
                for (Map.Entry<String, TokenUri> entry : result.tokenUriMap.entrySet()) {
                    map.putMap(entry.getKey(),BridgeHelper.objectToMap(entry.getValue()));
                }
                final WritableMap resultMap = Arguments.createMap();
                resultMap.putMap("tokenUriMap", map);
                promise.resolve(resultMap);
            }
        });
    }

    @ReactMethod
    public void getCurrencyPrices(final ReadableArray wallets, final ReadableArray exchangeCurrencies, final ReadableMap approximateRates, final Promise promise) {
        String[] exchange = new String[exchangeCurrencies.size()];
        for (int i = 0; i < exchange.length; i++) {
            exchange[i] = exchangeCurrencies.getString(i);
        }
        Wallet[] w = new Wallet[wallets.size()];
        for (int i = 0; i < w.length; i++) {
            final ReadableMap elem = wallets.getMap(i);
            w[i] = new Wallet();
            w[i].currency = (long) elem.getDouble("currency");
            w[i].tokenAddress = elem.getString("tokenAddress");
        }
        Map<String, Map<String, Double>> ratesMap = BridgeHelper.extractApproximateRates(approximateRates);
        getWallets().getCurrencyPrice(w, exchange, ratesMap, new PromiseCallback<GetCurrencyPriceResult>(promise){
            @Override
            public void onResult(GetCurrencyPriceResult result) {
                final WritableMap map = Arguments.createMap();
                for (Map.Entry<String, Double> entry : result.currencyPrice.entrySet()) {
                    map.putDouble(entry.getKey(),entry.getValue());
                }
                promise.resolve(map);
            }
        });
    }

    private Map<Integer, BalanceAddress> getBalancesAddressesMap(final ReadableArray addresses){
        final Map<Integer, BalanceAddress> addressesMap = new HashMap<>();
        final int N = addresses.size();
        for (int i = 0; i < N; i++) {
            BalanceAddress addr = new BalanceAddress();
            final ReadableMap elem = addresses.getMap(i);
            addr.currency = (long) elem.getDouble("currency");
            addr.tokenAddress = elem.getString("tokenAddress");
            addr.address = elem.getString("address");
            addressesMap.put(i, addr);
        }
        return addressesMap;
    }
    @ReactMethod
    public void getBalances(final ReadableArray addresses, final Promise promise) {
        final Map<Integer, BalanceAddress> addressesMap = getBalancesAddressesMap(addresses);
        getWallets().getBalances(addressesMap, new PromiseCallback<GetBalancesResult>(promise) {
            @Override
            public void onResult(GetBalancesResult result) {
                final WritableMap map = Arguments.createMap();
                for (Map.Entry<Integer, Balance> entry : result.balances.entrySet()) {
                    map.putMap(entry.getKey().toString(),
                            BridgeHelper.objectToMap(entry.getValue()));
                }
                promise.resolve(map);
            }
        });
    }
    @ReactMethod
    public void getBalancesLegacy(final ReadableArray addresses, final Promise promise) {
        final Map<Integer, BalanceAddress> addressesMap = getBalancesAddressesMap(addresses);
        getWallets().getBalancesLegacy(addressesMap, new PromiseCallback<GetBalancesResult>(promise) {
            @Override
            public void onResult(GetBalancesResult result) {
                final WritableMap map = Arguments.createMap();
                for (Map.Entry<Integer, Balance> entry : result.balances.entrySet()) {
                    map.putMap(entry.getKey().toString(),
                            BridgeHelper.objectToMap(entry.getValue()));
                }
                promise.resolve(map);
            }
        });
    }

    @ReactMethod
    public void getFinancialProducts(final ReadableArray kinds, final Promise promise) {
        int[] kindArr = new int[kinds.size()];
        for (int i = 0; i < kindArr.length; i++) {
            kindArr[i] = kinds.getInt(i);
        }
        getWallets().getFinancialProducts(kindArr,
                new PromiseCallback<GetFinancialProductsResult>(promise));
    }
    @ReactMethod
    public void getFinancialHistoryByKind(final int kind, final String page, final Promise promise) {
        getWallets().getFinancialHistory(kind, page,
                new PromiseCallback<GetFinancialHistoryResult>(promise){
                    @Override
                    public void onResult(GetFinancialHistoryResult result) {
                        final WritableMap map = Arguments.createMap();
                        final WritableMap productMap = Arguments.createMap();
                        for (Map.Entry<String, FinancialProduct> entry : result.products.entrySet()) {
                            productMap.putMap(entry.getKey(),
                                    BridgeHelper.objectToMap(entry.getValue()));
                        }
                        map.putInt("kind",result.kind.getValue());
                        map.putString("prevPage",result.prevPage);
                        map.putString("nextPage",result.nextPage);
                        map.putMap("products",productMap);
                        map.putArray("histories",BridgeHelper.objectToArray(result.histories));
                        promise.resolve(map);
                    }
                });
    }
    @ReactMethod
    public void getFinancialHistoryByProduct(final String productUuid, final String page, final Promise promise) {
        getWallets().getFinancialHistory(productUuid, page,
                new PromiseCallback<GetFinancialHistoryResult>(promise){
                    @Override
                    public void onResult(GetFinancialHistoryResult result) {
                        final WritableMap map = Arguments.createMap();
                        final WritableMap productMap = Arguments.createMap();
                        for (Map.Entry<String, FinancialProduct> entry : result.products.entrySet()) {
                            productMap.putMap(entry.getKey(),
                                    BridgeHelper.objectToMap(entry.getValue()));
                        }
                        map.putInt("kind",result.kind.getValue());
                        map.putString("prevPage",result.prevPage);
                        map.putString("nextPage",result.nextPage);
                        map.putMap("products",productMap);
                        map.putArray("histories",BridgeHelper.objectToArray(result.histories));
                        promise.resolve(map);
                    }
                });
    }
    @ReactMethod
    public void getFinancialBonusList(final Promise promise) {
        getWallets().getFinancialBonusList(new PromiseCallback<GetFinancialBonusResult>(promise));
    }
    @ReactMethod
    public void getFinancialOrder(final String productUuid, final String orderId, final Promise promise) {
        getWallets().getFinancialOrder(productUuid, orderId, new PromiseCallback<GetFinancialOrderResult>(promise));
    }
    @ReactMethod
    public void getHistory(final double currency, final String tokenAddress, final String address,
                           final int start, final int count, final ReadableMap filters, final Promise promise) {
        getWallets().getHistory((long)currency, tokenAddress, address, start, count,
                BridgeHelper.extractFiltersForHistory(filters),
                new PromiseCallback<GetHistoryResult>(promise));
    }
    @ReactMethod
    public void getUserHistory(final int start, final int count, final ReadableMap filters, final Promise promise) {
        getWallets().getUserHistory(start, count,
                BridgeHelper.extractFiltersForHistory(filters),
                new PromiseCallback<GetHistoryResult>(promise));
    }
    @ReactMethod
    public void getHistoryWithCrossChain(final double currency, final String tokenAddress, final String address,
                           final int start, final int count, final int crossChain, final ReadableMap filters, final Promise promise) {
        getWallets().getHistory((long)currency, tokenAddress, address, start, count,
                crossChain,
                BridgeHelper.extractFiltersForHistory(filters),
                new PromiseCallback<GetHistoryResult>(promise));
    }

    @ReactMethod
    public void getTransactionFee(final double currency, final String tokenAddress, final Promise promise) {
        getWallets().getTransactionFee((long)currency, tokenAddress, new PromiseCallback<GetTransactionFeeResult>(promise));
    }

    @ReactMethod
    public void getWalletLegacy(final double walletId, final Promise promise) {
        getWallets().getWalletLegacy((long) walletId, new PromiseCallback<GetWalletResult>(promise));
    }

    @ReactMethod
    public void getWallet(final double walletId, final Promise promise) {
        getWallets().getWallet((long) walletId, new PromiseCallback<GetWalletResult>(promise));
    }

    @ReactMethod
    public void getWalletUsage(final double walletId, final Promise promise) {
        getWallets().getWalletUsage((long) walletId, new PromiseCallback<GetWalletUsageResult>(promise));
    }

    @ReactMethod
    public void renameWallet(final double walletId, final String name, final Promise promise) {
        getWallets().renameWallet((long) walletId, name, new PromiseCallback<RenameWalletResult>(promise));
    }

    @ReactMethod
    public void updateDeviceInfoWithType(final int type,final Promise promise) {
        getWallets().updateDeviceInfo(type, new PromiseCallback<UpdateDeviceInfoResult>(promise));
    }
    @ReactMethod
    public void updateDeviceInfo(final Promise promise) {
        getWallets().updateDeviceInfo(getReactApplicationContext(), new PromiseCallback<UpdateDeviceInfoResult>(promise));
    }
    @ReactMethod
    public void getTransactionSmsCode(final double duration, final Promise promise) {
        getWallets().getTransactionSmsCode((long)duration, new PromiseCallback<GetActionTokenResult>(promise));
    }
    @ReactMethod
    public void getLoginSmsCode(final double duration, final Promise promise) {
        getWallets().getLoginSmsCode((long)duration, new PromiseCallback<GetActionTokenResult>(promise));
    }
    @ReactMethod
    public void getSmsCode(final int type, final double duration, final Promise promise) {
        getWallets().getSmsCode(type, (long)duration, new PromiseCallback<GetActionTokenResult>(promise));
    }
    @ReactMethod
    public void registerPubkey(final Promise promise) {
        getWallets().registerPubkey(new PromiseCallback<RegisterPubkeyResult>(promise));
    }

    @ReactMethod
    public void getBiometricsType(final Promise promise) {
        BiometricsType biometricsType = getWallets().getBiometricsType(getReactApplicationContext());
        final WritableMap map = Arguments.createMap();
        map.putInt("biometricsType", biometricsType.ordinal());
        promise.resolve(map);
    }

    @ReactMethod
    public void isBioKeyExist(final Promise promise) {
        boolean isBioKeyExist = getWallets().isBioKeyExist();
        final WritableMap map = Arguments.createMap();
        map.putBoolean("exist", isBioKeyExist);
        promise.resolve(map);
    }

    @ReactMethod
    public void getSignedActionToken(final String promptMessage, final String cancelButtonText, final Promise promise) {
        getWallets().getSignedActionToken( (FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText,
                new PromiseCallback<GetSignedActionTokenResult>(promise));
    }

    @ReactMethod
    public void getActionToken(final Promise promise) {
        getWallets().getActionToken(new PromiseCallback<GetActionTokenResult>(promise));
    }
    @ReactMethod
    public void getSignMessageActionToken(String message, final Promise promise) {
        getWallets().getSignMessageActionToken(message, new PromiseCallback<GetActionTokenResult>(promise));
    }

    @ReactMethod
    public void createTransactionWithPinSecret(final double fromWalletId, final String toAddress,
                                               final String amount, final String transactionFee,
                                               final String description,
                                               final ReadableMap pinSecretMap,
                                               final ReadableMap extraAttributes,
                                               final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().createTransaction((long) fromWalletId, toAddress,
                amount, transactionFee,
                description,
                pinSecret,
                BridgeHelper.extractExtrasForTransaction(extraAttributes),
                new PromiseCallback<CreateTransactionResult>(promise));
    }

    @ReactMethod
    public void createTransactionSmsWithPinSecret(final String actionToken,final String smsCode, final double fromWalletId, final String toAddress,
                                               final String amount, final String transactionFee,
                                               final String description,
                                               final ReadableMap pinSecretMap,
                                               final ReadableMap extraAttributes,
                                               final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().createTransactionSms(actionToken, smsCode, (long) fromWalletId, toAddress,
                amount, transactionFee,
                description,
                pinSecret,
                BridgeHelper.extractExtrasForTransaction(extraAttributes),
                new PromiseCallback<CreateTransactionResult>(promise));
    }

    @ReactMethod
    public void createTransactionBioWithPinSecret(final String promptMessage, final String cancelButtonText, final double fromWalletId, final String toAddress,
                                               final String amount, final String transactionFee,
                                               final String description,
                                               final ReadableMap pinSecretMap,
                                               final ReadableMap extraAttributes,
                                               final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().createTransactionBio( (FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long) fromWalletId, toAddress,
                amount, transactionFee,
                description,
                pinSecret,
                BridgeHelper.extractExtrasForTransaction(extraAttributes),
                new PromiseCallback<CreateTransactionResult>(promise));
    }

    @ReactMethod
    public void createTransactionWithSecureToken(final double fromWalletId, final String toAddress,
                                                 final String amount, final String transactionFee,
                                                 final String description,
                                                 final ReadableMap extraAttributes,
                                                 final Promise promise) {
        getWallets().createTransaction((long) fromWalletId, toAddress,
                amount, transactionFee, description,
                BridgeHelper.extractExtrasForTransaction(extraAttributes),
                new PromiseCallback<CreateTransactionResult>(promise));
    }

    @ReactMethod
    public void createTransactionSmsWithSecureToken(final String actionToken,final String smsCode, final double fromWalletId, final String toAddress,
                                                 final String amount, final String transactionFee,
                                                 final String description,
                                                 final ReadableMap extraAttributes,
                                                 final Promise promise) {
        getWallets().createTransactionSms(actionToken, smsCode, (long) fromWalletId, toAddress,
                amount, transactionFee, description,
                BridgeHelper.extractExtrasForTransaction(extraAttributes),
                new PromiseCallback<CreateTransactionResult>(promise));
    }

    @ReactMethod
    public void createTransactionBioWithSecureToken(final String promptMessage, final String cancelButtonText, final double fromWalletId, final String toAddress,
                                                 final String amount, final String transactionFee,
                                                 final String description,
                                                 final ReadableMap extraAttributes,
                                                 final Promise promise) {
        getWallets().createTransactionBio( (FragmentActivity) getCurrentActivity(),promptMessage, cancelButtonText, (long) fromWalletId, toAddress,
                amount, transactionFee, description,
                BridgeHelper.extractExtrasForTransaction(extraAttributes),
                new PromiseCallback<CreateTransactionResult>(promise));
    }

    @ReactMethod
    public void requestSecureTokenWithPinSecret(final ReadableMap pinSecretMap, final Promise promise) {

        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().requestSecureToken(pinSecret, new PromiseCallback<RequestSecureTokenResult>(promise));
    }

    @ReactMethod
    public void requestSecureTokenSmsWithPinSecret(final String actionToken, final String smsCode, final ReadableMap pinSecretMap, final Promise promise) {

        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().requestSecureTokenSms(actionToken, smsCode, pinSecret, new PromiseCallback<RequestSecureTokenResult>(promise));
    }

    @ReactMethod
    public void requestSecureTokenBioWithPinSecret(final String promptMessage, final String cancelButtonText, final ReadableMap pinSecretMap, final Promise promise) {

        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().requestSecureTokenBio( (FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, pinSecret, new PromiseCallback<RequestSecureTokenResult>(promise));
    }

    @ReactMethod
    public void increaseTransactionFeeWithPinSecret(final double fromWalletId, final String txid, final String transactionFee,
                                                    final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().increaseTransactionFee((long) fromWalletId, txid, transactionFee, pinSecret,
                new PromiseCallback<ReplaceTransactionResult>(promise));
    }

    @ReactMethod
    public void increaseTransactionFeeSmsWithPinSecret(final String actionToken, final String smsCode, final double fromWalletId, final String txid, final String transactionFee,
                                                    final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().increaseTransactionFeeSms(actionToken, smsCode, (long) fromWalletId, txid, transactionFee, pinSecret,
                new PromiseCallback<ReplaceTransactionResult>(promise));
    }

    @ReactMethod
    public void increaseTransactionFeeBioWithPinSecret(final String promptMessage, final String cancelButtonText, final double fromWalletId, final String txid, final String transactionFee,
                                                    final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().increaseTransactionFeeBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long) fromWalletId, txid, transactionFee, pinSecret,
                new PromiseCallback<ReplaceTransactionResult>(promise));
    }

    @ReactMethod
    public void cancelTransactionWithPinSecret(final double fromWalletId, final String txid, final String transactionFee,
                                               final ReadableMap pinSecretMap, final Promise promise) {

        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().cancelTransaction((long) fromWalletId, txid, transactionFee, pinSecret,
                new PromiseCallback<ReplaceTransactionResult>(promise));
    }

    @ReactMethod
    public void cancelTransactionSmsWithPinSecret(final String actionToken, final String smsCode, final double fromWalletId, final String txid, final String transactionFee,
                                               final ReadableMap pinSecretMap, final Promise promise) {

        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().cancelTransactionSms(actionToken, smsCode, (long) fromWalletId, txid, transactionFee, pinSecret,
                new PromiseCallback<ReplaceTransactionResult>(promise));
    }

    @ReactMethod
    public void cancelTransactionBioWithPinSecret(final String promptMessage, final String cancelButtonText, final double fromWalletId, final String txid, final String transactionFee,
                                               final ReadableMap pinSecretMap, final Promise promise) {

        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().cancelTransactionBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long) fromWalletId, txid, transactionFee, pinSecret,
                new PromiseCallback<ReplaceTransactionResult>(promise));
    }

    @ReactMethod
    public void clearSecureToken(final Promise promise) {
        getWallets().clearSecureToken(new PromiseCallback<ClearSecureTokenResult>(promise));
    }

    @ReactMethod
    public void callAbiFunctionWithPinSecret(final double walletId, final String name, final ReadableMap inputs, final ReadableMap pinSecretMap, final Promise promise) {

        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        final Map<String, Object> nativeInputs = BridgeHelper.reactNativeMapToNativeMap(inputs);
        getWallets().callAbiFunction((long) walletId, name, nativeInputs, pinSecret, new PromiseCallback<CallAbiFunctionResult>(promise));
    }

    @ReactMethod
    public void callAbiFunctionSmsWithPinSecret(final String actionToken, final String smsCode, final double walletId, final String name, final ReadableMap inputs, final ReadableMap pinSecretMap, final Promise promise) {

        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        final Map<String, Object> nativeInputs = BridgeHelper.reactNativeMapToNativeMap(inputs);
        getWallets().callAbiFunctionSms(actionToken, smsCode, (long) walletId, name, nativeInputs, pinSecret, new PromiseCallback<CallAbiFunctionResult>(promise));
    }

    @ReactMethod
    public void callAbiFunctionBioWithPinSecret(final String promptMessage, final String cancelButtonText, final double walletId, final String name, final ReadableMap inputs, final ReadableMap pinSecretMap, final Promise promise) {

        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        final Map<String, Object> nativeInputs = BridgeHelper.reactNativeMapToNativeMap(inputs);
        getWallets().callAbiFunctionBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long) walletId, name, nativeInputs, pinSecret, new PromiseCallback<CallAbiFunctionResult>(promise));
    }

    @ReactMethod
    public void callAbiFunctionRead(final double walletId, final String name, final String contractAddress, final String abiJson, final ReadableArray args, final Promise promise) {
        final Object[] nativeArray = BridgeHelper.reactNativeArrayToNativeArray(args);
        getWallets().callAbiFunctionRead((long) walletId, name, contractAddress, abiJson, nativeArray, new PromiseCallback<CallAbiFunctionResult>(promise));
    }

    @ReactMethod
    public void callAbiFunctionTransactionWithPinSecret(final double walletId, final String name, final String contractAddress, final String abiJson, final ReadableArray args, final String transactionFee, final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        final Object[] nativeArray = BridgeHelper.reactNativeArrayToNativeArray(args);
        getWallets().callAbiFunctionTransaction((long) walletId, name, contractAddress, abiJson, nativeArray, transactionFee, pinSecret, new PromiseCallback<CallAbiFunctionResult>(promise));
    }

    @ReactMethod
    public void callAbiFunctionTransactionSmsWithPinSecret(final String actionToken, final String smsCode, final double walletId, final String name, final String contractAddress, final String abiJson, final ReadableArray args, final String transactionFee, final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        final Object[] nativeArray = BridgeHelper.reactNativeArrayToNativeArray(args);
        getWallets().callAbiFunctionTransactionSms(actionToken, smsCode, (long) walletId, name, contractAddress, abiJson, nativeArray, transactionFee, pinSecret, new PromiseCallback<CallAbiFunctionResult>(promise));
    }

    @ReactMethod
    public void callAbiFunctionTransactionBioWithPinSecret(final String promptMessage, final String cancelButtonText, final double walletId, final String name, final String contractAddress, final String abiJson, final ReadableArray args, final String transactionFee, final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        final Object[] nativeArray = BridgeHelper.reactNativeArrayToNativeArray(args);
        getWallets().callAbiFunctionTransactionBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long) walletId, name, contractAddress, abiJson, nativeArray, transactionFee, pinSecret, new PromiseCallback<CallAbiFunctionResult>(promise));
    }

    @ReactMethod
    public void signMessageWithPinSecret(final double walletId, final String message, final ReadableMap pinSecretMap, final ReadableMap inputs, final Promise promise) {

        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        final Map<String, Object> nativeInputs = BridgeHelper.reactNativeMapToNativeMap(inputs);
        getWallets().signMessage((long) walletId, message, pinSecret, nativeInputs, new PromiseCallback<SignMessageResult>(promise));
    }

    @ReactMethod
    public void signMessageSmsWithPinSecret(final String actionToken, final String smsCode, final double walletId, final String message, final ReadableMap pinSecretMap, final ReadableMap inputs, final Promise promise) {

        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        final Map<String, Object> nativeInputs = BridgeHelper.reactNativeMapToNativeMap(inputs);
        getWallets().signMessageSms(actionToken, smsCode, (long) walletId, message, pinSecret, nativeInputs, new PromiseCallback<SignMessageResult>(promise));
    }

    @ReactMethod
    public void signMessageBioWithPinSecret(final String promptMessage, final String cancelButtonText, final double walletId, final String message, final ReadableMap pinSecretMap, final ReadableMap inputs, final Promise promise) {

        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        final Map<String, Object> nativeInputs = BridgeHelper.reactNativeMapToNativeMap(inputs);
        getWallets().signMessageBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long) walletId, message, pinSecret, nativeInputs, new PromiseCallback<SignMessageResult>(promise));
    }

    @ReactMethod
    public void getTransactionInfo(final double currency, final String txid, final Promise promise) {
        getWallets().getTransactionInfo((long) currency, txid, new PromiseCallback<GetTransactionInfoResult>(promise));
    }

    @ReactMethod
    public void getTransactionsInfo(final double currency, final ReadableArray txids, final Promise promise) {
        String[] txidArr = new String[txids.size()];
        for (int i = 0; i < txids.size(); i++) {
            txidArr[i] = txids.getString(i);
        }
        getWallets().getTransactionsInfo((long) currency, txidArr, new PromiseCallback<GetTransactionsInfoResult>(promise) {
            @Override
            public void onResult(GetTransactionsInfoResult result) {
                final WritableMap transactionsInfo = Arguments.createMap();
                for (Map.Entry<String, GetTransactionInfoResult> entry : result.transactionsInfo.entrySet()) {
                    transactionsInfo.putMap(entry.getKey(),
                            BridgeHelper.objectToMap(entry.getValue()));
                }

                final WritableMap resultMap = Arguments.createMap();
                resultMap.putMap("transactionsInfo", transactionsInfo);
                promise.resolve(resultMap);
            }
        });
    }

    @ReactMethod
    public void getEosRamPrice(final Promise promise) {
        getWallets().getEosRamPrice(new PromiseCallback<GetEosRamPriceResult>(promise));
    }

    @ReactMethod
    public void getEosResourceState(final String accountName, final Promise promise) {
        getWallets().getEosResourceState(accountName, new PromiseCallback<GetEosResourcesStateResult>(promise));
    }

    @ReactMethod
    public void validateEosAccount(final String accountName, final Promise promise) {
        getWallets().validateEosAccount(accountName, new PromiseCallback<ValidateEosAccountResult>(promise));
    }

    @ReactMethod
    public void signRawTxWithPinSecret(final double walletId, final String rawTx, final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }
        getWallets().signRawTx((long)walletId, rawTx, pinSecret, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }

    @ReactMethod
    public void commonSignRawTxWithPinSecret(final double walletId, final String rawTx, final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }
        getWallets().commonSignRawTx((long) walletId, rawTx, pinSecret, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }

    @ReactMethod
    public void signRawTxSmsWithPinSecret(final String actionToken, final String smsCode, final double walletId, final String rawTx, final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }
        getWallets().signRawTxSms(actionToken, smsCode, (long)walletId, rawTx, pinSecret, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }

    @ReactMethod
    public void commonSignRawTxSmsWithPinSecret(final String actionToken, final String smsCode, final double walletId, final String rawTx, final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }
        getWallets().commonSignRawTxSms(actionToken, smsCode, (long)walletId, rawTx, pinSecret, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }

    @ReactMethod
    public void signRawTxBioWithPinSecret(final String promptMessage, final String cancelButtonText, final double walletId, final String rawTx, final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().signRawTxBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long)walletId, rawTx, pinSecret, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }
    @ReactMethod
    public void commonSignRawTxBioWithPinSecret(final String promptMessage, final String cancelButtonText, final double walletId, final String rawTx, final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().commonSignRawTxBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long)walletId, rawTx, pinSecret, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }

    @ReactMethod
    public void sendSignedTx(final double walletId, final String signedTx, final Promise promise) {
        getWallets().sendSignedTx((long)walletId, signedTx, new PromiseCallback<SendSignedTxResult>(promise));
    }

    @ReactMethod
    public void estimateTransaction(double currency, String tokenAddress, String amount, String transactionFee, final Promise promise) {
        getWallets().estimateTransaction((long) currency, tokenAddress, amount, transactionFee, new PromiseCallback<EstimateTransactionResult>(promise));
    }

    @ReactMethod
    public void estimateTransactionWithId(double currency, String tokenAddress, String amount, String transactionFee, final double walletId, final Promise promise) {
        getWallets().estimateTransaction((long) currency, tokenAddress, amount, transactionFee, (long)walletId,  new PromiseCallback<EstimateTransactionResult>(promise));
    }
    @ReactMethod
    public void estimateTransactionWithIdAddress(double currency, String tokenAddress, String amount, String transactionFee, final double walletId, String toAddress, final Promise promise) {
        getWallets().estimateTransaction((long) currency, tokenAddress, amount, transactionFee, (long)walletId, toAddress,  new PromiseCallback<EstimateTransactionResult>(promise));
    }

    @ReactMethod
    public void walletConnectSignTypedDataWithPinSecret(final double walletId, final String typedData, final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().walletConnectSignTypedData((long)walletId, typedData, pinSecret, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }
    private WritableMap getChainMap(WalletConnectGetSupportedChainResult result){
        final WritableMap map = Arguments.createMap();
        for (Map.Entry<String, ChainInfo> entry : result.chainMap.entrySet()) {
            map.putMap(entry.getKey(), BridgeHelper.objectToMap(entry.getValue()));
        }
        final WritableMap resultMap = Arguments.createMap();
        resultMap.putMap("chainMap", map);
        return resultMap;
    }
    private WritableMap getSignedRawTxResultMap(SignedRawTxResult result){
        final WritableMap map = Arguments.createMap();
        for (Map.Entry<String, String> entry : result.signatures.entrySet()) {
            map.putString(entry.getKey(),entry.getValue());
        }
        final WritableMap resultMap = Arguments.createMap();
        resultMap.putMap("signatures", map);
        resultMap.putString("signedTx", result.signedTx);
        return resultMap;
    }

    @ReactMethod
    public void walletConnectSignTypedDataSmsWithPinSecret(final String actionToken, final String smsCode, final double walletId, final String typedData, final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().walletConnectSignTypedDataSms(actionToken, smsCode, (long)walletId, typedData, pinSecret, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }

    @ReactMethod
    public void walletConnectSignTypedDataBioWithPinSecret(final String promptMessage, final String cancelButtonText, final double walletId, final String typedData, final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().walletConnectSignTypedDataBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long)walletId, typedData, pinSecret, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }

    @ReactMethod
    public void walletConnectSignTransactionWithPinSecret(final double walletId, final String signParams, final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().walletConnectSignTransaction((long)walletId, signParams, pinSecret, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }

    @ReactMethod
    public void walletConnectSignTransactionSmsWithPinSecret(final String actionToken, final String smsCode, final double walletId, final String signParams, final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().walletConnectSignTransactionSms(actionToken, smsCode, (long)walletId, signParams, pinSecret, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }

    @ReactMethod
    public void walletConnectSignTransactionBioWithPinSecret(final String promptMessage, final String cancelButtonText, final double walletId, final String signParams, final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().walletConnectSignTransactionBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long)walletId, signParams, pinSecret, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }

    @ReactMethod
    public void walletConnectSignMessageWithPinSecret(final double walletId, final String message, final ReadableMap pinSecretMap, final ReadableMap inputs, final Promise promise) {

        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        final Map<String, Object> nativeInputs = BridgeHelper.reactNativeMapToNativeMap(inputs);
        getWallets().walletConnectSignMessage((long) walletId, message, pinSecret, nativeInputs, new PromiseCallback<SignMessageResult>(promise));
    }

    @ReactMethod
    public void walletConnectSignMessageSmsWithPinSecret(final String actionToken, final String smsCode, final double walletId, final String message, final ReadableMap pinSecretMap, final ReadableMap inputs, final Promise promise) {

        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        final Map<String, Object> nativeInputs = BridgeHelper.reactNativeMapToNativeMap(inputs);
        getWallets().walletConnectSignMessageSms(actionToken, smsCode, (long) walletId, message, pinSecret, nativeInputs, new PromiseCallback<SignMessageResult>(promise));
    }

    @ReactMethod
    public void walletConnectSignMessageBioWithPinSecret(final String promptMessage, final String cancelButtonText, final double walletId, final String message, final ReadableMap pinSecretMap, final ReadableMap inputs, final Promise promise) {

        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        final Map<String, Object> nativeInputs = BridgeHelper.reactNativeMapToNativeMap(inputs);
        getWallets().walletConnectSignMessageBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long) walletId, message, pinSecret, nativeInputs, new PromiseCallback<SignMessageResult>(promise));
    }

    @ReactMethod
    public void walletConnectSendSignedTransaction(final double walletId, final String signedTx, final Promise promise) {
        getWallets().walletConnectSendSignedTransaction((long)walletId, signedTx, new PromiseCallback<SendSignedTxResult>(promise));
    }

    @ReactMethod
    public void getWalletConnectSignedTx(final double walletId, final String accessId, final Promise promise) {
        getWallets().getWalletConnectSignedTx((long)walletId, accessId, new PromiseCallback<GetWalletConnectSignedTxResult>(promise));
    }

    @ReactMethod
    public void getWalletConnectUnsignedData(final double walletId, final String accessId, final Promise promise) {
        getWallets().getWalletConnectUnsignedData((long)walletId, accessId, new PromiseCallback<GetWalletConnectUnsignedDataResult>(promise));
    }

    @ReactMethod
    public void getWalletConnectApiHistory(final double walletId,final int start, final int count, final ReadableMap filters, final Promise promise) {
        getWallets().getWalletConnectApiHistory((long)walletId, start, count,
                BridgeHelper.extractFiltersForApiHistory(filters),
                new PromiseCallback<GetApiHistoryResult>(promise));
    }

    @ReactMethod
    public void walletConnectSync(final Promise promise) {
        getWallets().walletConnectSync(new PromiseCallback<WalletConnectSyncResult>(promise));
    }

    @ReactMethod
    public void getNonce(final double walletId, final Promise promise) {
        getWallets().getNonce((long)walletId, new PromiseCallback<GetNonceResult>(promise));
    }
    @ReactMethod
    public void registerTokenIds(final double walletId, final ReadableArray tokenIds, final Promise promise) {
        String[] tokenIdArr = new String[tokenIds.size()];
        for (int i = 0; i < tokenIdArr.length; i++) {
            tokenIdArr[i] = tokenIds.getString(i);
        }
        getWallets().registerTokenIds((long)walletId, tokenIdArr, new PromiseCallback<RegisterTokenIdsResult>(promise));
    }
    @ReactMethod
    public void cancelWalletConnectTransactionWithPinSecret(final double walletId, final String accessId,
                                                          final String transactionFee,
                                                          final ReadableMap pinSecretMap,
                                                          final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().cancelWalletConnectTransaction((long) walletId, accessId,
                transactionFee,
                pinSecret,
                new PromiseCallback<CreateTransactionResult>(promise));
    }

    @ReactMethod
    public void cancelWalletConnectTransactionSmsWithPinSecret(final String actionToken, final String smsCode, final double walletId, final String accessId,
                                                          final String transactionFee,
                                                          final ReadableMap pinSecretMap,
                                                          final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().cancelWalletConnectTransactionSms(actionToken, smsCode, (long) walletId, accessId,
                transactionFee,
                pinSecret,
                new PromiseCallback<CreateTransactionResult>(promise));
    }

    @ReactMethod
    public void cancelWalletConnectTransactionBioWithPinSecret(final String promptMessage, final String cancelButtonText, final double walletId, final String accessId,
                                                          final String transactionFee,
                                                          final ReadableMap pinSecretMap,
                                                          final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().cancelWalletConnectTransactionBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long) walletId, accessId,
                transactionFee,
                pinSecret,
                new PromiseCallback<CreateTransactionResult>(promise));
    }

    @ReactMethod
    public void setSolTokenAccountTransactionWithPinSecret(final double walletId, final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }
        getWallets().setSolTokenAccountTransaction((long) walletId, pinSecret, new PromiseCallback<SetSolTokenAccountTransactionResult>(promise));
    }

    @ReactMethod
    public void setSolTokenAccountTransactionSmsWithPinSecret(final String actionToken, final String smsCode, final double walletId, final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }
        getWallets().setSolTokenAccountTransactionSms(actionToken, smsCode, (long)walletId, pinSecret, new PromiseCallback<SetSolTokenAccountTransactionResult>(promise));
    }
    @ReactMethod
    public void setSolTokenAccountTransactionBioWithPinSecret(final String promptMessage, final String cancelButtonText, final double walletId, final ReadableMap pinSecretMap, final Promise promise) {
        // Get PinSecret
        PinSecret pinSecret = PinSecretBridge.fromReadableMap(pinSecretMap);
        if (pinSecret == null) {
            promise.reject(new NullPointerException("PinSecret not found"));
            return;
        }

        getWallets().setSolTokenAccountTransactionBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long)walletId, pinSecret, new PromiseCallback<SetSolTokenAccountTransactionResult>(promise));
    }
    /** Deprecated */
    @ReactMethod
    public void createWallet(final double currency, final String tokenAddress,
                             final double parentWalletId, final String name,
                             final String pinCode,
                             final ReadableMap extraAttributes,
                             final Promise promise) {
        final Map<String, String> extras = new HashMap<>();
        if (extraAttributes != null) {
            final ReadableMapKeySetIterator itor = extraAttributes.keySetIterator();
            while (itor.hasNextKey()) {
                final String key = itor.nextKey();
                // create wallets has only Strings currently
                extras.put(key, extraAttributes.getString(key));
            }
        }
        getWallets().createWallet((long) currency, tokenAddress,
                (long) parentWalletId, name, pinCode, extras,
                new PromiseCallback<CreateWalletResult>(promise));
    }
    /** Deprecated */
    @ReactMethod
    public void createTransactionWithPinCode(final double fromWalletId, final String toAddress,
                                             final String amount, final String transactionFee,
                                             final String description,
                                             final String pinCode,
                                             final ReadableMap extraAttributes,
                                             final Promise promise) {
        getWallets().createTransaction((long) fromWalletId, toAddress,
                amount, transactionFee,
                description,
                pinCode,
                BridgeHelper.extractExtrasForTransaction(extraAttributes),
                new PromiseCallback<CreateTransactionResult>(promise));
    }

    /** Deprecated */
    @ReactMethod
    public void increaseTransactionFeeWithPinCode(final double fromWalletId, final String txid, final String transactionFee,
                                                  final String pinCode, final Promise promise) {
        getWallets().increaseTransactionFee((long) fromWalletId, txid, transactionFee, pinCode,
                new PromiseCallback<ReplaceTransactionResult>(promise));
    }

    /** Deprecated */
    @ReactMethod
    public void cancelTransactionWithPinCode(final double fromWalletId, final String txid, final String transactionFee,
                                             final String pinCode, final Promise promise) {
        getWallets().cancelTransaction((long) fromWalletId, txid, transactionFee, pinCode,
                new PromiseCallback<ReplaceTransactionResult>(promise));
    }

    /** Deprecated */
    @ReactMethod
    public void cancelTransactionSmsWithPinCode(final String actionToken, final String smsCode, final double fromWalletId, final String txid, final String transactionFee,
                                               final String pinCode, final Promise promise) {
        getWallets().cancelTransactionSms(actionToken, smsCode, (long) fromWalletId, txid, transactionFee, pinCode,
                new PromiseCallback<ReplaceTransactionResult>(promise));
    }

    /** Deprecated */
    @ReactMethod
    public void cancelTransactionBioWithPinCode(final String promptMessage, final String cancelButtonText, final double fromWalletId, final String txid, final String transactionFee,
                                               final String pinCode, final Promise promise) {
        getWallets().cancelTransactionBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long) fromWalletId, txid, transactionFee, pinCode,
                new PromiseCallback<ReplaceTransactionResult>(promise));
    }

    /** Deprecated */
    @ReactMethod
    public void requestSecureToken(final String pinCode, final Promise promise) {
        getWallets().requestSecureToken(pinCode, new PromiseCallback<RequestSecureTokenResult>(promise));
    }
    /** Deprecated */
    @ReactMethod
    public void callAbiFunction(final double walletId, final String name, final ReadableMap inputs, final String pinCode, final Promise promise) {
        final Map<String, Object> nativeInputs = BridgeHelper.reactNativeMapToNativeMap(inputs);
        getWallets().callAbiFunction((long) walletId, name, nativeInputs, pinCode, new PromiseCallback<CallAbiFunctionResult>(promise));
    }

    @ReactMethod
    public void callAbiFunctionSmsWithPinCode(final String actionToken, final String smsCode, final double walletId, final String name, final ReadableMap inputs, final String pinCode, final Promise promise) {
        final Map<String, Object> nativeInputs = BridgeHelper.reactNativeMapToNativeMap(inputs);
        getWallets().callAbiFunctionSms(actionToken, smsCode, (long) walletId, name, nativeInputs, pinCode, new PromiseCallback<CallAbiFunctionResult>(promise));
    }

    @ReactMethod
    public void callAbiFunctionBioWithPinCode(final String promptMessage, final String cancelButtonText, final double walletId, final String name, final ReadableMap inputs, final String pinCode, final Promise promise) {
        final Map<String, Object> nativeInputs = BridgeHelper.reactNativeMapToNativeMap(inputs);
        getWallets().callAbiFunctionBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long) walletId, name, nativeInputs, pinCode, new PromiseCallback<CallAbiFunctionResult>(promise));
    }

    @ReactMethod
    public void exportPrivateKey(final double walletId, final String pinCode, final Promise promise) {
        getWallets().exportPrivateKey((long) walletId,  pinCode, new PromiseCallback<ExportPrivateKeyResult>(promise));
    }

    /** Deprecated */
    @ReactMethod
    public void callAbiFunctionTransaction(final double walletId, final String name, final String contractAddress, final String abiJson, final ReadableArray args, final String transactionFee, final String pinCode, final Promise promise) {
        final Object[] nativeArray = BridgeHelper.reactNativeArrayToNativeArray(args);
        getWallets().callAbiFunctionTransaction((long) walletId, name, contractAddress, abiJson, nativeArray, transactionFee, pinCode, new PromiseCallback<CallAbiFunctionResult>(promise));
    }

    /** Deprecated */
    @ReactMethod
    public void callAbiFunctionTransactionSmsWithPinCode(final String actionToken, final String smsCode, final double walletId, final String name, final String contractAddress, final String abiJson, final ReadableArray args, final String transactionFee, final String pinCode, final Promise promise) {
        final Object[] nativeArray = BridgeHelper.reactNativeArrayToNativeArray(args);
        getWallets().callAbiFunctionTransactionSms(actionToken, smsCode, (long) walletId, name, contractAddress, abiJson, nativeArray, transactionFee, pinCode, new PromiseCallback<CallAbiFunctionResult>(promise));
    }

    /** Deprecated */
    @ReactMethod
    public void callAbiFunctionTransactionBioWithPinCode(final String promptMessage, final String cancelButtonText, final double walletId, final String name, final String contractAddress, final String abiJson, final ReadableArray args, final String transactionFee, final String pinCode, final Promise promise) {
        final Object[] nativeArray = BridgeHelper.reactNativeArrayToNativeArray(args);
        getWallets().callAbiFunctionTransactionBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long) walletId, name, contractAddress, abiJson, nativeArray, transactionFee, pinCode, new PromiseCallback<CallAbiFunctionResult>(promise));
    }

    /** Deprecated **/
    @ReactMethod
    public void signRawTx(final double walletId, final String rawTx, final String pinCode, final Promise promise) {
        getWallets().signRawTx((long)walletId, rawTx, pinCode, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }
    /** Deprecated **/
    @ReactMethod
    public void commonSignRawTx(final double walletId, final String rawTx, final String pinCode, final Promise promise) {
        getWallets().commonSignRawTx((long)walletId, rawTx, pinCode, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }
    /** Deprecated **/
    @ReactMethod
    public void signRawTxSmsWithPinCode(final String actionToken, final String smsCode, final double walletId, final String rawTx, final String pinCode, final Promise promise) {
        getWallets().signRawTxSms(actionToken, smsCode, (long)walletId, rawTx, pinCode, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }
    /** Deprecated **/
    @ReactMethod
    public void commonSignRawTxSmsWithPinCode(final String actionToken, final String smsCode, final double walletId, final String rawTx, final String pinCode, final Promise promise) {
        getWallets().commonSignRawTxSms(actionToken, smsCode, (long)walletId, rawTx, pinCode, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }
    /** Deprecated **/
    @ReactMethod
    public void signRawTxBioWithPinCode(final String promptMessage, final String cancelButtonText, final double walletId, final String rawTx, final String pinCode, final Promise promise) {
        getWallets().signRawTxBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long) walletId, rawTx, pinCode, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }
    /** Deprecated **/
    @ReactMethod
    public void commonSignRawTxBioWithPinCode(final String promptMessage, final String cancelButtonText, final double walletId, final String rawTx, final String pinCode, final Promise promise) {
        getWallets().commonSignRawTxBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long)walletId, rawTx, pinCode, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }
    /** Deprecated */
    @ReactMethod
    public void signMessage(final double walletId, final String message, final String pinCode, final ReadableMap inputs, final Promise promise) {
        final Map<String, Object> nativeInputs = BridgeHelper.reactNativeMapToNativeMap(inputs);
        getWallets().signMessage((long) walletId, message,  pinCode, nativeInputs, new PromiseCallback<SignMessageResult>(promise));
    }

    /** Deprecated */
    @ReactMethod
    public void signMessageSmsWithPinCode(final String actionToken, final String smsCode, final double walletId, final String message, final String pinCode, final ReadableMap inputs, final Promise promise) {
        final Map<String, Object> nativeInputs = BridgeHelper.reactNativeMapToNativeMap(inputs);
        getWallets().signMessageSms(actionToken, smsCode, (long) walletId, message, pinCode, nativeInputs, new PromiseCallback<SignMessageResult>(promise));
    }

    /** Deprecated */
    @ReactMethod
    public void signMessageBioWithPinCode(final String promptMessage, final String cancelButtonText, final double walletId, final String message, final String pinCode, final ReadableMap inputs, final Promise promise) {
        final Map<String, Object> nativeInputs = BridgeHelper.reactNativeMapToNativeMap(inputs);
        getWallets().signMessageBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long) walletId, message, pinCode, nativeInputs, new PromiseCallback<SignMessageResult>(promise));
    }

    /** Deprecated **/
    @ReactMethod
    public void walletConnectSignTypedData(final double walletId, final String typedData, final String pinCode, final Promise promise) {
        getWallets().walletConnectSignTypedData((long)walletId, typedData, pinCode, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }

    /** Deprecated **/
    @ReactMethod
    public void walletConnectSignTypedDataSmsWithPinCode(final String actionToken, final String smsCode, final double walletId, final String typedData, final String pinCode, final Promise promise) {
        getWallets().walletConnectSignTypedDataSms(actionToken, smsCode, (long)walletId, typedData, pinCode, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }

    /** Deprecated **/
    @ReactMethod
    public void walletConnectSignTypedDataBioWithPinCode(final String promptMessage, final String cancelButtonText, final double walletId, final String typedData, final String pinCode, final Promise promise) {
        getWallets().walletConnectSignTypedDataBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long)walletId, typedData, pinCode, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }

    /** Deprecated **/
    @ReactMethod
    public void walletConnectSignTransaction(final double walletId, final String signParams, final String pinCode, final Promise promise) {
        getWallets().walletConnectSignTransaction((long)walletId, signParams, pinCode, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }

    /** Deprecated **/
    @ReactMethod
    public void walletConnectSignTransactionSmsWithPinCode(final String actionToken, final String smsCode, final double walletId, final String signParams, final String pinCode, final Promise promise) {
        getWallets().walletConnectSignTransactionSms(actionToken, smsCode, (long)walletId, signParams, pinCode, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }

    /** Deprecated **/
    @ReactMethod
    public void walletConnectSignTransactionBioWithPinCode(final String promptMessage, final String cancelButtonText, final double walletId, final String signParams, final String pinCode, final Promise promise) {
        getWallets().walletConnectSignTransactionBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long)walletId, signParams, pinCode, new PromiseCallback<SignedRawTxResult>(promise){
            @Override
            public void onResult(SignedRawTxResult result) {
                promise.resolve(getSignedRawTxResultMap(result));
            }
        });
    }

    /** Deprecated */
    @ReactMethod
    public void walletConnectSignMessage(final double walletId, final String message, final String pinCode, final ReadableMap inputs, final Promise promise) {
        final Map<String, Object> nativeInputs = BridgeHelper.reactNativeMapToNativeMap(inputs);
        getWallets().walletConnectSignMessage((long) walletId, message,  pinCode, nativeInputs, new PromiseCallback<SignMessageResult>(promise));
    }

    /** Deprecated */
    @ReactMethod
    public void walletConnectSignMessageSmsWithPinCode(final String actionToken, final String smsCode, final double walletId, final String message, final String pinCode, final ReadableMap inputs, final Promise promise) {
        final Map<String, Object> nativeInputs = BridgeHelper.reactNativeMapToNativeMap(inputs);
        getWallets().walletConnectSignMessageSms(actionToken, smsCode, (long) walletId, message, pinCode, nativeInputs, new PromiseCallback<SignMessageResult>(promise));
    }

    /** Deprecated */
    @ReactMethod
    public void walletConnectSignMessageBioWithPinCode(final String promptMessage, final String cancelButtonText, final double walletId, final String message, final String pinCode, final ReadableMap inputs, final Promise promise) {
        final Map<String, Object> nativeInputs = BridgeHelper.reactNativeMapToNativeMap(inputs);
        getWallets().walletConnectSignMessageBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long) walletId, message, pinCode, nativeInputs, new PromiseCallback<SignMessageResult>(promise));
    }

    /** Deprecated */
    @ReactMethod
    public void cancelWalletConnectTransactionWithPinCode(final double walletId, final String accessId,
                                             final String transactionFee,
                                             final String pinCode,
                                             final Promise promise) {
        getWallets().cancelWalletConnectTransaction((long) walletId, accessId,
                transactionFee,
                pinCode,
                new PromiseCallback<CreateTransactionResult>(promise));
    }

    /** Deprecated */
    @ReactMethod
    public void cancelWalletConnectTransactionSmsWithPinCode(final String actionToken, final String smsCode, final double walletId, final String accessId,
                                                          final String transactionFee,
                                                          final String pinCode,
                                                          final Promise promise) {
        getWallets().cancelWalletConnectTransactionSms(actionToken, smsCode, (long) walletId, accessId,
                transactionFee,
                pinCode,
                new PromiseCallback<CreateTransactionResult>(promise));
    }

    /** Deprecated */
    @ReactMethod
    public void cancelWalletConnectTransactionBioWithPinCode(final String promptMessage, final String cancelButtonText, final double walletId, final String accessId,
                                                          final String transactionFee,
                                                          final String pinCode,
                                                          final Promise promise) {
        getWallets().cancelWalletConnectTransactionBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long) walletId, accessId,
                transactionFee,
                pinCode,
                new PromiseCallback<CreateTransactionResult>(promise));
    }

    /** Deprecated **/
    @ReactMethod
    public void setSolTokenAccountTransaction(final double walletId, final String pinCode, final Promise promise) {
        getWallets().setSolTokenAccountTransaction((long)walletId, pinCode, new PromiseCallback<SetSolTokenAccountTransactionResult>(promise));
    }

    /** Deprecated **/
    @ReactMethod
    public void setSolTokenAccountTransactionSms(final String actionToken, final String smsCode, final double walletId, final String pinCode, final Promise promise) {
        getWallets().setSolTokenAccountTransactionSms(actionToken, smsCode, (long)walletId, pinCode, new PromiseCallback<SetSolTokenAccountTransactionResult>(promise));
    }

    /** Deprecated **/
    @ReactMethod
    public void setSolTokenAccountTransactionBio(final String promptMessage, final String cancelButtonText, final double walletId, final String pinCode, final Promise promise) {
        getWallets().setSolTokenAccountTransactionBio((FragmentActivity) getCurrentActivity(), promptMessage, cancelButtonText, (long)walletId, pinCode, new PromiseCallback<SetSolTokenAccountTransactionResult>(promise));
    }
}