Merge pull request #573 from enkryptcom/prep/release

feat/release-2.0

Author: kvhnuke

packages/extension/.env.example

@@ -0,0 +1,2 @@
+# VITE_DEBUG_LOG="swap:*"
+VITE_DEBUG_LOG=

packages/extension/src/libs/activity-state/index.ts

@@ -61,6 +61,7 @@ class ActivityState {
       this.getActivityId(options),
     );
   }
+
   async updateActivity(
     activity: Activity,
     options: ActivityOptions,
@@ -75,24 +76,29 @@ class ActivityState {
     });
     await this.setActivitiesById(clone, this.getActivityId(options));
   }
+
   async setCacheTime(options: ActivityOptions): Promise<void> {
     await this.#storage.set(this.getActivityCacheId(options), {
       [STORAGE_KEY]: new Date().getTime(),
     });
   }
+
   async getCacheTime(options: ActivityOptions): Promise<number> {
     const cacheTime: Record<string, number> = await this.#storage.get(
       this.getActivityCacheId(options),
     );
     if (!cacheTime || !cacheTime[STORAGE_KEY]) return 0;
     return cacheTime[STORAGE_KEY];
   }
+
   async getAllActivities(options: ActivityOptions): Promise<Activity[]> {
     return this.getActivitiesById(this.getActivityId(options));
   }
+
   async deleteAllActivities(options: ActivityOptions): Promise<void> {
     this.setActivitiesById([], this.getActivityId(options));
   }
+
   private async setActivitiesById(
     activities: Activity[],
     id: string,
@@ -101,6 +107,7 @@ class ActivityState {
       [STORAGE_KEY]: activities,
     });
   }
+
   private async getActivitiesById(id: string): Promise<Activity[]> {
     const allStates: Record<string, Activity[]> = await this.#storage.get(id);
     if (!allStates || !allStates[STORAGE_KEY]) return [];

packages/extension/src/libs/utils/unicode-detection.ts

@@ -0,0 +1,22 @@
+const fixedHex = (number: number, length: number) => {
+  let str = number.toString(16).toUpperCase();
+  while (str.length < length) str = '0' + str;
+  return str;
+};
+
+/* Creates a unicode literal based on the string */
+const unicodeLiteral = (str: string) => {
+  let i;
+  let result = '';
+  for (i = 0; i < str.length; ++i) {
+    if (str.charCodeAt(i) > 126 || str.charCodeAt(i) < 32)
+      result += '\\u' + fixedHex(str.charCodeAt(i), 4);
+    else result += str[i];
+  }
+  return result;
+};
+export const getRTLOLTLOSafeString = (str: string): string => {
+  const dangerous = /[\u202A-\u202E\u2066-\u2069\u200E\u200F\u061C]/.test(str);
+  if (dangerous) return unicodeLiteral(str);
+  return str;
+};

packages/extension/src/providers/bitcoin/ui/btc-sign-message.vue

@@ -65,6 +65,7 @@ import { ProviderRequestOptions } from '@/types/provider';
 import { BitcoinNetwork } from '../types/bitcoin-network';
 import { EnkryptAccount } from '@enkryptcom/types';
 import { MessageSigner } from './libs/signer';
+import { getRTLOLTLOSafeString } from '@/libs/utils/unicode-detection';
 
 const windowPromise = WindowPromiseHandler(4);
 const network = ref<BitcoinNetwork>(DEFAULT_BTC_NETWORK);
@@ -92,7 +93,7 @@ onBeforeMount(async () => {
   account.value = Request.value.params![2] as EnkryptAccount;
   identicon.value = network.value.identicon(account.value.address);
   Options.value = options;
-  message.value = Request.value.params![0];
+  message.value = getRTLOLTLOSafeString(Request.value.params![0]);
   type.value = Request.value.params![1];
 });
 

packages/extension/src/providers/bitcoin/ui/send-transaction/index.vue

@@ -312,7 +312,10 @@ const isInputsValid = computed<boolean>(() => {
     isSendToken.value
   )
     return false;
-  if (new BigNumber(sendAmount.value).gt(assetMaxValue.value)) return false;
+
+  const sendAmountBigNumber = new BigNumber(sendAmount.value)
+  if (sendAmountBigNumber.isNaN()) return false
+  if (sendAmountBigNumber.gt(assetMaxValue.value)) return false;
   return true;
 });
 

packages/extension/src/providers/common/libs/new-features.ts

@@ -1,6 +1,6 @@
 import { NetworkNames } from '@enkryptcom/types';
 
-const newNetworks = [NetworkNames.Solana];
+const newNetworks = [NetworkNames.Bitrock, NetworkNames.Fraxtal];
 const newSwaps: NetworkNames[] = [];
 
 export { newNetworks, newSwaps };

packages/extension/src/providers/common/ui/send-transaction/send-input-amount.vue

@@ -73,9 +73,16 @@ const amount = computed({
 
 const onlyNumber = ($event: KeyboardEvent) => {
   const keyCode = $event.keyCode ? $event.keyCode : $event.which;
-  if ((keyCode < 48 || keyCode > 57) && keyCode !== 46) {
-    $event.preventDefault();
+  // Numeric
+  if (keyCode >= /* 0 */ 48 && keyCode <= /* 9 */ 57) {
+    return;
   }
+  // Only allow a single period
+  if (keyCode === /* '.' */ 46 && amount.value.indexOf('.') === -1) {
+    return;
+  }
+  // Alphabetical (/non-numeric) or mulitple periods. Don't propagate change
+  $event.preventDefault();
 };
 const changeFocus = () => {
   isFocus.value = !isFocus.value;

packages/extension/src/providers/ethereum/libs/transaction/gas-utils.ts

@@ -62,7 +62,7 @@ const getGasBasedOnType = (
   }
 };
 const getMinPriorityFee = (): BNType => {
-  return toBN(toWei('0.1', 'gwei'));
+  return toBN(toWei('1', 'gwei'));
 };
 const getPriorityFeeAvg = (arr: BNType[]): BNType => {
   const sum = arr.reduce((a, v) => a.add(v));

packages/extension/src/providers/ethereum/libs/transaction/index.ts

@@ -38,14 +38,13 @@ class Transaction {
       value: this.tx.value || '0x0',
     });
   }
-  async getOPfees(): Promise<BNType> {
+  async getOPfees(
+    fTx: LegacyTransaction | FeeMarketEIP1559Transaction,
+  ): Promise<BNType> {
     const OPContract = new this.web3.Contract(
       OPTIMISM_PRICE_ORACLE_ABI as any,
       OPTIMISM_PRICE_ORACLE,
     );
-    const fTx = await this.getFinalizedTransaction({
-      gasPriceType: GasPriceTypes.ECONOMY,
-    });
     const serializedTx = fTx.serialize();
     return OPContract.methods
       .getL1Fee(bufferToHex(serializedTx))
@@ -87,6 +86,7 @@ class Transaction {
     maxFeePerGas?: string;
     gasLimit: string;
     formattedFeeHistory?: FormattedFeeHistory;
+    finalizedTransaction: LegacyTransaction | FeeMarketEIP1559Transaction;
   }> {
     const latestBlock = await this.web3.getBlock('latest', false);
     const { isFeeMarketNetwork, feeHistory } = await this.web3
@@ -123,10 +123,20 @@ class Transaction {
         nonce: this.tx.nonce || (numberToHex(nonce) as `0x${string}`),
         value: this.tx.value || '0x0',
       };
+      const common = Common.custom({
+        chainId: BigInt(this.tx.chainId),
+      });
+      const finalizedTransaction = LegacyTransaction.fromTxData(
+        legacyTx as FinalizedLegacyEthereumTransaction,
+        {
+          common,
+        },
+      );
       return {
         transaction: legacyTx,
         gasPrice: gasPrice,
         gasLimit: legacyTx.gasLimit,
+        finalizedTransaction,
       };
     } else {
       // Fee market transaction (post EIP1559)
@@ -141,7 +151,7 @@ class Transaction {
       const gasLimit =
         this.tx.gasLimit ||
         (numberToHex(await this.estimateGas()) as `0x${string}`);
-      const maxFeePerGas = !options.totalGasPrice
+      let maxFeePerGas = !options.totalGasPrice
         ? feeMarket.maxFeePerGas
         : options.totalGasPrice.div(toBN(gasLimit));
       const maxPriorityFeePerGas = feeMarket.maxPriorityFeePerGas;
@@ -162,13 +172,43 @@ class Transaction {
         type: '0x02',
         accessList: this.tx.accessList || [],
       };
+      const common = Common.custom({
+        chainId: BigInt(this.tx.chainId),
+        defaultHardfork: Hardfork.London,
+      });
+      let finalizedTransaction = FeeMarketEIP1559Transaction.fromTxData(
+        feeMarketTx as FinalizedFeeMarketEthereumTransaction,
+        {
+          common,
+        },
+      );
+      if (options.totalGasPrice) {
+        const opFee = await this.getOPfees(finalizedTransaction);
+        if (opFee.gtn(0)) {
+          const gasFeeWithoutOPFee = options.totalGasPrice.sub(opFee);
+          maxFeePerGas = gasFeeWithoutOPFee.div(toBN(gasLimit));
+          feeMarketTx.maxFeePerGas = numberToHex(maxFeePerGas) as `0x${string}`;
+          feeMarketTx.maxPriorityFeePerGas = numberToHex(
+            maxPriorityFeePerGas.gt(maxFeePerGas)
+              ? maxFeePerGas
+              : maxPriorityFeePerGas,
+          ) as `0x${string}`;
+          finalizedTransaction = FeeMarketEIP1559Transaction.fromTxData(
+            feeMarketTx as FinalizedFeeMarketEthereumTransaction,
+            {
+              common,
+            },
+          );
+        }
+      }
       return {
         transaction: feeMarketTx,
         gasLimit: feeMarketTx.gasLimit,
         baseFeePerGas: numberToHex(baseFeePerGas!),
         maxFeePerGas: numberToHex(feeMarket.maxFeePerGas),
         maxPriorityFeePerGas: numberToHex(feeMarket.maxPriorityFeePerGas),
         formattedFeeHistory,
+        finalizedTransaction,
       };
     }
   }
@@ -182,30 +222,8 @@ class Transaction {
   async getFinalizedTransaction(
     options: TransactionOptions,
   ): Promise<LegacyTransaction | FeeMarketEIP1559Transaction> {
-    const { transaction } = await this.finalizeTransaction(options);
-
-    if (!transaction.maxFeePerGas) {
-      const common = Common.custom({
-        chainId: BigInt(transaction.chainId),
-      });
-      return LegacyTransaction.fromTxData(
-        transaction as FinalizedLegacyEthereumTransaction,
-        {
-          common,
-        },
-      );
-    } else {
-      const common = Common.custom({
-        chainId: BigInt(transaction.chainId),
-        defaultHardfork: Hardfork.London,
-      });
-      return FeeMarketEIP1559Transaction.fromTxData(
-        transaction as FinalizedFeeMarketEthereumTransaction,
-        {
-          common,
-        },
-      );
-    }
+    const { finalizedTransaction } = await this.finalizeTransaction(options);
+    return finalizedTransaction;
   }
 
   async getMessageToSign(options: TransactionOptions): Promise<Uint8Array> {
@@ -214,35 +232,38 @@ class Transaction {
   }
 
   async getGasCosts(): Promise<GasCosts> {
-    const { gasLimit, gasPrice, baseFeePerGas, formattedFeeHistory } =
-      await this.finalizeTransaction({
-        gasPriceType: GasPriceTypes.ECONOMY,
-      });
-    const opFee = await this.getOPfees();
+    const {
+      gasLimit,
+      gasPrice,
+      baseFeePerGas,
+      formattedFeeHistory,
+      finalizedTransaction,
+    } = await this.finalizeTransaction({
+      gasPriceType: GasPriceTypes.ECONOMY,
+    });
     if (gasPrice) {
       return {
         [GasPriceTypes.ECONOMY]: numberToHex(
-          getGasBasedOnType(gasPrice, GasPriceTypes.ECONOMY)
-            .mul(toBN(gasLimit))
-            .add(opFee),
+          getGasBasedOnType(gasPrice, GasPriceTypes.ECONOMY).mul(
+            toBN(gasLimit),
+          ),
         ),
         [GasPriceTypes.REGULAR]: numberToHex(
-          getGasBasedOnType(gasPrice, GasPriceTypes.REGULAR)
-            .mul(toBN(gasLimit))
-            .add(opFee),
+          getGasBasedOnType(gasPrice, GasPriceTypes.REGULAR).mul(
+            toBN(gasLimit),
+          ),
         ),
         [GasPriceTypes.FAST]: numberToHex(
-          getGasBasedOnType(gasPrice, GasPriceTypes.FAST)
-            .mul(toBN(gasLimit))
-            .add(opFee),
+          getGasBasedOnType(gasPrice, GasPriceTypes.FAST).mul(toBN(gasLimit)),
         ),
         [GasPriceTypes.FASTEST]: numberToHex(
-          getGasBasedOnType(gasPrice, GasPriceTypes.FASTEST)
-            .mul(toBN(gasLimit))
-            .add(opFee),
+          getGasBasedOnType(gasPrice, GasPriceTypes.FASTEST).mul(
+            toBN(gasLimit),
+          ),
         ),
       };
     } else {
+      const opFee = await this.getOPfees(finalizedTransaction);
       return {
         [GasPriceTypes.ECONOMY]: numberToHex(
           this.getFeeMarketGasInfo(

packages/extension/src/providers/ethereum/networks/maticzk.ts

@@ -14,11 +14,11 @@ const maticOptions: EvmNetworkOptions = {
   blockExplorerAddr: 'https://zkevm.polygonscan.com/address/[[address]]',
   chainID: '0x44d',
   isTestNetwork: false,
-  currencyName: 'POL',
-  currencyNameLong: 'Polygon POL',
+  currencyName: 'ETH',
+  currencyNameLong: 'Ethereum',
   node: 'wss://nodes.mewapi.io/ws/maticzk',
   icon,
-  coingeckoID: 'polygon-ecosystem-token',
+  coingeckoID: 'ethereum',
   coingeckoPlatform: CoingeckoPlatform.MaticZK,
   NFTHandler: shNFTHandler,
   assetsInfoHandler,