@subwallet/extension-base 0.8.1-wr → 0.8.1-wr2x

package/stores/AccountRef.js

@@ -0,0 +1,10 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { EXTENSION_PREFIX } from '@subwallet/extension-base/defaults';
+import SubscribableStore from '@subwallet/extension-base/stores/SubscribableStore';
+export default class AccountRefStore extends SubscribableStore {
+  constructor() {
+    super(EXTENSION_PREFIX ? `${EXTENSION_PREFIX}account_link` : null);
+  }
+}

package/stores/Accounts.d.ts

@@ -1,4 +1,4 @@
-import type { KeyringJson, KeyringStore } from '@polkadot/ui-keyring/types';
+import type { KeyringJson, KeyringStore } from '@subwallet/ui-keyring/types';
 import BaseStore from './Base';
 export default class AccountsStore extends BaseStore<KeyringJson> implements KeyringStore {
     constructor();

package/stores/Application.d.ts

@@ -0,0 +1,7 @@
+import { ApplicationMetadataType } from '@subwallet/extension-base/background/KoniTypes';
+import SubscribableStore from '@subwallet/extension-base/stores/SubscribableStore';
+export default class ApplicationStore extends SubscribableStore<ApplicationMetadataType> {
+    constructor();
+    getVersion(): Promise<string>;
+    setVersion(version: string): Promise<void>;
+}

package/stores/Application.js

@@ -0,0 +1,20 @@
+// Copyright 2019-2022 @subwallet/extension-koni-ui authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { EXTENSION_PREFIX } from '@subwallet/extension-base/defaults';
+import SubscribableStore from '@subwallet/extension-base/stores/SubscribableStore';
+const APPLICATION_METADATA_KEY = 'application';
+export default class ApplicationStore extends SubscribableStore {
+  constructor() {
+    super(EXTENSION_PREFIX);
+  }
+  async getVersion() {
+    const meta = await this.asyncGet(APPLICATION_METADATA_KEY);
+    return meta === null || meta === void 0 ? void 0 : meta.version;
+  }
+  async setVersion(version) {
+    const meta = (await this.asyncGet(APPLICATION_METADATA_KEY)) || {};
+    meta.version = version;
+    return this.set(APPLICATION_METADATA_KEY, meta);
+  }
+}

package/stores/AssetSetting.d.ts

@@ -0,0 +1,5 @@
+import { AssetSetting } from '@subwallet/extension-base/background/KoniTypes';
+import SubscribableStore from '@subwallet/extension-base/stores/SubscribableStore';
+export default class AssetSettingStore extends SubscribableStore<Record<string, AssetSetting>> {
+    constructor();
+}

package/stores/AssetSetting.js

@@ -0,0 +1,12 @@
+// Copyright 2019-2022 @polkadot/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { EXTENSION_PREFIX } from '@subwallet/extension-base/defaults';
+import SubscribableStore from '@subwallet/extension-base/stores/SubscribableStore';
+
+// Not every asset has its setting stored, if not in store then it has default value (visible = false)
+export default class AssetSettingStore extends SubscribableStore {
+  constructor() {
+    super(EXTENSION_PREFIX ? `${EXTENSION_PREFIX}asset-setting` : null);
+  }
+}

package/stores/Authorize.d.ts

@@ -0,0 +1,5 @@
+import { AuthUrls } from '@subwallet/extension-base/background/handlers/State';
+import SubscribableStore from '@subwallet/extension-base/stores/SubscribableStore';
+export default class AuthorizeStore extends SubscribableStore<AuthUrls> {
+    constructor();
+}

package/stores/Authorize.js

@@ -0,0 +1,10 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { EXTENSION_PREFIX } from '@subwallet/extension-base/defaults';
+import SubscribableStore from '@subwallet/extension-base/stores/SubscribableStore';
+export default class AuthorizeStore extends SubscribableStore {
+  constructor() {
+    super(EXTENSION_PREFIX ? `${EXTENSION_PREFIX}authorize` : null);
+  }
+}

package/stores/CurrentAccountStore.d.ts

@@ -0,0 +1,5 @@
+import { CurrentAccountInfo } from '@subwallet/extension-base/background/KoniTypes';
+import SubscribableStore from '@subwallet/extension-base/stores/SubscribableStore';
+export default class CurrentAccountStore extends SubscribableStore<CurrentAccountInfo> {
+    constructor();
+}

package/stores/CurrentAccountStore.js

@@ -0,0 +1,10 @@
+// Copyright 2019-2022 @subwallet/extension-koni-ui authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { EXTENSION_PREFIX } from '@subwallet/extension-base/defaults';
+import SubscribableStore from '@subwallet/extension-base/stores/SubscribableStore';
+export default class CurrentAccountStore extends SubscribableStore {
+  constructor() {
+    super(EXTENSION_PREFIX ? `${EXTENSION_PREFIX}current_account` : null);
+  }
+}

package/stores/Keyring.d.ts

@@ -0,0 +1,7 @@
+import type { KeyringPasswordJson } from '@subwallet/keyring/types';
+import type { PasswordStore } from '@subwallet/ui-keyring/types';
+export default class KeyringStore implements PasswordStore {
+    get(update: (value: KeyringPasswordJson) => void): void;
+    remove(update?: () => void): void;
+    set(value: KeyringPasswordJson, update?: () => void): void;
+}

package/stores/Keyring.js

@@ -0,0 +1,32 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { SUBWALLET_KEYRING } from '@subwallet/ui-keyring/defaults';
+const lastError = type => {
+  const error = chrome.runtime.lastError;
+  if (error) {
+    console.error(`KeyringStore.${type}:: runtime.lastError:`, error);
+  }
+};
+export default class KeyringStore {
+  get(update) {
+    chrome.storage.local.get([SUBWALLET_KEYRING], result => {
+      lastError('get');
+      update(result[SUBWALLET_KEYRING]);
+    });
+  }
+  remove(update) {
+    chrome.storage.local.remove(SUBWALLET_KEYRING, () => {
+      lastError('remove');
+      update && update();
+    });
+  }
+  set(value, update) {
+    chrome.storage.local.set({
+      [SUBWALLET_KEYRING]: value
+    }, () => {
+      lastError('set');
+      update && update();
+    });
+  }
+}

package/stores/Settings.d.ts

@@ -0,0 +1,5 @@
+import { RequestSettingsType } from '@subwallet/extension-base/background/KoniTypes';
+import SubscribableStore from '@subwallet/extension-base/stores/SubscribableStore';
+export default class SettingsStore extends SubscribableStore<RequestSettingsType> {
+    constructor();
+}

package/stores/Settings.js

@@ -0,0 +1,10 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { EXTENSION_PREFIX } from '@subwallet/extension-base/defaults';
+import SubscribableStore from '@subwallet/extension-base/stores/SubscribableStore';
+export default class SettingsStore extends SubscribableStore {
+  constructor() {
+    super(EXTENSION_PREFIX ? `${EXTENSION_PREFIX}settings` : null);
+  }
+}

package/stores/SubscribableStore.d.ts

@@ -0,0 +1,9 @@
+import BaseStore from '@subwallet/extension-base/stores/Base';
+import { Subject } from 'rxjs';
+export default abstract class SubscribableStore<T> extends BaseStore<T> {
+    private readonly subject;
+    getSubject(): Subject<T>;
+    set(_key: string, value: T, update?: () => void): void;
+    asyncGet: (key: string) => Promise<T>;
+    removeAll(): void;
+}

package/stores/SubscribableStore.js

@@ -0,0 +1,25 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseStore from '@subwallet/extension-base/stores/Base';
+import { Subject } from 'rxjs';
+export default class SubscribableStore extends BaseStore {
+  subject = new Subject();
+  getSubject() {
+    return this.subject;
+  }
+  set(_key, value, update) {
+    super.set(_key, value, () => {
+      this.subject.next(value);
+      update && update();
+    });
+  }
+  asyncGet = async key => {
+    return new Promise(resolve => {
+      this.get(key, resolve);
+    });
+  };
+  removeAll() {
+    return this.all(key => this.remove(key));
+  }
+}

package/stores/TransactionHistory.d.ts

@@ -0,0 +1,6 @@
+import { TxHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
+import SubscribableStore from '@subwallet/extension-base/stores/SubscribableStore';
+export default class TransactionHistoryStore extends SubscribableStore<TxHistoryItem[]> {
+    constructor();
+    getByMultiKeys(_keys: string[], update: (value: TxHistoryItem[]) => void): void;
+}

package/stores/TransactionHistory.js

@@ -0,0 +1,29 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { EXTENSION_PREFIX } from '@subwallet/extension-base/defaults';
+import SubscribableStore from '@subwallet/extension-base/stores/SubscribableStore';
+const lastError = type => {
+  const error = chrome.runtime.lastError;
+  if (error) {
+    console.error(`TransactionHistoryStore.${type}:: runtime.lastError:`, error);
+  }
+};
+export default class TransactionHistoryStore extends SubscribableStore {
+  constructor() {
+    super(EXTENSION_PREFIX ? `${EXTENSION_PREFIX}transaction_history` : null);
+  }
+  getByMultiKeys(_keys, update) {
+    const keys = _keys.map(k => `${this.getPrefix()}${k}`);
+    chrome.storage.local.get(keys, result => {
+      lastError('getByMultiKey');
+      const items = [];
+      keys.forEach(k => {
+        if (result[k]) {
+          items.push(...result[k]);
+        }
+      });
+      update(items);
+    });
+  }
+}

package/stores/TransactionHistoryV2.d.ts

@@ -0,0 +1,5 @@
+import { TxHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
+import SubscribableStore from '@subwallet/extension-base/stores/SubscribableStore';
+export default class TransactionHistoryStoreV2 extends SubscribableStore<Record<string, TxHistoryItem[]>> {
+    constructor();
+}

package/stores/TransactionHistoryV2.js

@@ -0,0 +1,10 @@
+// Copyright 2019-2022 @subwallet/extension-koni-ui authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { EXTENSION_PREFIX } from '@subwallet/extension-base/defaults';
+import SubscribableStore from '@subwallet/extension-base/stores/SubscribableStore';
+export default class TransactionHistoryStoreV2 extends SubscribableStore {
+  constructor() {
+    super(`${EXTENSION_PREFIX}transaction`);
+  }
+}

package/stores/TransactionHistoryV3.d.ts

@@ -0,0 +1,5 @@
+import { TransactionHistoryItemJson } from '@subwallet/extension-base/background/KoniTypes';
+import SubscribableStore from '@subwallet/extension-base/stores/SubscribableStore';
+export default class TransactionHistoryStoreV3 extends SubscribableStore<Record<string, TransactionHistoryItemJson>> {
+    constructor();
+}

package/stores/TransactionHistoryV3.js

@@ -0,0 +1,10 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { EXTENSION_PREFIX } from '@subwallet/extension-base/defaults';
+import SubscribableStore from '@subwallet/extension-base/stores/SubscribableStore';
+export default class TransactionHistoryStoreV3 extends SubscribableStore {
+  constructor() {
+    super(`${EXTENSION_PREFIX}transaction3`);
+  }
+}

package/stores/index.d.ts

@@ -1,2 +1,3 @@
 export { default as AccountsStore } from './Accounts';
 export { default as MetadataStore } from './Metadata';
+export { default as CurrentAccountStore } from './CurrentAccountStore';

package/stores/index.js

@@ -2,4 +2,5 @@
 // SPDX-License-Identifier: Apache-2.0
 
 export { default as AccountsStore } from "./Accounts.js";
-export { default as MetadataStore } from "./Metadata.js";
+export { default as MetadataStore } from "./Metadata.js";
+export { default as CurrentAccountStore } from "./CurrentAccountStore.js";

package/utils/address.d.ts

@@ -0,0 +1 @@
+export declare const simpleAddress: (address: string) => string;

package/utils/address.js

@@ -0,0 +1,10 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { decodeAddress, encodeAddress, isEthereumAddress } from '@polkadot/util-crypto';
+export const simpleAddress = address => {
+  if (isEthereumAddress(address)) {
+    return address;
+  }
+  return encodeAddress(decodeAddress(address));
+};

package/utils/eth/mergeTransactionAndSignature.d.ts

@@ -0,0 +1,2 @@
+import { Web3Transaction } from '@subwallet/extension-base/signers/types';
+export declare const parseTxAndSignature: (tx: Web3Transaction, _signature: `0x${string}`) => `0x${string}`;

package/utils/eth/mergeTransactionAndSignature.js

@@ -0,0 +1,14 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import RLP from 'rlp';
+import { u8aToHex } from '@polkadot/util';
+export const parseTxAndSignature = (tx, _signature) => {
+  const signature = _signature.slice(2);
+  const r = `0x${signature.substring(0, 64)}`;
+  const s = `0x${signature.substring(64, 128)}`;
+  const v = `0x${signature.substring(128)}`;
+  const data = [tx.nonce, tx.gasPrice, tx.gasLimit, tx.to, tx.value, tx.data, v, r, s];
+  const encoded = RLP.encode(data);
+  return u8aToHex(encoded);
+};

package/utils/eth/parseTransaction/base.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import { NestedArray } from '@subwallet/extension-base/background/KoniTypes';
+import { Buffer } from 'buffer';
+import { AbiItem } from 'web3-utils';
+export interface InputData {
+    method: string | null;
+    methodName: string | null;
+    types: string[];
+    inputs: NestedArray<any>[];
+    names: NestedArray<string>[];
+}
+export declare class InputDataDecoder {
+    readonly abi: AbiItem[];
+    constructor(prop: string | AbiItem[] | any);
+    decodeConstructor(data: Buffer | string): InputData;
+    decodeData(data: Buffer | string): InputData;
+}

package/utils/eth/parseTransaction/base.js

@@ -0,0 +1,273 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { Buffer } from 'buffer';
+import { ethers } from 'ethers';
+import isBuffer from 'is-buffer';
+// @ts-ignore
+import { _jsonInterfaceMethodToString, keccak256 } from 'web3-utils';
+const ABI_TYPES = ['function', 'constructor', 'event', 'fallback'];
+const instanceOfAbiItem = object => {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-member-access
+  return 'type' in object && ABI_TYPES.includes(object.type);
+};
+const checkArrayAbiItems = data => {
+  if (Array.isArray(data)) {
+    return data.length > 0 && data.every(value => instanceOfAbiItem(value));
+  } else {
+    return false;
+  }
+};
+const genType = type => {
+  if (typeof type === 'string') {
+    return type;
+  } else {
+    if (type.components) {
+      var _type$components;
+      const arr = (_type$components = type.components) === null || _type$components === void 0 ? void 0 : _type$components.map(genType);
+      const tupleStr = `(${arr.join(',')})`;
+      if (type.type === 'tuple[]') {
+        return tupleStr + '[]';
+      } else {
+        return tupleStr;
+      }
+    } else {
+      return type.type;
+    }
+  }
+};
+const getMethodId = abi => {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-call
+  return keccak256(_jsonInterfaceMethodToString(abi)).slice(2, 10);
+};
+const getMethodName = abi => {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-call
+  return _jsonInterfaceMethodToString(abi);
+};
+const deepRemoveUnwantedArrayProperties = arr => {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-return
+  return [...arr.map(item => {
+    if (Array.isArray(item)) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      return deepRemoveUnwantedArrayProperties(item);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return item;
+  })];
+};
+
+// remove 0x from addresses
+const deepStripTupleAddresses = (input, tupleTypes) => input.map((item, i) => {
+  // We find tupleTypes to not be an array where internalType is present in the ABI indicating item is a structure
+  const type = tupleTypes[i] ? tupleTypes[i].type : null;
+  if (type === 'address' && typeof item === 'string') {
+    return item;
+  }
+  if (type === 'address[]' && Array.isArray(item)) {
+    return item.map(a => a);
+  }
+  if (Array.isArray(item)) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return deepStripTupleAddresses(item, tupleTypes);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  return item;
+});
+const toHexString = byteArray => {
+  return Array.from(byteArray, function (byte) {
+    return ('0' + (byte & 0xFF).toString(16)).slice(-2);
+  }).join('');
+};
+export class InputDataDecoder {
+  constructor(prop) {
+    this.abi = [];
+    if (typeof prop === 'string') {
+      try {
+        this.abi = JSON.parse(prop);
+      } catch (err) {
+        throw new Error(`Invalid ABI: ${err.message}`);
+      }
+    } else if (checkArrayAbiItems(prop)) {
+      this.abi = prop;
+    } else {
+      throw new TypeError('Must pass ABI array object or file path to constructor');
+    }
+  }
+  decodeConstructor(data) {
+    if (isBuffer(data)) {
+      data = data.toString('utf8');
+    }
+    if (typeof data !== 'string') {
+      data = '';
+    }
+    data = data.trim();
+    for (let i = 0; i < this.abi.length; i++) {
+      const obj = this.abi[i];
+      if (obj.type !== 'constructor') {
+        continue;
+      }
+      const method = obj.name || null;
+      const methodName = getMethodName(obj);
+      const types = obj.inputs ? obj.inputs.map(x => x.type) : [];
+      const names = obj.inputs ? obj.inputs.map(x => x.name) : [];
+
+      // take last 32 bytes
+      data = data.slice(-256);
+      if (data.length !== 256) {
+        throw new Error('fail');
+      }
+      if (data.indexOf('0x') !== 0) {
+        data = `0x${data}`;
+      }
+      const _inputs = ethers.utils.defaultAbiCoder.decode(types, data);
+      const inputs = deepRemoveUnwantedArrayProperties(_inputs);
+      return {
+        methodName,
+        method,
+        types,
+        inputs,
+        names
+      };
+    }
+    throw new Error('not found');
+  }
+  decodeData(data) {
+    if (isBuffer(data)) {
+      data = data.toString('utf8');
+    }
+    if (typeof data !== 'string') {
+      data = '';
+    }
+    data = data.trim();
+    const dataBuf = Buffer.from(data.replace(/^0x/, ''), 'hex');
+    const methodId = toHexString(dataBuf.subarray(0, 4));
+    const inputsBuf = dataBuf.subarray(4);
+    let result = {
+      method: null,
+      methodName: null,
+      types: [],
+      inputs: [],
+      names: []
+    };
+    for (const abi of this.abi) {
+      try {
+        if (abi.type === 'constructor') {
+          continue;
+        }
+        if (abi.type === 'event') {
+          continue;
+        }
+        const method = abi.name || null;
+        const methodName = getMethodName(abi);
+        const types = abi.inputs ? abi.inputs.map(x => {
+          if (x.type.includes('tuple')) {
+            return x;
+          } else {
+            return x.type;
+          }
+        }) : [];
+        const names = abi.inputs ? abi.inputs.map(x => {
+          if (x.type.includes('tuple') && x.components) {
+            return [x.name, x.components.map(a => a.name)];
+          } else {
+            return x.name;
+          }
+        }) : [];
+        const hash = getMethodId(abi);
+        if (hash === methodId) {
+          let inputs = [];
+          try {
+            // @ts-ignore
+            inputs = ethers.utils.defaultAbiCoder.decode(types, inputsBuf);
+          } catch (err) {
+            try {
+              const ifc = new ethers.utils.Interface([]);
+              inputs = ifc.decodeFunctionData(ethers.utils.FunctionFragment.fromObject(abi), data);
+            } catch (err) {}
+          }
+
+          // TODO: do this normalization into normalizeAddresses
+          let _inputs = [];
+          _inputs = inputs.map((input, i) => {
+            if (types[i].components) {
+              const tupleTypes = types[i].components;
+
+              // eslint-disable-next-line @typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-argument
+              return deepStripTupleAddresses(input, tupleTypes);
+            }
+            if (types[i] === 'address' && typeof input === 'string') {
+              return input;
+            }
+            if (types[i] === 'address[]' && Array.isArray(input)) {
+              return input.map(address => address);
+            }
+
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return input;
+          });
+
+          // Map any tuple types into arrays
+          const typesToReturn = types.map(genType);
+
+          // defaultAbiCoder attaches some unwanted properties to the list object
+          _inputs = deepRemoveUnwantedArrayProperties(_inputs);
+          result = {
+            methodName,
+            method,
+            types: typesToReturn,
+            inputs: _inputs,
+            names
+          };
+        }
+      } catch (err) {
+        console.log(err);
+      }
+    }
+    if (!result.method) {
+      for (const obj of this.abi) {
+        if (obj.type === 'constructor') {
+          continue;
+        }
+        if (obj.type === 'event') {
+          continue;
+        }
+        const method = obj.name || null;
+        try {
+          const ifc = new ethers.utils.Interface([]);
+          const _result = ifc.decodeFunctionData(ethers.utils.FunctionFragment.fromObject(obj), data);
+          const inputs = deepRemoveUnwantedArrayProperties(_result);
+          result.method = method;
+          result.methodName = getMethodName(obj);
+          result.inputs = inputs;
+          result.names = obj.inputs ? obj.inputs.map(x => {
+            if (x.type.includes('tuple')) {
+              var _x$components;
+              return [x.name, ((_x$components = x.components) === null || _x$components === void 0 ? void 0 : _x$components.map(a => a.name)) || ''];
+            } else {
+              return x.name;
+            }
+          }) : [];
+          const types = obj.inputs ? obj.inputs.map(x => {
+            if (x.type.includes('tuple')) {
+              return x;
+            } else {
+              return x.type;
+            }
+          }) : [];
+          result.types = types.map(genType);
+        } catch (err) {}
+      }
+    }
+    if (!result.method) {
+      try {
+        const decoded = this.decodeConstructor(data);
+        if (decoded) {
+          return decoded;
+        }
+      } catch (err) {}
+    }
+    return result;
+  }
+}

package/utils/eth/parseTransaction/index.d.ts

@@ -0,0 +1,6 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { ResponseParseEvmContractInput, ResponseQrParseRLP } from '@subwallet/extension-base/background/KoniTypes';
+import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
+export declare const isContractAddress: (address: string, evmApi: _EvmApi) => Promise<boolean>;
+export declare const parseContractInput: (input: string, contractAddress: string, network: _ChainInfo | null) => Promise<ResponseParseEvmContractInput>;
+export declare const parseEvmRlp: (data: string, networkMap: Record<string, _ChainInfo>, evmApiMap: Record<string, _EvmApi>) => Promise<ResponseQrParseRLP>;