imToken v3.28.8 - WalletAPI.java 源代码

package org.consenlabs.imtoken.walletapi;

import com.facebook.react.bridge.Promise;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.bridge.ReactMethod;
import com.facebook.react.bridge.ReadableArray;
import com.facebook.react.bridge.ReadableMap;
import com.facebook.react.bridge.WritableArray;
import com.facebook.react.bridge.WritableMap;
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import com.meituan.android.walle.WalleChannelReader;
import com.microsoft.codepush.react.CodePushConstants;
import java.math.BigInteger;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.bitcoinj.core.Sha256Hash;
import org.consenlabs.imtoken.MainApplication;
import org.consenlabs.imtoken.walletapi.TokenBaseJavaModule;
import org.consenlabs.tokencore.foundation.utils.CachedDerivedKey;
import org.consenlabs.tokencore.foundation.utils.NumericUtil;
import org.consenlabs.tokencore.wallet.Identity;
import org.consenlabs.tokencore.wallet.Wallet;
import org.consenlabs.tokencore.wallet.WalletManager;
import org.consenlabs.tokencore.wallet.keystore.EOSKeystore;
import org.consenlabs.tokencore.wallet.keystore.HDMnemonicKeystore;
import org.consenlabs.tokencore.wallet.model.ChainType;
import org.consenlabs.tokencore.wallet.model.KeyPair;
import org.consenlabs.tokencore.wallet.model.Messages;
import org.consenlabs.tokencore.wallet.model.Metadata;
import org.consenlabs.tokencore.wallet.model.MnemonicAndPath;
import org.consenlabs.tokencore.wallet.model.TokenException;
import org.consenlabs.tokencore.wallet.transaction.BitcoinTransaction;
import org.consenlabs.tokencore.wallet.transaction.EOSTransaction;
import org.consenlabs.tokencore.wallet.transaction.EthereumSign;
import org.consenlabs.tokencore.wallet.transaction.EthereumTransaction;
import org.consenlabs.tokencore.wallet.transaction.OmniTransaction;
import org.consenlabs.tokencore.wallet.transaction.TxSignResult;
import org.consenlabs.tokencore.wallet.transaction.cosmos.Coin;
import org.consenlabs.tokencore.wallet.transaction.cosmos.CosmosTransaction;
import org.consenlabs.tokencore.wallet.transaction.cosmos.StdFee;
import org.consenlabs.tokencore.wallet.validators.ETHAddressValidator;
import org.consenlabs.tokencore.wallet.validators.MetadataValidator;
import org.json.JSONException;
import org.json.JSONObject;

public class WalletAPI extends TokenBaseJavaModule {
    public String getName() {
        return "WalletAPI";
    }

    public WalletAPI(ReactApplicationContext reactApplicationContext) {
        super(reactApplicationContext);
    }

    @ReactMethod
    public void createIdentity(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                Identity createIdentity = Identity.createIdentity(readableMap.getString("name"), readableMap.getString("password"), readableMap.getString("passwordHint"), readableMap.getString("network").toUpperCase(), readableMap.getString("segWit").toUpperCase());
                WritableArray createArray = TokenBaseJavaModule.sArgumentMapper.createArray();
                Iterator<Wallet> it = createIdentity.getWallets().iterator();
                while (it.hasNext()) {
                    createArray.pushMap(TokenBaseJavaModule.createBuilder(it.next()).toMap());
                }
                WritableMap map = new WritableMapBuilder().put("identifier", createIdentity.getIdentifier()).put("ipfsId", createIdentity.getIpfsId()).toMap();
                map.putArray("wallets", createArray);
                return map;
            }
        }, promise);
    }

    @ReactMethod
    public void recoverIdentity(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                String string = readableMap.getString("name");
                String string2 = readableMap.getString("mnemonic");
                Identity recoverIdentity = Identity.recoverIdentity(string2, string, readableMap.getString("password"), readableMap.getString("passwordHint"), readableMap.getString("network").toUpperCase(), readableMap.getString("segWit").toUpperCase());
                WritableArray createArray = TokenBaseJavaModule.sArgumentMapper.createArray();
                Iterator<Wallet> it = recoverIdentity.getWallets().iterator();
                while (it.hasNext()) {
                    createArray.pushMap(TokenBaseJavaModule.createBuilder(it.next()).toMap());
                }
                WritableMap map = new WritableMapBuilder().put("identifier", recoverIdentity.getIdentifier()).put("mnemonic", string2).put("ipfsId", recoverIdentity.getIpfsId()).toMap();
                map.putArray("wallets", createArray);
                return map;
            }
        }, promise);
    }

    @ReactMethod
    public void exportIdentity(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                String string = readableMap.getString("identifier");
                String string2 = readableMap.getString("password");
                Identity currentIdentity = Identity.getCurrentIdentity();
                Preconditions.checkState(currentIdentity.getIdentifier().equals(string), Messages.INVALID_IDENTITY);
                return new WritableMapBuilder().put("identifier", string).put("mnemonic", currentIdentity.exportIdentity(string2)).toMap();
            }
        }, promise);
    }

    @ReactMethod
    public void removeIdentity(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                String string = readableMap.getString("identifier");
                String string2 = readableMap.getString("password");
                Identity currentIdentity = Identity.getCurrentIdentity();
                Preconditions.checkState(currentIdentity.getIdentifier().equals(string), Messages.INVALID_IDENTITY);
                currentIdentity.deleteIdentity(string2);
                return new WritableMapBuilder().put("identifier", string).toMap();
            }
        }, promise);
    }

    @ReactMethod
    public void deriveWalletsFromIdentity(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                String string = readableMap.getString("identifier");
                String string2 = readableMap.getString("password");
                ReadableArray array = readableMap.getArray("chainTypes");
                ArrayList arrayList = new ArrayList(array.size());
                for (int i = 0; i < array.size(); i++) {
                    arrayList.add(array.getString(i));
                }
                Identity currentIdentity = Identity.getCurrentIdentity();
                Preconditions.checkState(currentIdentity.getIdentifier().equals(string), Messages.INVALID_IDENTITY);
                List<Wallet> deriveWallets = currentIdentity.deriveWallets(arrayList, string2);
                WritableArray createArray = TokenBaseJavaModule.sArgumentMapper.createArray();
                for (int i2 = 0; i2 < deriveWallets.size(); i2++) {
                    createArray.pushMap(TokenBaseJavaModule.createBuilder(deriveWallets.get(i2)).toMap());
                }
                return createArray;
            }
        }, promise);
    }

    @ReactMethod
    public void encryptDataToIpfs(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                String string = readableMap.getString("content");
                String string2 = readableMap.getString("identifier");
                Identity currentIdentity = Identity.getCurrentIdentity();
                Preconditions.checkState(currentIdentity.getIdentifier().equals(string2), Messages.INVALID_IDENTITY);
                return new WritableMapBuilder().put("encrypted", currentIdentity.encryptDataToIPFS(string)).put("identifier", string2).toMap();
            }
        }, promise);
    }

    @ReactMethod
    public void decryptDataFromIpfs(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                String string = readableMap.getString("encrypted");
                String string2 = readableMap.getString("identifier");
                Identity currentIdentity = Identity.getCurrentIdentity();
                Preconditions.checkState(currentIdentity.getIdentifier().equals(string2), Messages.INVALID_IDENTITY);
                return new WritableMapBuilder().put("content", currentIdentity.decryptDataFromIPFS(string)).put("identifier", string2).toMap();
            }
        }, promise);
    }

    @ReactMethod
    public void generateMnemonic(ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                return WalletManager.generateMnemonic();
            }
        }, promise);
    }

    @ReactMethod
    public void mnemonicToPublicKey(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                return WalletManager.mnemonicToPublic(readableMap.getString("mnemonic"), readableMap.getString("path"), readableMap.getString("encodeTo"));
            }
        }, promise);
    }

    @ReactMethod
    public void privateKeyToPublicKey(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                return WalletManager.privateKeyToPublic(readableMap.getString("privateKey"), readableMap.getString("privateKeyType"), readableMap.getString("encodeTo"));
            }
        }, promise);
    }

    @ReactMethod
    public void importWalletFromMnemonic(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                String string = readableMap.getString("password");
                String string2 = readableMap.getString("mnemonic");
                String string3 = readableMap.getString("path");
                boolean z = readableMap.getBoolean("overwrite");
                Metadata validate = new MetadataValidator(readableMap.toHashMap()).validate();
                List<EOSKeystore.PermissionObject> readPermissions = WalletAPI.this.readPermissions(readableMap);
                if (readPermissions != null) {
                    return TokenBaseJavaModule.createBuilder(WalletManager.importWalletFromMnemonic(validate, readableMap.hasKey("accountName") ? readableMap.getString("accountName") : "", string2, string3, readPermissions, string, z)).toMap();
                }
                return TokenBaseJavaModule.createBuilder(WalletManager.importWalletFromMnemonic(validate, string2, string3, string, z)).toMap();
            }
        }, promise);
    }

    @ReactMethod
    public void findWalletByMnemonic(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                String string = readableMap.getString("mnemonic");
                String string2 = readableMap.getString("path");
                Wallet findWalletByMnemonic = WalletManager.findWalletByMnemonic(readableMap.getString("chainType"), readableMap.getString("network"), string, string2, readableMap.hasKey("segWit") ? readableMap.getString("segWit") : "");
                if (findWalletByMnemonic != null) {
                    return TokenBaseJavaModule.createBuilder(findWalletByMnemonic).toMap();
                }
                return null;
            }
        }, promise);
    }

    @ReactMethod
    public void importWalletFromKeystore(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                return TokenBaseJavaModule.createBuilder(WalletManager.importWalletFromKeystore(new MetadataValidator(readableMap.toHashMap()).validate(), readableMap.getString("keystore"), readableMap.getString("password"), readableMap.getBoolean("overwrite"))).toMap();
            }
        }, promise);
    }

    @ReactMethod
    public void findWalletByKeystore(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                Wallet findWalletByKeystore = WalletManager.findWalletByKeystore(readableMap.getString("chainType"), readableMap.getString("keystore"), readableMap.getString("password"));
                if (findWalletByKeystore != null) {
                    return TokenBaseJavaModule.createBuilder(findWalletByKeystore).toMap();
                }
                return null;
            }
        }, promise);
    }

    @ReactMethod
    public void importWalletFromPrivateKey(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                Wallet importWalletFromPrivateKey;
                String string = readableMap.getString("password");
                boolean z = readableMap.getBoolean("overwrite");
                boolean hasKey = readableMap.hasKey("privateKeys");
                String str = Metadata.FROM_WIF;
                if (hasKey) {
                    ArrayList arrayList = readableMap.getArray("privateKeys").toArrayList();
                    ArrayList arrayList2 = new ArrayList(arrayList.size());
                    Iterator it = arrayList.iterator();
                    while (it.hasNext()) {
                        arrayList2.add((String) it.next());
                    }
                    List<EOSKeystore.PermissionObject> readPermissions = WalletAPI.this.readPermissions(readableMap);
                    Metadata validate = new MetadataValidator(readableMap.toHashMap()).validate();
                    validate.setSource(Metadata.FROM_WIF);
                    return TokenBaseJavaModule.createBuilder(WalletManager.importWalletFromPrivateKeys(validate, readableMap.hasKey("accountName") ? readableMap.getString("accountName") : "", arrayList2, readPermissions, string, z)).toMap();
                }
                String string2 = readableMap.getString("privateKey");
                Metadata validate2 = new MetadataValidator(readableMap.toHashMap()).validate();
                if (ChainType.ETHEREUM.equals(validate2.getChainType())) {
                    str = Metadata.FROM_PRIVATE;
                }
                validate2.setSource(str);
                if (readableMap.hasKey("accountName")) {
                    importWalletFromPrivateKey = WalletManager.importWalletFromPrivateKey(validate2, readableMap.getString("accountName"), string2, string, z);
                } else {
                    importWalletFromPrivateKey = WalletManager.importWalletFromPrivateKey(validate2, string2, string, z);
                }
                return TokenBaseJavaModule.createBuilder(importWalletFromPrivateKey).toMap();
            }
        }, promise);
    }

    @ReactMethod
    public void findWalletByPrivateKey(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                Wallet findWalletByPrivateKey = WalletManager.findWalletByPrivateKey(readableMap.getString("chainType"), readableMap.getString("network"), readableMap.getString("privateKey"), readableMap.getString("segWit"));
                if (findWalletByPrivateKey != null) {
                    return TokenBaseJavaModule.createBuilder(findWalletByPrivateKey).toMap();
                }
                return null;
            }
        }, promise);
    }

    @ReactMethod
    public void exportPrivateKey(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                char c;
                String string = readableMap.getString("id");
                String string2 = readableMap.getString("password");
                Wallet mustFindWalletById = WalletManager.mustFindWalletById(string);
                String chainType = mustFindWalletById.getMetadata().getChainType();
                int hashCode = chainType.hashCode();
                if (hashCode == -636739593) {
                    if (chainType.equals(ChainType.ETHEREUM)) {
                        c = 1;
                    }
                    c = 65535;
                } else if (hashCode != 68841) {
                    if (hashCode == 615278846 && chainType.equals(ChainType.BITCOIN)) {
                        c = 2;
                    }
                    c = 65535;
                } else {
                    if (chainType.equals(ChainType.EOS)) {
                        c = 0;
                    }
                    c = 65535;
                }
                if (c != 0) {
                    if (c == 1) {
                        return new WritableMapBuilder().put("privateKey", WalletManager.exportPrivateKey(string, string2)).toMap();
                    }
                    if (c == 2) {
                        return new WritableMapBuilder().put("privateKey", WalletManager.exportPrivateKeyByAddress(string, string2, readableMap.hasKey("derivedPath") ? readableMap.getString("derivedPath") : null, readableMap.hasKey("address") ? readableMap.getString("address") : null)).toMap();
                    }
                    throw new TokenException("Not support the chain  of " + mustFindWalletById.getMetadata().getChainType());
                }
                List<KeyPair> exportPrivateKeys = mustFindWalletById.exportPrivateKeys(string2);
                WritableArray createArray = WalletAPI.sArgumentMapper.createArray();
                for (KeyPair keyPair : exportPrivateKeys) {
                    WritableMap createMap = WalletAPI.sArgumentMapper.createMap();
                    createMap.putString("privateKey", keyPair.getPrivateKey());
                    createMap.putString("publicKey", keyPair.getPublicKey());
                    createArray.pushMap(createMap);
                }
                return createArray;
            }
        }, promise);
    }

    @ReactMethod
    public void exportMnemonic(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                MnemonicAndPath exportMnemonic = WalletManager.exportMnemonic(readableMap.getString("id"), readableMap.getString("password"));
                return new WritableMapBuilder().put("mnemonic", exportMnemonic.getMnemonic()).put("path", exportMnemonic.getPath()).toMap();
            }
        }, promise);
    }

    @ReactMethod
    public void verifyPassword(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                String string = readableMap.getString("id");
                if (!WalletManager.mustFindWalletById(string).getKeystore().verifyPassword(readableMap.getString("password"))) {
                    throw new TokenException(Messages.WALLET_INVALID_PASSWORD);
                }
                return new WritableMapBuilder().put("id", string).toMap();
            }
        }, promise);
    }

    @ReactMethod
    public void exportKeystore(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                return new WritableMapBuilder().put("json", WalletManager.exportKeystore(readableMap.getString("id"), readableMap.getString("password"))).toMap();
            }
        }, promise);
    }

    @ReactMethod
    public void removeWallet(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                String string = readableMap.getString("id");
                WalletManager.removeWallet(string, readableMap.getString("password"));
                return new WritableMapBuilder().put("id", string).toMap();
            }
        }, promise);
    }

    @Override
    BigInteger parseBigInt(ReadableMap readableMap, String str) {
        String string = readableMap.getString(str);
        if (string != null && string.startsWith("0x")) {
            return new BigInteger(string.substring(2), 16);
        }
        return new BigInteger(string);
    }

    @ReactMethod
    public void calcExternalAddress(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                Wallet mustFindWalletById = WalletManager.mustFindWalletById(readableMap.getString("id"));
                int i = readableMap.getInt("externalIdx");
                String newReceiveAddress = mustFindWalletById.newReceiveAddress(i);
                WritableMap createMap = TokenBaseJavaModule.sArgumentMapper.createMap();
                createMap.putString("address", newReceiveAddress);
                createMap.putString("type", "EXTERNAL");
                createMap.putString("derivedPath", String.format("0/%d", Integer.valueOf(i)));
                return createMap;
            }
        }, promise);
    }

    @ReactMethod
    public void personalSign(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                ReadableMap transformToPasswordFreeMap = WalletAPI.this.transformToPasswordFreeMap(readableMap);
                String string = transformToPasswordFreeMap.getString("id");
                return NumericUtil.prependHexPrefix(EthereumSign.personalSign(transformToPasswordFreeMap.getString("data"), WalletManager.mustFindWalletById(string).decryptMainKey(transformToPasswordFreeMap.getString("password"))));
            }
        }, promise);
    }

    @ReactMethod
    public void sign(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                ReadableMap transformToPasswordFreeMap = WalletAPI.this.transformToPasswordFreeMap(readableMap);
                String string = transformToPasswordFreeMap.getString("id");
                String string2 = transformToPasswordFreeMap.getString("data");
                byte[] decryptMainKey = WalletManager.mustFindWalletById(string).decryptMainKey(transformToPasswordFreeMap.getString("password"));
                if (readableMap.hasKey("isHex") && readableMap.getBoolean("isHex")) {
                    return NumericUtil.prependHexPrefix(EthereumSign.signHex(string2, decryptMainKey));
                }
                return NumericUtil.prependHexPrefix(EthereumSign.signStr(string2, decryptMainKey));
            }
        }, promise);
    }

    @ReactMethod
    public void batchSign(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                String signStr;
                ReadableMap transformToPasswordFreeMap = WalletAPI.this.transformToPasswordFreeMap(readableMap);
                String string = transformToPasswordFreeMap.getString("id");
                String string2 = transformToPasswordFreeMap.getString("password");
                ArrayList arrayList = transformToPasswordFreeMap.getArray("data").toArrayList();
                WritableArray createArray = TokenBaseJavaModule.sArgumentMapper.createArray();
                byte[] decryptMainKey = WalletManager.mustFindWalletById(string).decryptMainKey(string2);
                boolean z = readableMap.hasKey("isHex") && readableMap.getBoolean("isHex");
                Iterator it = arrayList.iterator();
                while (it.hasNext()) {
                    Object next = it.next();
                    if (z) {
                        signStr = EthereumSign.signHex((String) next, decryptMainKey);
                    } else {
                        signStr = EthereumSign.signStr((String) next, decryptMainKey);
                    }
                    createArray.pushString(NumericUtil.prependHexPrefix(signStr));
                }
                return createArray;
            }
        }, promise);
    }

    @ReactMethod
    public void ecRecover(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                String string = readableMap.getString("data");
                String string2 = readableMap.getString("signature");
                if (readableMap.hasKey("isHex") && readableMap.getBoolean("isHex")) {
                    return EthereumSign.recoverAddressFromHex(string, string2);
                }
                return EthereumSign.recoverAddressFromStr(string, string2);
            }
        }, promise);
    }

    @ReactMethod
    public void batchECRecover(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                ArrayList arrayList = readableMap.getArray("dataAndSignatures").toArrayList();
                WritableArray createArray = TokenBaseJavaModule.sArgumentMapper.createArray();
                for (int i = 0; i < arrayList.size(); i++) {
                    ReadableMap readableMap2 = (ReadableMap) arrayList.get(i);
                    String string = readableMap2.getString("data");
                    String string2 = readableMap2.getString("signature");
                    if (readableMap.hasKey("isHex") && readableMap.getBoolean("isHex")) {
                        createArray.pushString(EthereumSign.recoverAddressFromHex(string, string2));
                    } else {
                        createArray.pushString(EthereumSign.recoverAddressFromStr(string, string2));
                    }
                }
                return createArray;
            }
        }, promise);
    }

    @ReactMethod
    public void signTransaction(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                ReadableMap transformToPasswordFreeMap = WalletAPI.this.transformToPasswordFreeMap(readableMap);
                Wallet mustFindWalletById = WalletManager.mustFindWalletById(transformToPasswordFreeMap.getString("id"));
                if (ChainType.ETHEREUM.equals(mustFindWalletById.getMetadata().getChainType())) {
                    return WalletAPI.this.signEthereumTransaction(transformToPasswordFreeMap, mustFindWalletById);
                }
                if (ChainType.BITCOIN.equals(mustFindWalletById.getMetadata().getChainType())) {
                    return WalletAPI.this.signBitcoinTransaction(transformToPasswordFreeMap, mustFindWalletById);
                }
                if (ChainType.EOS.equals(mustFindWalletById.getMetadata().getChainType())) {
                    return WalletAPI.this.signEOSTransaction(transformToPasswordFreeMap, mustFindWalletById);
                }
                if (ChainType.COSMOS.equalsIgnoreCase(mustFindWalletById.getMetadata().getChainType())) {
                    return WalletAPI.this.signCosmosTransaction(transformToPasswordFreeMap, mustFindWalletById);
                }
                mustFindWalletById.getKeystore().getCrypto().clearCachedDerivedKey();
                throw new TokenException("Unsupport ChainType ");
            }
        }, promise);
    }

    @ReactMethod
    public void signMessage(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                WalletAPI.this.transformToPasswordFreeMap(readableMap);
                throw new TokenException(Messages.WALLET_INVALID_TYPE);
            }
        }, promise);
    }

    @ReactMethod
    public void switchBTCWalletMode(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                return TokenBaseJavaModule.createBuilder(WalletManager.switchBTCWalletMode(readableMap.getString("id"), readableMap.getString("password"), readableMap.getString("segWit"))).toMap();
            }
        }, promise);
    }

    @ReactMethod
    public void signAuthenticationMessage(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                String string = readableMap.getString("identifier");
                int i = readableMap.getInt("accessTime");
                String string2 = readableMap.getString("deviceToken");
                String string3 = readableMap.getString("password");
                Identity currentIdentity = Identity.getCurrentIdentity();
                if (!currentIdentity.getIdentifier().equals(string)) {
                    throw new TokenException(Messages.INVALID_IDENTITY);
                }
                return NumericUtil.prependHexPrefix(currentIdentity.signAuthenticationMessage(i, string2, string3));
            }
        }, promise);
    }

    @ReactMethod
    public void updateEOSWalletAccountName(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                return TokenBaseJavaModule.createBuilder(WalletManager.setAccountName(readableMap.getString("id"), readableMap.getString("accountName"), readableMap.hasKey("password") ? readableMap.getString("password") : "")).toMap();
            }
        }, promise);
    }

    @ReactMethod
    public void findEOSWalletByAccountName(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                return TokenBaseJavaModule.createBuilder(WalletManager.findWalletByAddress(ChainType.EOS, readableMap.getString("accountName"))).toMap();
            }
        }, promise);
    }

    @ReactMethod
    public void eosEcSign(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                ReadableMap transformToPasswordFreeMap = WalletAPI.this.transformToPasswordFreeMap(readableMap);
                return WalletManager.eosEcSign(transformToPasswordFreeMap.getString("id"), transformToPasswordFreeMap.getString("data"), transformToPasswordFreeMap.getBoolean("isHex"), transformToPasswordFreeMap.getString("password"), transformToPasswordFreeMap.hasKey("publicKey") ? transformToPasswordFreeMap.getString("publicKey") : null);
            }
        }, promise);
    }

    @ReactMethod
    public void eosEcRecover(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                return WalletManager.eosEcRecover(readableMap.getString("data"), readableMap.getBoolean("isHex"), readableMap.getString("signature"));
            }
        }, promise);
    }

    @ReactMethod
    public void migrateEOSDerivingToMnemonicPath(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                return TokenBaseJavaModule.createBuilder(WalletManager.migrateEOSDerivingToMnemonicPath(readableMap.getString("id"), readableMap.getString("password"), readableMap.hasKey("path") ? readableMap.getString("path") : "")).toMap();
            }
        }, promise);
    }

    @ReactMethod
    public void decryptData(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                String string = readableMap.getString("cipherText");
                String string2 = readableMap.getString("password");
                String string3 = readableMap.hasKey("salt") ? readableMap.getString("salt") : "e65cc9bdc3ad15a9f6e0931b24fbf3cf";
                String string4 = readableMap.hasKey("cipher") ? readableMap.getString("cipher") : "aes-128-ctr";
                String string5 = readableMap.hasKey("padding") ? readableMap.getString("padding") : "nopadding";
                String substring = string.substring(string.length() - 64, string.length());
                byte[] decryptData = WalletManager.decryptData(string.substring(0, string.length() - 64), string4, string5, Sha256Hash.hash(string2.getBytes(Charset.forName("UTF-8"))), string3);
                if (!NumericUtil.bytesToHex(Sha256Hash.hash(decryptData)).equalsIgnoreCase(substring)) {
                    throw new TokenException(Messages.WALLET_INVALID_PASSWORD);
                }
                return NumericUtil.bytesToHex(decryptData);
            }
        }, promise);
    }

    @ReactMethod
    public void tryImportWalletFromUnknownKeystore(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                return TokenBaseJavaModule.createBuilder(WalletManager.tryImportWalletFromUnknownKeystore(readableMap.getString("keystore"), readableMap.getString("password"))).toMap();
            }
        }, promise);
    }

    @ReactMethod
    public void checkBiometricMode(ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                return BiometricProtectedData.checkBiometricMode();
            }
        }, promise);
    }

    @ReactMethod
    public void cacheDerivedKey(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                String string = readableMap.getString("id");
                String string2 = readableMap.getString("password");
                WalletManager.mustFindWalletById(string);
                new BiometricProtectedData(WalletAPI.this.getReactApplicationContext(), string).encryptData(WalletManager.getDerivedKey(string, string2));
                WritableMap createMap = TokenBaseJavaModule.sArgumentMapper.createMap();
                createMap.putString("id", string);
                createMap.putBoolean("enableDerivedKey", true);
                createMap.putString("mode", "fingerprint");
                return createMap;
            }
        }, promise);
    }

    @ReactMethod
    public void getDerivedKey(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                String string = readableMap.getString("id");
                byte[] decryptData = new BiometricProtectedData(WalletAPI.this.getReactApplicationContext(), string).decryptData();
                WritableMap createMap = TokenBaseJavaModule.sArgumentMapper.createMap();
                createMap.putString("id", string);
                createMap.putString("derivedKey", NumericUtil.bytesToHex(decryptData));
                if (WalletManager.mustFindWalletById(string).verifyDerivedKey(decryptData)) {
                    return createMap;
                }
                throw new TokenException(Messages.INVALID_CACHED_DERIVED_KEY);
            }
        }, promise);
    }

    @ReactMethod
    public void deleteDerivedKey(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                String string = readableMap.getString("id");
                new BiometricProtectedData(WalletAPI.this.getReactApplicationContext(), string).deleteEncrypted();
                WritableMap createMap = TokenBaseJavaModule.sArgumentMapper.createMap();
                createMap.putString("id", string);
                return createMap;
            }
        }, promise);
    }

    @ReactMethod
    public void exportWalletMetadata(final ReadableMap readableMap, Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                Wallet mustFindWalletById = WalletManager.mustFindWalletById(readableMap.getString("id"));
                if (!(mustFindWalletById.getKeystore() instanceof HDMnemonicKeystore)) {
                    throw new TokenException("Only allow debug BTC HD wallet");
                }
                HDMnemonicKeystore hDMnemonicKeystore = (HDMnemonicKeystore) mustFindWalletById.getKeystore();
                WritableMap createMap = TokenBaseJavaModule.sArgumentMapper.createMap();
                createMap.putString("path", hDMnemonicKeystore.getMnemonicPath());
                createMap.putString("network", hDMnemonicKeystore.getMetadata().getNetwork());
                return createMap;
            }
        }, promise);
    }

    List<EOSKeystore.PermissionObject> readPermissions(ReadableMap readableMap) {
        if (!readableMap.hasKey("permissions")) {
            return null;
        }
        ReadableArray array = readableMap.getArray("permissions");
        ArrayList arrayList = new ArrayList(array.size());
        for (int i = 0; i < array.size(); i++) {
            ReadableMap map = array.getMap(i);
            EOSKeystore.PermissionObject permissionObject = new EOSKeystore.PermissionObject();
            if (map.hasKey("parent")) {
                permissionObject.setParent(map.getString("parent"));
            }
            permissionObject.setPermission(map.getString("permission"));
            permissionObject.setPublicKey(map.getString("publicKey"));
            arrayList.add(permissionObject);
        }
        return arrayList;
    }

    public ReadableMap signEthereumTransaction(ReadableMap readableMap, Wallet wallet) {
        String string = readableMap.getString("to");
        if (!string.equals("")) {
            new ETHAddressValidator(string).validate();
        }
        TxSignResult signTransaction = new EthereumTransaction(parseBigInt(readableMap, "nonce"), parseBigInt(readableMap, "gasPrice"), parseBigInt(readableMap, "gasLimit"), readableMap.getString("to"), parseBigInt(readableMap, "value"), readableMap.getString("data")).signTransaction(readableMap.getString("chainId"), readableMap.getString("password"), wallet);
        return new WritableMapBuilder().put("sign", signTransaction.getSignature()).put(CodePushConstants.PENDING_UPDATE_HASH_KEY, signTransaction.getTxHash()).toMap();
    }

    public Object signBitcoinTransaction(ReadableMap readableMap, Wallet wallet) {
        char c;
        TxSignResult signTransaction;
        TxSignResult signTransaction2;
        ArrayList arrayList = new ArrayList();
        int i = readableMap.getInt("internalUsed") + 1;
        String string = readableMap.getString("segWit");
        String string2 = readableMap.getString("to");
        long parseLong = Long.parseLong(readableMap.getString("amount"));
        long parseLong2 = Long.parseLong(readableMap.getString("fee"));
        ReadableMap map = readableMap.hasKey("extra") ? readableMap.getMap("extra") : null;
        String string3 = readableMap.getString("password");
        String string4 = readableMap.getString("chainId");
        int i2 = 0;
        for (ReadableArray array = readableMap.getArray("outputs"); i2 < array.size(); array = array) {
            ReadableMap map2 = array.getMap(i2);
            arrayList.add(new BitcoinTransaction.UTXO(map2.getString("txHash"), map2.getInt("vout"), Long.parseLong(map2.getString("amount")), map2.getString("address"), map2.getString("scriptPubKey"), map2.getString("derivedPath")));
            i2++;
        }
        String upperCase = (readableMap.hasKey("protocol") ? readableMap.getString("protocol") : ChainType.BITCOIN).toUpperCase();
        int hashCode = upperCase.hashCode();
        char c2 = 65535;
        if (hashCode != 2429977) {
            if (hashCode == 615278846 && upperCase.equals(ChainType.BITCOIN)) {
                c = 0;
            }
            c = 65535;
        } else {
            if (upperCase.equals("OMNI")) {
                c = 1;
            }
            c = 65535;
        }
        if (c == 0) {
            BitcoinTransaction bitcoinTransaction = new BitcoinTransaction(string2, i, parseLong, parseLong2, arrayList, map != null ? map.toHashMap() : null);
            if (Metadata.P2WPKH.equalsIgnoreCase(string)) {
                signTransaction = bitcoinTransaction.signSegWitTransaction(string4, string3, wallet);
            } else {
                signTransaction = bitcoinTransaction.signTransaction(string4, string3, wallet);
            }
            return serializeSignResult(signTransaction);
        }
        if (c == 1) {
            int i3 = map.getInt("propertyId");
            String upperCase2 = map.getString("feeMode").toUpperCase();
            int hashCode2 = upperCase2.hashCode();
            if (hashCode2 != 66097) {
                if (hashCode2 == 2614190 && upperCase2.equals("USDT")) {
                    c2 = 1;
                }
            } else if (upperCase2.equals("BTC")) {
                c2 = 0;
            }
            if (c2 == 0) {
                OmniTransaction omniTransaction = new OmniTransaction(string2, parseLong, parseLong2, i3, arrayList);
                if (Metadata.P2WPKH.equalsIgnoreCase(string)) {
                    signTransaction2 = omniTransaction.signSegWitTransaction(string4, string3, wallet);
                } else {
                    signTransaction2 = omniTransaction.signTransaction(string4, string3, wallet);
                }
                return serializeSignResult(signTransaction2);
            }
            if (c2 == 1) {
                List<TxSignResult> signServerPayFeeOmniTx = OmniTransaction.signServerPayFeeOmniTx(string2, parseLong, parseLong2, i3, Long.parseLong(map.getString("usdtFee")), map.getString("serverPubKey"), arrayList, string3, wallet);
                WritableArray createArray = sArgumentMapper.createArray();
                createArray.pushMap(serializeSignResult(signServerPayFeeOmniTx.get(0)));
                createArray.pushMap(serializeSignResult(signServerPayFeeOmniTx.get(1)));
                return createArray;
            }
            throw new TokenException("Unsupport fee mode");
        }
        throw new TokenException("Only support Bitcoin or omni network");
    }

    private WritableMap serializeSignResult(TxSignResult txSignResult) {
        return new WritableMapBuilder().put("sign", txSignResult.getSignature()).put(CodePushConstants.PENDING_UPDATE_HASH_KEY, txSignResult.getTxHash()).put("wtxID", txSignResult.getWtxID()).toMap();
    }

    public ReadableArray signEOSTransaction(ReadableMap readableMap, Wallet wallet) {
        List<EOSTransaction.ToSignObj> readEOSToSignObjs = readEOSToSignObjs(readableMap);
        return presentEOSSignResult(new EOSTransaction(readEOSToSignObjs).signTransactions(readableMap.getString("chainId"), readableMap.getString("password"), wallet));
    }

    public ReadableMap signCosmosTransaction(ReadableMap readableMap, Wallet wallet) {
        String string = readableMap.getString("password");
        long parseLong = Long.parseLong(readableMap.getString("accountNumber"));
        String string2 = readableMap.getString("chainId");
        String string3 = readableMap.getString("memo");
        long parseLong2 = Long.parseLong(readableMap.getString("sequence"));
        ReadableMap map = readableMap.getMap("fee");
        StdFee stdFee = new StdFee(parseCosmosCoins(map.getArray("amount")), Long.parseLong(map.getString("gas")));
        ArrayList arrayList = new ArrayList();
        ReadableArray array = readableMap.getArray("msgs");
        for (int i = 0; i < array.size(); i++) {
            arrayList.add(array.getMap(i).toHashMap());
        }
        try {
            return new WritableMapBuilder().put("sign", convertJsonToWritableMap(new JSONObject(new CosmosTransaction(parseLong, string2, stdFee, string3, arrayList, parseLong2).signTransaction(string2, string, wallet).getSignature()))).put(CodePushConstants.PENDING_UPDATE_HASH_KEY, "").toMap();
        } catch (JSONException unused) {
            throw new TokenException(Messages.UNKNOWN_ENCODE);
        }
    }

    private List<Coin> parseCosmosCoins(ReadableArray readableArray) {
        ArrayList arrayList = new ArrayList(readableArray.size());
        for (int i = 0; i < readableArray.size(); i++) {
            arrayList.add(parseCosmosCoin(readableArray.getMap(i)));
        }
        return arrayList;
    }

    private Coin parseCosmosCoin(ReadableMap readableMap) {
        return new Coin(readableMap.getString("denom"), Long.parseLong(readableMap.getString("amount")));
    }

    @ReactMethod
    public void getChannel(Promise promise) {
        asyncCall(new TokenBaseJavaModule.Callable() {
            @Override
            public Object call() {
                return WalleChannelReader.getChannel(MainApplication.getsInstance());
            }
        }, promise);
    }

    public ReadableMap transformToPasswordFreeMap(ReadableMap readableMap) {
        WritableMap createMap = sArgumentMapper.createMap();
        createMap.merge(readableMap);
        if (readableMap.hasKey("derivedKey") && !Strings.isNullOrEmpty(readableMap.getString("derivedKey"))) {
            String string = readableMap.getString("derivedKey");
            String bytesToHex = NumericUtil.bytesToHex(NumericUtil.generateRandomBytes(8));
            WalletManager.mustFindWalletById(readableMap.getString("id")).getKeystore().getCrypto().setCachedDerivedKey(new CachedDerivedKey(bytesToHex, NumericUtil.hexToBytes(string)));
            createMap.putString("password", bytesToHex);
        }
        return createMap;
    }
}