@subwallet/extension-base 1.3.41-0 → 1.3.43-0

package/strategy/api-request-strategy/index.js

@@ -0,0 +1,83 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { SWError } from '@subwallet/extension-base/background/errors/SWError';
+export class BaseApiRequestStrategy {
+  nextId = 0;
+  isRunning = false;
+  requestMap = {};
+  processInterval = undefined;
+  getId() {
+    return this.nextId++;
+  }
+  constructor(context) {
+    this.context = context;
+  }
+  addRequest(run, ordinal) {
+    const newId = this.getId();
+    return new Promise((resolve, reject) => {
+      this.requestMap[newId] = {
+        id: newId,
+        status: 'pending',
+        retry: -1,
+        ordinal,
+        run,
+        resolve,
+        reject
+      };
+      if (!this.isRunning) {
+        this.process();
+      }
+    });
+  }
+  process() {
+    this.stop();
+    this.isRunning = true;
+    const maxRetry = this.context.maxRetry;
+    const interval = setInterval(() => {
+      const remainingRequests = Object.values(this.requestMap);
+      if (remainingRequests.length === 0) {
+        this.isRunning = false;
+        clearInterval(interval);
+        return;
+      }
+
+      // Get first this.limit requests base on id
+      const requests = remainingRequests.filter(request => request.status !== 'running').sort((a, b) => a.id - b.id).sort((a, b) => a.ordinal - b.ordinal).slice(0, this.context.callRate);
+
+      // Start requests
+      requests.forEach(request => {
+        request.status = 'running';
+        request.run().then(rs => {
+          request.resolve(rs);
+        }).catch(e => {
+          const isRateLimited = this.isRateLimited(e);
+
+          // Limit rate
+          if (isRateLimited) {
+            if (request.retry < maxRetry) {
+              request.status = 'pending';
+              request.retry++;
+              this.context.reduceLimitRate();
+            } else {
+              // Reject request
+              request.reject(new SWError('MAX_RETRY', String(e)));
+            }
+          } else {
+            request.reject(new SWError('UNKNOWN', String(e)));
+          }
+        });
+      });
+    }, this.context.intervalCheck);
+    this.processInterval = interval;
+  }
+  stop() {
+    clearInterval(this.processInterval);
+    this.processInterval = undefined;
+  }
+  setContext(context) {
+    this.stop();
+    this.context = context;
+    this.process();
+  }
+}

package/strategy/api-request-strategy/types.d.ts

@@ -0,0 +1,22 @@
+export interface ApiRequestContext {
+    callRate: number;
+    limitRate: number;
+    intervalCheck: number;
+    maxRetry: number;
+    reduceLimitRate: () => void;
+}
+export interface ApiRequestStrategy {
+    addRequest: <T>(run: ApiRequest<T>['run'], ordinal: number) => Promise<T>;
+    setContext: (context: ApiRequestContext) => void;
+    stop: () => void;
+}
+export interface ApiRequest<T> {
+    id: number;
+    retry: number;
+    /** Serve smaller first  */
+    ordinal: number;
+    status: 'pending' | 'running';
+    run: () => Promise<any>;
+    resolve: (value: any) => T;
+    reject: (error?: any) => void;
+}

package/strategy/api-request-strategy/types.js

@@ -0,0 +1 @@
+export {};

package/strategy/api-request-strategy/utils/index.d.ts

@@ -0,0 +1,2 @@
+export declare const postRequest: (url: string, body: any, headers?: Record<string, string>, jsonBody?: boolean) => Promise<Response>;
+export declare const getRequest: (url: string, params?: Record<string, string>, headers?: Record<string, string>) => Promise<Response>;

package/strategy/api-request-strategy/utils/index.js

@@ -0,0 +1,23 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import fetch from 'cross-fetch';
+export const postRequest = (url, body, headers, jsonBody = true) => {
+  return fetch(url, {
+    method: 'POST',
+    headers: headers || {
+      'Content-Type': 'application/json'
+    },
+    body: jsonBody ? JSON.stringify(body) : body
+  });
+};
+export const getRequest = (url, params, headers) => {
+  const queryString = params ? Object.keys(params).map(key => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`).join('&') : '';
+  const _url = `${url}?${queryString}`;
+  return fetch(_url, {
+    method: 'GET',
+    headers: headers || {
+      'Content-Type': 'application/json'
+    }
+  });
+};

package/types/account/info/keyring.d.ts

@@ -116,7 +116,7 @@ export declare enum AccountChainType {
     CARDANO = "cardano"
 }
 export declare const ACCOUNT_CHAIN_TYPE_ORDINAL_MAP: Record<string, number>;
-export declare const SUPPORTED_ACCOUNT_CHAIN_TYPES: string[];
+export declare const SUPPORTED_ACCOUNT_CHAIN_TYPES: AccountChainType[];
 export declare enum AccountActions {
     DERIVE = "DERIVE",
     EXPORT_MNEMONIC = "EXPORT_MNEMONIC",

package/types/account/info/keyring.js

@@ -74,7 +74,7 @@ export const ACCOUNT_CHAIN_TYPE_ORDINAL_MAP = {
   [AccountChainType.CARDANO]: 4,
   [AccountChainType.BITCOIN]: 5
 };
-export const SUPPORTED_ACCOUNT_CHAIN_TYPES = ['substrate', 'ethereum', 'ton', 'cardano'];
+export const SUPPORTED_ACCOUNT_CHAIN_TYPES = [AccountChainType.SUBSTRATE, AccountChainType.ETHEREUM, AccountChainType.TON, AccountChainType.CARDANO, AccountChainType.BITCOIN];
 export let AccountActions;
 
 /**

package/types/balance/index.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="bn.js" />
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { _BalanceMetadata, APIItemState, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
-import { _CardanoApi, _EvmApi, _SubstrateApi, _TonApi } from '@subwallet/extension-base/services/chain-service/types';
+import { _BitcoinApi, _CardanoApi, _EvmApi, _SubstrateApi, _TonApi } from '@subwallet/extension-base/services/chain-service/types';
 import { BN } from '@polkadot/util';
 export interface TokenBalanceRaw {
     reserved: BN;
@@ -55,3 +55,6 @@ export interface SubscribeTonPalletBalance extends SubscribeBasePalletBalance {
 export interface SusbcribeCardanoPalletBalance extends SubscribeBasePalletBalance {
     cardanoApi: _CardanoApi;
 }
+export interface SusbcribeBitcoinPalletBalance extends SubscribeBasePalletBalance {
+    bitcoinApi: _BitcoinApi;
+}

package/types/balance/transfer.d.ts

@@ -1,7 +1,9 @@
+import { PsbtTransactionArg } from '@subwallet/extension-base/background/KoniTypes';
 import { BaseRequestSign } from '@subwallet/extension-base/types';
 import { FeeChainType, FeeDetail, TransactionFee } from '../fee';
 export interface RequestSubscribeTransfer extends TransactionFee {
     address: string;
+    to?: string;
     chain: string;
     value: string;
     token: string;
@@ -15,6 +17,12 @@ export interface ResponseSubscribeTransfer {
     feePercentageSpecialCase?: number;
     error?: string;
 }
+export interface RequestSubmitTransferWithId extends RequestSubmitTransfer {
+    id?: string;
+}
+export interface ResponseSubscribeTransferConfirmation extends Omit<ResponseSubscribeTransfer, 'maxTransferable'> {
+    error?: string;
+}
 export interface RequestSubmitTransfer extends BaseRequestSign, TransactionFee {
     chain: string;
     from: string;
@@ -24,3 +32,14 @@ export interface RequestSubmitTransfer extends BaseRequestSign, TransactionFee {
     value: string;
     transferBounceable?: boolean;
 }
+export interface RequestSubmitSignPsbtTransfer extends BaseRequestSign {
+    id: string;
+    chain: string;
+    from: string;
+    to: string;
+    value: string;
+    txInput: PsbtTransactionArg[];
+    txOutput: PsbtTransactionArg[];
+    tokenSlug: string;
+    psbt: string;
+}

package/types/bitcoin.d.ts

@@ -0,0 +1,93 @@
+export interface UtxoResponseItem {
+    txid: string;
+    vout: number;
+    status: {
+        confirmed: boolean;
+        block_height?: number;
+        block_hash?: string;
+        block_time?: number;
+    };
+    value: number;
+}
+export interface DetermineUtxosForSpendArgs {
+    sender: string;
+    amount: number;
+    feeRate: number;
+    recipient: string;
+    utxos: UtxoResponseItem[];
+}
+interface DetermineUtxosOutput {
+    value: number;
+    address?: string;
+}
+export interface DetermineUtxosForSpendResult {
+    filteredUtxos: UtxoResponseItem[];
+    inputs: UtxoResponseItem[];
+    outputs: DetermineUtxosOutput[];
+    size: number;
+    fee: number;
+}
+export declare class InsufficientFundsError extends Error {
+    constructor();
+}
+interface BitcoinTransactionIssuance {
+    asset_id: string;
+    is_reissuance: boolean;
+    asset_blinding_nonce: number;
+    asset_entropy: number;
+    contract_hash: string;
+    assetamount?: number;
+    assetamountcommitment?: number;
+    tokenamount?: number;
+    tokenamountcommitment?: number;
+}
+interface BitcoinTransactionPegOut {
+    genesis_hash: string;
+    scriptpubkey: string;
+    scriptpubkey_asm: string;
+    scriptpubkey_address: string;
+}
+export interface BitcoinTransactionStatus {
+    confirmed: boolean;
+    block_height?: number | null;
+    block_hash?: string | null;
+    block_time?: number | null;
+}
+export interface BitcoinTransactionVectorOutput {
+    scriptpubkey: string;
+    scriptpubkey_asm: string;
+    scriptpubkey_type: string;
+    scriptpubkey_address: string;
+    value: number;
+    valuecommitment?: number;
+    asset?: string;
+    assetcommitment?: number;
+    pegout?: BitcoinTransactionPegOut | null;
+}
+export interface BitcoinTransactionVectorInput {
+    inner_redeemscript_asm?: string;
+    inner_witnessscript_asm?: string;
+    is_coinbase: boolean;
+    is_pegin?: boolean;
+    issuance?: BitcoinTransactionIssuance | null;
+    prevout: BitcoinTransactionVectorOutput;
+    scriptsig: string;
+    scriptsig_asm: string;
+    sequence: number;
+    txid: string;
+    vout: number;
+    witness: string[];
+}
+export interface BitcoinTx {
+    fee: number;
+    locktime: number;
+    size: number;
+    status: BitcoinTransactionStatus;
+    tx_type?: string;
+    txid: string;
+    version: number;
+    vin: BitcoinTransactionVectorInput[];
+    vout: BitcoinTransactionVectorOutput[];
+    weight: number;
+}
+export {};

package/types/bitcoin.js

@@ -0,0 +1,17 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+// https://github.com/leather-wallet/extension/blob/dev/src/app/query/bitcoin/bitcoin-client.ts
+
+// https://github.com/leather-wallet/extension/blob/dev/src/app/common/transactions/bitcoin/coinselect/local-coin-selection.ts
+
+// https://github.com/leather-wallet/extension/blob/dev/src/app/common/transactions/bitcoin/coinselect/local-coin-selection.ts
+export class InsufficientFundsError extends Error {
+  constructor() {
+    super('Insufficient funds');
+  }
+}
+// Source: https://github.com/Blockstream/esplora/blob/master/API.md#transaction-format
+// ---------------
+
+// ---------------

package/types/buy.d.ts

@@ -4,7 +4,7 @@ export interface BuyService {
     symbol: string;
 }
 export declare type SupportService = 'transak' | 'banxa' | 'coinbase' | 'moonpay' | 'onramper' | 'meld';
-export declare type OnrampAccountSupportType = 'ETHEREUM' | 'SUBSTRATE';
+export declare type OnrampAccountSupportType = 'ETHEREUM' | 'SUBSTRATE' | 'TON' | 'CARDANO';
 export interface BuyTokenInfo {
     network: string;
     symbol: string;

package/types/fee/base.d.ts

@@ -1,4 +1,4 @@
-export declare type FeeChainType = 'evm' | 'substrate' | 'ton' | 'cardano';
+export declare type FeeChainType = 'evm' | 'substrate' | 'ton' | 'cardano' | 'bitcoin';
 export interface BaseFeeInfo {
     busyNetwork: boolean;
     type: FeeChainType;
@@ -6,3 +6,6 @@ export interface BaseFeeInfo {
 export interface BaseFeeDetail {
     estimatedFee: string;
 }
+export interface BaseFeeTime {
+    time: number;
+}

package/types/fee/bitcoin.d.ts

@@ -0,0 +1,18 @@
+import { BaseFeeDetail, BaseFeeInfo, BaseFeeTime } from './base';
+import { FeeDefaultOption } from './option';
+export interface BitcoinFeeRate {
+    feeRate: number;
+}
+export declare type BitcoinFeeRateDetail = BitcoinFeeRate & BaseFeeTime;
+export interface BitcoinFeeInfo extends BaseFeeInfo {
+    type: 'bitcoin';
+    options: {
+        slow: BitcoinFeeRateDetail;
+        average: BitcoinFeeRateDetail;
+        fast: BitcoinFeeRateDetail;
+        default: FeeDefaultOption;
+    };
+}
+export interface BitcoinFeeDetail extends BitcoinFeeInfo, BaseFeeDetail {
+    vSize: number;
+}

package/types/fee/bitcoin.js

@@ -0,0 +1 @@
+export {};

package/types/fee/index.d.ts

@@ -3,3 +3,4 @@ export * from './evm';
 export * from './option';
 export * from './subscription';
 export * from './substrate';
+export * from './bitcoin';

package/types/fee/index.js

@@ -5,4 +5,5 @@ export * from "./base.js";
 export * from "./evm.js";
 export * from "./option.js";
 export * from "./subscription.js";
-export * from "./substrate.js";
+export * from "./substrate.js";
+export * from "./bitcoin.js";

package/types/fee/subscription.d.ts

@@ -1,11 +1,12 @@
+import { BitcoinFeeDetail, BitcoinFeeInfo, BitcoinFeeRate } from '@subwallet/extension-base/types';
 import { BehaviorSubject } from 'rxjs';
 import { CardanoFeeDetail, CardanoFeeInfo, CardanoTipInfo } from './cardano';
 import { EvmEIP1559FeeOption, EvmFeeDetail, EvmFeeInfo } from './evm';
 import { SubstrateFeeDetail, SubstrateFeeInfo, SubstrateTipInfo } from './substrate';
 import { TonFeeDetail, TonFeeInfo, TonTipInfo } from './ton';
-export declare type FeeInfo = EvmFeeInfo | SubstrateFeeInfo | TonFeeInfo | CardanoFeeInfo;
-export declare type FeeDetail = EvmFeeDetail | SubstrateFeeDetail | TonFeeDetail | CardanoFeeDetail;
-export declare type FeeCustom = EvmEIP1559FeeOption | SubstrateTipInfo | TonTipInfo | CardanoTipInfo;
+export declare type FeeInfo = EvmFeeInfo | SubstrateFeeInfo | TonFeeInfo | CardanoFeeInfo | BitcoinFeeInfo;
+export declare type FeeDetail = EvmFeeDetail | SubstrateFeeDetail | TonFeeDetail | CardanoFeeDetail | BitcoinFeeDetail;
+export declare type FeeCustom = EvmEIP1559FeeOption | SubstrateTipInfo | TonTipInfo | CardanoTipInfo | BitcoinFeeRate;
 export interface FeeSubscription {
     observer: BehaviorSubject<FeeInfo | undefined>;
     subscription: Record<string, VoidFunction>;

package/types/index.d.ts

@@ -23,3 +23,4 @@ export * from './swap';
 export * from './transaction';
 export * from './yield';
 export * from './setting';
+export * from './bitcoin';

package/types/index.js

@@ -16,4 +16,5 @@ export * from "./swap/index.js";
 export * from "./transaction/index.js";
 export * from "./yield/index.js";
 export * from "./setting.js";
+export * from "./bitcoin.js";
 export {};

package/utils/account/analyze.js

@@ -2,8 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { resolveAzeroAddressToDomain, resolveAzeroDomainToAddress } from '@subwallet/extension-base/koni/api/dotsama/domain';
-import { _chainInfoToChainType, _getChainSubstrateAddressPrefix } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getChainSubstrateAddressPrefix, _isChainInfoCompatibleWithAccountInfo } from '@subwallet/extension-base/services/chain-service/utils';
 import { AccountChainType, AnalyzedGroup } from '@subwallet/extension-base/types';
+import { getKeypairTypeByAddress } from '@subwallet/keyring';
 import { isAddress } from '@polkadot/util-crypto';
 import { _reformatAddressWithChain, reformatAddress } from "./common.js";
 // TODO: Re-confirm to compare without
@@ -51,14 +52,13 @@ export const _analyzeAddress = async (data, accountProxies, contacts, chainInfo,
   const chain = chainInfo.slug;
   const _data = data.trim().toLowerCase();
   const options = [];
-  const currentChainType = _chainInfoToChainType(chainInfo);
   let current;
 
   // Filter account proxies
   for (const accountProxy of accountProxies) {
     const _name = accountProxy.name.trim().toLowerCase();
     const nameCondition = isNameValid(_data, _name);
-    const filterAccounts = accountProxy.accounts.filter(account => account.chainType === currentChainType);
+    const filterAccounts = accountProxy.accounts.filter(account => _isChainInfoCompatibleWithAccountInfo(chainInfo, account.chainType, account.type));
     for (const account of filterAccounts) {
       const addressCondition = isStrValidWithAddress(_data, account, chainInfo);
       const condition = nameCondition !== 'invalid' ? nameCondition : addressCondition;
@@ -86,7 +86,7 @@ export const _analyzeAddress = async (data, accountProxies, contacts, chainInfo,
       }
     }
   }
-  const filterContacts = contacts.filter(contact => contact.chainType === currentChainType);
+  const filterContacts = contacts.filter(contact => _isChainInfoCompatibleWithAccountInfo(chainInfo, contact.chainType, getKeypairTypeByAddress(contact.address)));
 
   // Filter address book addresses
   for (const contact of filterContacts) {

package/utils/account/common.d.ts

@@ -6,15 +6,14 @@ export declare function isAccountAll(address?: string): boolean;
 export declare function reformatAddress(address: string, networkPrefix?: number, isEthereum?: boolean): string;
 export declare const _reformatAddressWithChain: (address: string, chainInfo: _ChainInfo) => string;
 export declare const getAccountChainTypeForAddress: (address: string) => AccountChainType;
-interface AddressesByChainType {
-    [ChainType.SUBSTRATE]: string[];
-    [ChainType.EVM]: string[];
-    [ChainType.BITCOIN]: string[];
-    [ChainType.TON]: string[];
-    [ChainType.CARDANO]: string[];
+declare type AddressesByChainType = {
+    [key in ChainType]: string[];
+};
+interface ExtendAddressesByChainType extends AddressesByChainType {
+    _bitcoin: string[];
 }
-export declare function getAddressesByChainType(addresses: string[], chainTypes: ChainType[]): string[];
-export declare function getAddressesByChainTypeMap(addresses: string[]): AddressesByChainType;
+export declare function getAddressesByChainType(addresses: string[], chainTypes: ChainType[], chainInfo?: _ChainInfo): string[];
+export declare function getAddressesByChainTypeMap(addresses: string[], chainInfo?: _ChainInfo): ExtendAddressesByChainType;
 export declare function quickFormatAddressToCompare(address?: string): string | undefined;
 /** @deprecated */
 export declare const modifyAccountName: (type: KeypairType, name: string, modify: boolean) => string;

package/utils/account/common.js

@@ -1,12 +1,12 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { ChainType } from '@subwallet/extension-base/background/KoniTypes';
 import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
 import { _chainInfoToChainType, _getChainSubstrateAddressPrefix } from '@subwallet/extension-base/services/chain-service/utils';
 import { AccountChainType } from '@subwallet/extension-base/types';
 import { getAccountChainTypeFromKeypairType } from '@subwallet/extension-base/utils';
 import { decodeAddress, encodeAddress, getKeypairTypeByAddress, isAddress, isBitcoinAddress, isCardanoAddress, isTonAddress } from '@subwallet/keyring';
+import { getBitcoinAddressInfo } from '@subwallet/keyring/utils/address/validate';
 import { ethereumEncode, isEthereumAddress } from '@polkadot/util-crypto';
 export function isAccountAll(address) {
   return address === ALL_ACCOUNT_KEY;
@@ -52,20 +52,22 @@ export const getAccountChainTypeForAddress = address => {
   const type = getKeypairTypeByAddress(address);
   return getAccountChainTypeFromKeypairType(type);
 };
-export function getAddressesByChainType(addresses, chainTypes) {
-  const addressByChainTypeMap = getAddressesByChainTypeMap(addresses);
+// TODO: Recheck the usage of this function for Bitcoin; it is currently applied to history.
+export function getAddressesByChainType(addresses, chainTypes, chainInfo) {
+  const addressByChainTypeMap = getAddressesByChainTypeMap(addresses, chainInfo);
   return chainTypes.map(chainType => {
     return addressByChainTypeMap[chainType];
   }).flat(); // todo: recheck
 }
 
-export function getAddressesByChainTypeMap(addresses) {
+export function getAddressesByChainTypeMap(addresses, chainInfo) {
   const addressByChainType = {
     substrate: [],
     evm: [],
     bitcoin: [],
     ton: [],
-    cardano: []
+    cardano: [],
+    _bitcoin: []
   };
   addresses.forEach(address => {
     if (isEthereumAddress(address)) {
@@ -73,7 +75,15 @@ export function getAddressesByChainTypeMap(addresses) {
     } else if (isTonAddress(address)) {
       addressByChainType.ton.push(address);
     } else if (isBitcoinAddress(address)) {
-      addressByChainType.bitcoin.push(address);
+      const addressInfo = getBitcoinAddressInfo(address);
+      if (chainInfo !== null && chainInfo !== void 0 && chainInfo.bitcoinInfo) {
+        const isNetworkMatch = addressInfo.network === chainInfo.bitcoinInfo.bitcoinNetwork;
+        if (isNetworkMatch) {
+          addressByChainType.bitcoin.push(address);
+        } else {
+          addressByChainType._bitcoin.push(address);
+        }
+      }
     } else if (isCardanoAddress(address)) {
       addressByChainType.cardano.push(address);
     } else {