@subwallet/extension-base 1.3.35-0 → 1.3.37-0

package/services/transaction-service/index.js

@@ -200,6 +200,22 @@ export default class TransactionService {
       extrinsicHash: transactionId
     };
   }
+  fillDutchTransactionDefaultInfo(transaction) {
+    const isInternal = !transaction.url;
+    const transactionId = getTransactionId(transaction.chainType, transaction.chain, isInternal, isWalletConnectRequest(transaction.id));
+    return {
+      ...transaction,
+      createdAt: new Date().getTime(),
+      updatedAt: new Date().getTime(),
+      errors: transaction.errors || [],
+      warnings: transaction.warnings || [],
+      url: transaction.url || EXTENSION_REQUEST_URL,
+      status: ExtrinsicStatus.QUEUED,
+      isInternal,
+      id: transactionId,
+      extrinsicHash: transactionId
+    };
+  }
   async addTransaction(inputTransaction) {
     const transactions = this.transactions;
     // Fill transaction default info
@@ -212,6 +228,15 @@ export default class TransactionService {
     });
     return await this.sendTransaction(transaction);
   }
+  addDutchTransaction(inputTransaction) {
+    const transactions = this.transactions;
+    const transaction = this.fillDutchTransactionDefaultInfo(inputTransaction);
+    transactions[transaction.id] = transaction;
+    this.transactionSubject.next({
+      ...transactions
+    });
+    return this.sendDutchTransaction(transaction);
+  }
   generateBeforeHandleResponseErrors(errors) {
     return {
       errors,
@@ -327,6 +352,62 @@ export default class TransactionService {
     'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
     return validatedTransaction;
   }
+  async handleDutchTransaction(transaction) {
+    var _transaction$step2;
+    const transactionId = getTransactionId(transaction.chainType, transaction.chain, true);
+    const validatedTransaction = {
+      ...transaction,
+      id: transactionId,
+      extrinsicHash: '',
+      status: undefined,
+      errors: transaction.errors || [],
+      warnings: transaction.warnings || [],
+      processId: (_transaction$step2 = transaction.step) === null || _transaction$step2 === void 0 ? void 0 : _transaction$step2.processId
+    };
+    const txInput = {
+      ...transaction,
+      isInternal: true,
+      status: ExtrinsicStatus.QUEUED,
+      id: transactionId,
+      extrinsicHash: transactionId,
+      createdAt: new Date().getTime(),
+      updatedAt: new Date().getTime()
+    };
+    const emitter = this.addDutchTransaction(txInput);
+    await new Promise(resolve => {
+      if (transaction.resolveOnDone) {
+        emitter.on('success', data => {
+          validatedTransaction.id = data.id;
+          validatedTransaction.extrinsicHash = data.extrinsicHash;
+          resolve();
+        });
+      } else {
+        emitter.on('signed', data => {
+          validatedTransaction.id = data.id;
+          validatedTransaction.extrinsicHash = data.extrinsicHash;
+          resolve();
+        });
+      }
+      emitter.on('error', data => {
+        if (data.errors.length > 0) {
+          validatedTransaction.errors.push(...data.errors);
+          resolve();
+        }
+      });
+      emitter.on('timeout', data => {
+        if (transaction.errorOnTimeOut && data.errors.length > 0) {
+          validatedTransaction.errors.push(...data.errors);
+          resolve();
+        }
+      });
+    });
+
+    // @ts-ignore
+    'transaction' in validatedTransaction && delete validatedTransaction.transaction;
+    'additionalValidator' in validatedTransaction && delete validatedTransaction.additionalValidator;
+    'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
+    return validatedTransaction;
+  }
   async sendTransaction(transaction) {
     // Send Transaction
     const emitter = await (transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : transaction.chainType === 'evm' ? this.signAndSendEvmTransaction(transaction) : transaction.chainType === 'cardano' ? this.signAndSendCardanoTransaction(transaction) : this.signAndSendTonTransaction(transaction));
@@ -374,10 +455,7 @@ export default class TransactionService {
       if (step) {
         const rejectError = data.errors.find(error => {
           // TODO: REFACTOR ERROR CODE
-          if ([BasicTxErrorType.UNABLE_TO_SIGN, BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType)) {
-            return true;
-          }
-          return false;
+          return [BasicTxErrorType.UNABLE_TO_SIGN, BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType);
         });
 
         /**
@@ -450,10 +528,73 @@ export default class TransactionService {
       if (step) {
         const rejectError = data.errors.find(error => {
           // TODO: REFACTOR ERROR CODE
-          if ([BasicTxErrorType.UNABLE_TO_SIGN, BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType)) {
-            return true;
-          }
-          return false;
+          return [BasicTxErrorType.UNABLE_TO_SIGN, BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType);
+        });
+
+        /**
+         * Now simple check, first step have step id = 1.
+         * Improve to fetch the process from db
+         * */
+        if (rejectError && step.stepId === 1) {
+          this.deleteProcess(step);
+        } else {
+          this.updateProcessStepStatus(step, {
+            status: StepStatus.FAILED
+          });
+        }
+      }
+    });
+
+    // Todo: handle any event with transaction.eventsHandler
+
+    eventsHandler === null || eventsHandler === void 0 ? void 0 : eventsHandler(emitter);
+    return emitter;
+  }
+  sendDutchTransaction(transaction) {
+    // Send Transaction
+    const emitter = this.signAndSendEvmDutchTransaction(transaction);
+    const {
+      eventsHandler,
+      step
+    } = transaction;
+    emitter.on('send', data => {
+      this.onSend(data);
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          transactionId: transaction.id,
+          status: StepStatus.SUBMITTING,
+          chain: transaction.chain
+        });
+      }
+    });
+    emitter.on('extrinsicHash', data => {
+      this.onHasTransactionHash(data);
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          extrinsicHash: data.extrinsicHash,
+          status: StepStatus.PROCESSING
+        });
+      }
+    });
+    emitter.on('success', data => {
+      this.handlePostProcessing(data.id);
+      this.onSuccess(data);
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          status: StepStatus.COMPLETE
+        });
+      }
+    });
+    emitter.on('error', data => {
+      // this.handlePostProcessing(data.id); // might enable this later
+      this.onFailed({
+        ...data,
+        errors: [...data.errors, new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]
+      });
+      if (step) {
+        const rejectError = data.errors.find(error => {
+          // TODO: REFACTOR ERROR CODE
+          return [BasicTxErrorType.UNABLE_TO_SIGN, BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType);
         });
 
         /**
@@ -469,6 +610,17 @@ export default class TransactionService {
         }
       }
     });
+    emitter.on('timeout', data => {
+      this.onTimeOut({
+        ...data,
+        errors: [...data.errors, new TransactionError(BasicTxErrorType.TIMEOUT)]
+      });
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          status: StepStatus.TIMEOUT
+        });
+      }
+    });
 
     // Todo: handle any event with transaction.eventsHandler
 
@@ -498,7 +650,7 @@ export default class TransactionService {
     return getExplorerLink(chainInfo, transaction.extrinsicHash, 'tx');
   }
   transactionToHistories(id, startBlock, nonce, eventLogs) {
-    var _transaction$step2;
+    var _transaction$step3;
     const transaction = this.getTransaction(id);
     const extrinsicType = transaction.extrinsicType;
     const chainInfo = this.state.chainService.getChainInfoByKey(transaction.chain);
@@ -523,7 +675,7 @@ export default class TransactionService {
       // Will be added in next step
       nonce: nonce !== null && nonce !== void 0 ? nonce : 0,
       startBlock: startBlock || 0,
-      processId: (_transaction$step2 = transaction.step) === null || _transaction$step2 === void 0 ? void 0 : _transaction$step2.processId
+      processId: (_transaction$step3 = transaction.step) === null || _transaction$step3 === void 0 ? void 0 : _transaction$step3.processId
     };
     const nativeAsset = _getChainNativeTokenBasicInfo(chainInfo);
     const baseNativeAmount = {
@@ -1351,6 +1503,76 @@ export default class TransactionService {
     });
     return emitter;
   }
+  signAndSendEvmDutchTransaction({
+    address,
+    id,
+    isPassConfirmation,
+    step,
+    transaction,
+    url
+  }) {
+    const emitter = new EventEmitter();
+    const eventData = {
+      id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: id,
+      processId: step === null || step === void 0 ? void 0 : step.processId
+    };
+
+    // todo: review this object
+    const evmSignaturePayload = {
+      id: id,
+      type: 'eth_signTypedData_v4',
+      payload: transaction,
+      address: address,
+      hashPayload: '',
+      canSign: true,
+      processId: step === null || step === void 0 ? void 0 : step.processId
+    };
+    this.state.requestService.addConfirmation(id, url || EXTENSION_REQUEST_URL, 'submitApiRequest', evmSignaturePayload, {
+      isPassConfirmation
+    }).then(({
+      isApproved,
+      payload: signature
+    }) => {
+      if (isApproved) {
+        emitter.emit('signed', eventData);
+        emitter.emit('send', eventData);
+        transaction.submitSwapOrder().then(isSendSuccess => {
+          if (!isSendSuccess) {
+            throw new EvmProviderError(EvmProviderErrorType.UNAUTHORIZED, t('Failed to sign'));
+          }
+          this.handleTransactionTimeout(emitter, eventData);
+          transaction.cronCheckTxSuccess().then(order => {
+            if (!order) {
+              eventData.errors.push(new TransactionError(BasicTxErrorType.SEND_TRANSACTION_FAILED));
+              emitter.emit('error', eventData);
+            } else {
+              eventData.extrinsicHash = order.txHash;
+              emitter.emit('extrinsicHash', eventData);
+              emitter.emit('success', eventData);
+            }
+          }).catch(e => {
+            eventData.errors.push(new TransactionError(BasicTxErrorType.SEND_TRANSACTION_FAILED, t(e.message)));
+            emitter.emit('error', eventData);
+          });
+        }).catch(e => {
+          eventData.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SEND, t(e.message)));
+          emitter.emit('error', eventData);
+        });
+      } else {
+        this.removeTransaction(id);
+        eventData.errors.push(new TransactionError(BasicTxErrorType.USER_REJECT_REQUEST));
+        emitter.emit('error', eventData);
+      }
+    }).catch(e => {
+      this.removeTransaction(id);
+      eventData.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SIGN, t(e.message)));
+      emitter.emit('error', eventData);
+    });
+    return emitter;
+  }
   signAndSendSubstrateTransaction({
     address,
     chain,
@@ -1784,9 +2006,9 @@ export default class TransactionService {
     }
   }
   async createProcessNotification(transactionId) {
-    var _transaction$step3;
+    var _transaction$step4;
     const transaction = this.getTransaction(transactionId);
-    if (transaction && (_transaction$step3 = transaction.step) !== null && _transaction$step3 !== void 0 && _transaction$step3.processId) {
+    if (transaction && (_transaction$step4 = transaction.step) !== null && _transaction$step4 !== void 0 && _transaction$step4.processId) {
       const process = this.aliveProcessMap.get(transaction.step.processId);
       if (process) {
         await this.state.inappNotificationService.createProcessNotification(process);

package/services/transaction-service/types.d.ts

@@ -1,12 +1,13 @@
 import { ChainType, ExtrinsicDataTypeMap, ExtrinsicStatus, ExtrinsicType, FeeData, ValidateTransactionResponse } from '@subwallet/extension-base/background/KoniTypes';
 import { SignTypedDataMessageV3V4 } from '@subwallet/extension-base/core/logic-validation';
 import { TonTransactionConfig } from '@subwallet/extension-base/services/balance-service/transfer/ton-transfer';
+import { UniswapOrderInfo } from '@subwallet/extension-base/services/swap-service/handler/uniswap-handler';
 import { BaseRequestSign, BriefProcessStep, ProcessTransactionData, TransactionFee } from '@subwallet/extension-base/types';
 import EventEmitter from 'eventemitter3';
 import { TransactionConfig } from 'web3-core';
 import { SubmittableExtrinsic } from '@polkadot/api/promise/types';
 import { EventRecord } from '@polkadot/types/interfaces';
-export interface SWTransaction extends ValidateTransactionResponse, Partial<Pick<BaseRequestSign, 'ignoreWarnings'>>, TransactionFee {
+export interface SWTransactionBase extends ValidateTransactionResponse, Partial<Pick<BaseRequestSign, 'ignoreWarnings'>>, TransactionFee {
     id: string;
     url?: string;
     isInternal: boolean;
@@ -21,7 +22,7 @@ export interface SWTransaction extends ValidateTransactionResponse, Partial<Pick
     updatedAt: number;
     estimateFee?: FeeData;
     xcmFeeDryRun?: string;
-    transaction: SubmittableExtrinsic | TransactionConfig | TonTransactionConfig;
+    transaction: any;
     additionalValidator?: (inputTransaction: SWTransactionResponse) => Promise<void>;
     eventsHandler?: (eventEmitter: TransactionEmitter) => void;
     isPassConfirmation?: boolean;
@@ -29,18 +30,27 @@ export interface SWTransaction extends ValidateTransactionResponse, Partial<Pick
     signAfterCreate?: (id: string) => void;
     step?: BriefProcessStep;
 }
-export interface SWPermitTransaction extends Omit<SWTransaction, 'transaction'> {
+export interface SWTransaction extends SWTransactionBase {
+    transaction: SubmittableExtrinsic | TransactionConfig | TonTransactionConfig;
+}
+export interface SWPermitTransaction extends SWTransactionBase {
     transaction: SignTypedDataMessageV3V4;
 }
-export interface SWTransactionResult extends Omit<SWTransaction, 'transaction' | 'additionalValidator' | 'eventsHandler' | 'process'> {
+export interface SWDutchTransaction extends SWTransactionBase {
+    transaction: {
+        submitSwapOrder: () => Promise<boolean>;
+        cronCheckTxSuccess: () => Promise<UniswapOrderInfo | undefined>;
+    };
+}
+export interface SWTransactionResult extends Omit<SWTransactionBase, 'transaction' | 'additionalValidator' | 'eventsHandler' | 'process'> {
     process?: ProcessTransactionData;
 }
-declare type SwInputBase = Pick<SWTransaction, 'address' | 'url' | 'data' | 'extrinsicType' | 'chain' | 'chainType' | 'ignoreWarnings' | 'transferNativeAmount'> & Partial<Pick<SWTransaction, 'additionalValidator' | 'eventsHandler'>>;
-export interface SWTransactionInput extends SwInputBase, Partial<Pick<SWTransaction, 'estimateFee' | 'signAfterCreate' | 'isPassConfirmation' | 'step' | 'errorOnTimeOut' | 'xcmFeeDryRun'>>, TransactionFee {
+declare type SwInputBase = Pick<SWTransactionBase, 'address' | 'url' | 'data' | 'extrinsicType' | 'chain' | 'chainType' | 'ignoreWarnings' | 'transferNativeAmount'> & Partial<Pick<SWTransactionBase, 'additionalValidator' | 'eventsHandler'>>;
+export interface SWTransactionInput extends SwInputBase, Partial<Pick<SWTransactionBase, 'estimateFee' | 'signAfterCreate' | 'isPassConfirmation' | 'step' | 'errorOnTimeOut' | 'xcmFeeDryRun'>>, TransactionFee {
     id?: string;
-    transaction?: SWTransaction['transaction'] | null;
-    warnings?: SWTransaction['warnings'];
-    errors?: SWTransaction['errors'];
+    transaction?: SWTransactionBase['transaction'] | null;
+    warnings?: SWTransactionBase['warnings'];
+    errors?: SWTransactionBase['errors'];
     edAsWarning?: boolean;
     isTransferAll?: boolean;
     isTransferLocalTokenAndPayThatTokenAsFee?: boolean;
@@ -50,7 +60,10 @@ export interface SWTransactionInput extends SwInputBase, Partial<Pick<SWTransact
 export interface SWPermitTransactionInput extends Omit<SWTransactionInput, 'transaction'> {
     transaction?: SWPermitTransaction['transaction'] | null;
 }
-export declare type SWTransactionResponse = SwInputBase & Pick<SWTransaction, 'warnings' | 'errors'> & Partial<Pick<SWTransaction, 'id' | 'extrinsicHash' | 'status' | 'estimateFee' | 'xcmFeeDryRun'>> & TransactionFee & {
+export interface SWDutchTransactionInput extends Omit<SWTransactionInput, 'transaction'> {
+    transaction?: SWDutchTransaction['transaction'] | null;
+}
+export declare type SWTransactionResponse = SwInputBase & Pick<SWTransactionBase, 'warnings' | 'errors'> & Partial<Pick<SWTransactionBase, 'id' | 'extrinsicHash' | 'status' | 'estimateFee' | 'xcmFeeDryRun'>> & TransactionFee & {
     processId?: string;
 };
 export declare type ValidateTransactionResponseInput = SWTransactionInput;

package/types/swap/index.d.ts

@@ -62,7 +62,8 @@ export declare enum SwapProviderId {
     ROCOCO_ASSET_HUB = "ROCOCO_ASSET_HUB",
     WESTEND_ASSET_HUB = "WESTEND_ASSET_HUB",
     SIMPLE_SWAP = "SIMPLE_SWAP",
-    UNISWAP = "UNISWAP"
+    UNISWAP = "UNISWAP",
+    KYBER = "KYBER"
 }
 export declare const _SUPPORTED_SWAP_PROVIDERS: SwapProviderId[];
 export interface SwapProvider {
@@ -138,6 +139,7 @@ export interface SwapRequestV2 {
     feeToken?: string;
     preferredProvider?: SwapProviderId;
     isCrossChain?: boolean;
+    isSupportKyberVersion?: boolean;
 }
 export interface SwapRequestResult {
     process: CommonOptimalSwapPath;
@@ -166,6 +168,7 @@ export interface SwapSubmitStepData {
     extrinsicType: ExtrinsicType;
     chainType: ChainType;
     isPermit?: boolean;
+    isDutch?: boolean;
 }
 export declare enum DynamicSwapType {
     SWAP = "SWAP",

package/types/swap/index.js

@@ -35,13 +35,14 @@ export let SwapProviderId;
   SwapProviderId["WESTEND_ASSET_HUB"] = "WESTEND_ASSET_HUB";
   SwapProviderId["SIMPLE_SWAP"] = "SIMPLE_SWAP";
   SwapProviderId["UNISWAP"] = "UNISWAP";
+  SwapProviderId["KYBER"] = "KYBER";
 })(SwapProviderId || (SwapProviderId = {}));
 export const _SUPPORTED_SWAP_PROVIDERS = [SwapProviderId.CHAIN_FLIP_TESTNET, SwapProviderId.CHAIN_FLIP_MAINNET, SwapProviderId.HYDRADX_MAINNET,
 // SwapProviderId.HYDRADX_TESTNET,
 SwapProviderId.POLKADOT_ASSET_HUB, SwapProviderId.KUSAMA_ASSET_HUB,
 // SwapProviderId.ROCOCO_ASSET_HUB,
 // SwapProviderId.WESTEND_ASSET_HUB,
-SwapProviderId.SIMPLE_SWAP, SwapProviderId.UNISWAP];
+SwapProviderId.SIMPLE_SWAP, SwapProviderId.UNISWAP, SwapProviderId.KYBER];
 // process handling
 export let SwapFeeType;
 (function (SwapFeeType) {

package/utils/cardano.d.ts

@@ -1,2 +1,4 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
 export declare const convertCardanoAddressToHex: (bech32Address: string) => string;
 export declare const convertCardanoHexToBech32: (hexAddress: string) => string;
+export declare const validateAddressNetwork: (address: string, chainInfo?: _ChainInfo) => boolean;

package/utils/cardano.js

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { Address } from '@emurgo/cardano-serialization-lib-nodejs';
+import { isCardanoMainnetAddress, isCardanoTestnetAddress } from '@subwallet/keyring';
 export const convertCardanoAddressToHex = bech32Address => {
   const addr = Address.from_bech32(bech32Address);
   return addr.to_hex();
@@ -9,4 +10,10 @@ export const convertCardanoAddressToHex = bech32Address => {
 export const convertCardanoHexToBech32 = hexAddress => {
   const addr = Address.from_hex(hexAddress);
   return addr.to_bech32();
+};
+export const validateAddressNetwork = (address, chainInfo) => {
+  if (!(chainInfo !== null && chainInfo !== void 0 && chainInfo.cardanoInfo) || !chainInfo.isTestnet) {
+    return isCardanoMainnetAddress(address);
+  }
+  return isCardanoTestnetAddress(address);
 };