@instadapp/avocado-base 0.0.0-dev.97f9db0 → 0.0.0-dev.9853aa2

package/nuxt.config.ts

@@ -1,4 +1,20 @@
 // https://nuxt.com/docs/api/configuration/nuxt-config
+import ViteComponents from "unplugin-vue-components/vite";
+
 export default defineNuxtConfig({
-  modules: ["@nuxtjs/tailwindcss"],
+  modules: ["@nuxtjs/tailwindcss", "nuxt-svgo", "@vueuse/nuxt"],
+  svgo: {
+    defaultImport: "component",
+    autoImportPath: "./assets/images/icons",
+    svgoConfig: {
+      plugins: ["prefixIds"],
+    },
+  },
+  vite: {
+    plugins: [
+      ViteComponents({
+        dts: true,
+      }),
+    ],
+  },
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@instadapp/avocado-base",
-  "version": "0.0.0-dev.97f9db0",
+  "version": "0.0.0-dev.9853aa2",
   "type": "module",
   "main": "./nuxt.config.ts",
   "types": "global.d.ts",
@@ -16,11 +16,14 @@
     "@instadapp/avocado-dev": "npm:@instadapp/avocado@dev",
     "@nuxtjs/tailwindcss": "^6.6.5",
     "@typechain/ethers-v5": "^10.2.0",
-    "nuxt": "^3.3.3",
+    "nuxt": "^3.6.1",
+    "nuxt-svgo": "^3.1.0",
     "rimraf": "^3.0.2",
-    "typechain": "^8.1.1"
+    "typechain": "^8.1.1",
+    "unplugin-vue-components": "^0.25.1"
   },
   "dependencies": {
+    "@vueuse/nuxt": "^10.2.0",
     "bignumber.js": "^9.1.1",
     "ethers": "^5.7.2"
   }

package/utils/avocado.ts

@@ -20,3 +20,5 @@ export const AVO_STAGING_DEPOSIT_ADDRESS =
 export const AVO_PROD_RPC_URL = "https://rpc.avocado.instadapp.io";
 
 export const AVO_STAGING_RPC_URL = "https://rpc.avocado.instad.app";
+
+export const blockQueryURL = "https://blockquery.instadapp.io";

package/utils/bignumber.ts

@@ -1,6 +1,8 @@
 import { BigNumber } from "bignumber.js";
 import { BigNumber as BN } from "ethers";
 
+type CombinedBigNumber = BigNumber | string | number;
+
 export const toBN = (value: BigNumber.Value | BN) =>
   new BigNumber(BN.isBigNumber(value) ? value.toString() : value);
 export const isZero = (value: BigNumber.Value | BN) => toBN(value).isZero();
@@ -29,3 +31,21 @@ export const ensureValue = (value: any) => {
 export const max = (...args: BigNumber.Value[]) => {
   return BigNumber.max(...args);
 };
+
+export function pow(value: CombinedBigNumber, exponent: string | number) {
+  return toBN(value).pow(toBN(exponent));
+}
+
+export function toWei(val: CombinedBigNumber, decimals: number): string {
+  const num = toBN(val);
+  const multiplier = pow(10, decimals);
+  return times(num, multiplier).toFixed(0);
+}
+
+export function fromWei(val: CombinedBigNumber, decimal = 18) {
+  return toBN(val).div(new BigNumber(10).pow(decimal));
+}
+
+export function abs(value: CombinedBigNumber) {
+  return toBN(value).abs();
+}

package/utils/formatter.ts

@@ -1,11 +1,14 @@
 export function formatPercent(
-  value: number,
+  value?: number | string,
   fractionDigits = 2,
   maxValue = null
 ) {
-  if (isZero(value)) return "0.00%";
+  if (!value || isZero(value)) return "0.00%";
 
-  if (maxValue && gt(times(value, "100"), maxValue)) return `>${maxValue}%`;
+  const valueAsNumber = toBN(value).toNumber();
+
+  if (maxValue && gt(times(valueAsNumber, "100"), maxValue))
+    return `>${maxValue}%`;
 
   const formatter = new Intl.NumberFormat("en-US", {
     style: "percent",
@@ -13,7 +16,7 @@ export function formatPercent(
     maximumFractionDigits: fractionDigits,
   });
 
-  return formatter.format(value);
+  return formatter.format(valueAsNumber);
 }
 
 export function shortenHash(hash: string, length: number = 4) {
@@ -42,10 +45,50 @@ export function signedNumber(numb: string | number) {
   }).format(toBN(numb).toNumber());
 }
 
-export function formatDecimal(value: string | number, decimalPlaces = 5) {
+function getFractionDigits(value: string | number) {
+  const absoluteValue = toBN(value).abs();
+
+  if (isZero(absoluteValue)) {
+    return 2;
+  } else if (lt(absoluteValue, 0.01)) {
+    return 6;
+  } else if (lt(absoluteValue, 1)) {
+    return 4;
+  } else if (lt(absoluteValue, 10000)) {
+    return 2;
+  } else {
+    return 0;
+  }
+}
+
+export function formatDecimal(value: string | number, fractionDigits?: number) {
   if (!value) {
     value = "0";
   }
+  if (lt(value, "0.0001") && gt(value, "0")) {
+    return "< 0.0001";
+  } else {
+    const num = toBN(value);
+    let decimals;
+
+    if (num.lt(1)) {
+      decimals = 8;
+    } else if (num.lt(10)) {
+      decimals = 6;
+    } else if (num.lt(100)) {
+      decimals = 4;
+    } else if (num.lt(1000)) {
+      decimals = 3;
+    } else if (num.lt(10000)) {
+      decimals = 2;
+    } else if (num.lt(100000)) {
+      decimals = 1;
+    } else {
+      decimals = 0;
+    }
 
-  return toBN(value).decimalPlaces(decimalPlaces).toFormat();
+    const formattedNumber = num.toFixed(fractionDigits || decimals);
+
+    return toBN(formattedNumber).toFormat();
+  }
 }

package/utils/metadata.ts

@@ -1,5 +1,5 @@
 import { ethers, utils } from "ethers";
-import { Forwarder__factory } from "@/contracts";
+import { Forwarder__factory } from "../contracts";
 
 const multiMetadataTypes = ["bytes[]"];
 
@@ -7,6 +7,13 @@ const metadataTypes = ["bytes32 type", "uint8 version", "bytes data"];
 
 const actionMetadataTypes = {
   transfer: ["address token", "uint256 amount", "address receiver"],
+  "cross-transfer": [
+    "address fromToken",
+    "address toToken",
+    "uint256 toChainId",
+    "uint256 amount",
+    "address receiver",
+  ],
   bridge: [
     "uint256 amount",
     "address receiver",
@@ -27,6 +34,7 @@ const actionMetadataTypes = {
   "gas-topup": ["uint256 amount", "address token", "address onBehalf"],
   upgrade: ["bytes32 version", "address walletImpl"],
   dapp: ["string name", "string url"],
+  auth: ["address address", "uint256 chainId", "bool remove"],
   deploy: [],
   permit2: [
     "address token",
@@ -34,6 +42,8 @@ const actionMetadataTypes = {
     "uint160 amount",
     "uint48 expiration",
   ],
+  "instadapp-pro": ["string castDetails"],
+  reject: ["string reason"],
 };
 
 const encodeMetadata = (props: MetadataProps) => {
@@ -78,6 +88,60 @@ export const encodeTransferMetadata = (
   return single ? encodeMultipleActions(data) : data;
 };
 
+export const encodeRejectMetadata = (reason: string, single = true) => {
+  const encodedData = ethers.utils.defaultAbiCoder.encode(
+    actionMetadataTypes.reject,
+    [reason]
+  );
+
+  const data = encodeMetadata({
+    type: "reject",
+    encodedData,
+  });
+
+  return single ? encodeMultipleActions(data) : data;
+};
+
+export const encodeCrossTransferMetadata = (
+  params: CrossSendMetadataProps,
+  single = true
+) => {
+  const encodedData = ethers.utils.defaultAbiCoder.encode(
+    actionMetadataTypes["cross-transfer"],
+    [
+      params.fromToken,
+      params.toToken,
+      params.toChainId,
+      params.amount,
+      params.receiver,
+    ]
+  );
+
+  const data = encodeMetadata({
+    type: "cross-transfer",
+    encodedData,
+  });
+
+  return single ? encodeMultipleActions(data) : data;
+};
+
+export const encodeAuthMetadata = (
+  params: AuthMetadataProps,
+  single = true
+) => {
+  const encodedData = ethers.utils.defaultAbiCoder.encode(
+    actionMetadataTypes["auth"],
+    [params.address, params.chainId, params.remove]
+  );
+
+  const data = encodeMetadata({
+    type: "auth",
+    encodedData,
+  });
+
+  return single ? encodeMultipleActions(data) : data;
+};
+
 export const encodeDeployMetadata = (single = true) => {
   const data = encodeMetadata({
     type: "deploy",
@@ -193,134 +257,224 @@ export const encodeMultipleActions = (...actionData: string[]) => {
   return ethers.utils.defaultAbiCoder.encode(multiMetadataTypes, [actionData]);
 };
 
-export const decodeMetadata = (data: string) => {
+export const decodeData = (data: string) => {
   try {
-    const iface = Forwarder__factory.createInterface();
-    let metadata = "0x";
-    let payload = {};
-
-    if (!data) return payload;
-
-    if (data.startsWith("0x18e7f485")) {
-      const executeData = iface.decodeFunctionData("execute", data);
-      if (executeData.metadata_ === "0x" || !executeData.metadata_) {
-        return null;
-      } else {
-        metadata = executeData.metadata_;
-      }
+    const metadata = getMetadataFromData(data) || "0x";
+
+    return parseMetadata(metadata);
+  } catch (e) {
+    // console.log(e);
+    return null;
+  }
+};
+
+export const decodeMetadata = (metadata: string) => {
+  try {
+    return parseMetadata(metadata);
+  } catch (e) {
+    return null;
+  }
+};
+
+const getMetadataFromData = (data: string) => {
+  const iface = Forwarder__factory.createInterface();
+  let metadata = "0x";
+
+  if (data.startsWith("0x18e7f485")) {
+    const executeData = iface.decodeFunctionData("execute", data);
+    if (executeData.metadata_ === "0x" || !executeData.metadata_) {
+      return null;
+    } else {
+      metadata = executeData.metadata_;
+    }
+  } else if (data.startsWith("0x14f80a8d")) {
+    const executeDataV2 = iface.decodeFunctionData("executeV2", data);
+    if (
+      executeDataV2.params_.metadata === "0x" ||
+      !executeDataV2.params_.metadata
+    ) {
+      return null;
+    } else {
+      metadata = executeDataV2.params_.metadata;
+    }
+  } else if (data.startsWith("0x85114d53")) {
+    const executeDataV3 = iface.decodeFunctionData("executeV3", data);
+    if (
+      executeDataV3.params_.metadata === "0x" ||
+      !executeDataV3.params_.metadata
+    ) {
+      return null;
+    } else {
+      metadata = executeDataV3.params_.metadata;
+    }
+  } else {
+    const executeDataMultisigV3 = iface.decodeFunctionData(
+      "executeMultisigV3",
+      data
+    );
+    if (
+      executeDataMultisigV3.params_.metadata === "0x" ||
+      !executeDataMultisigV3.params_.metadata
+    ) {
+      return null;
     } else {
-      const executeDataV2 = iface.decodeFunctionData("executeV2", data);
-      if (
-        executeDataV2.params_.metadata === "0x" ||
-        !executeDataV2.params_.metadata
-      ) {
-        return null;
-      } else {
-        metadata = executeDataV2.params_.metadata;
-      }
+      metadata = executeDataMultisigV3.params_.metadata;
     }
+  }
 
-    const metadataArr = [];
-
-    const [decodedMultiMetadata = []] =
-      (ethers.utils.defaultAbiCoder.decode(
-        multiMetadataTypes,
-        metadata
-      ) as string[]) || [];
-
-    for (let metadata of decodedMultiMetadata) {
-      const decodedMetadata = ethers.utils.defaultAbiCoder.decode(
-        metadataTypes,
-        metadata
-      );
-
-      const type = ethers.utils.parseBytes32String(
-        decodedMetadata.type
-      ) as keyof typeof actionMetadataTypes;
-
-      const decodedData = ethers.utils.defaultAbiCoder.decode(
-        actionMetadataTypes[type],
-        decodedMetadata.data
-      );
-
-      switch (type) {
-        case "transfer":
-          payload = {
-            type,
-            token: decodedData.token,
-            amount: toBN(decodedData.amount).toFixed(),
-            receiver: decodedData.receiver,
-          };
-          break;
-        case "bridge":
-          payload = {
-            type,
-            amount: toBN(decodedData.amount).toFixed(),
-            receiver: decodedData.receiver,
-            toToken: decodedData.toToken,
-            fromToken: decodedData.fromToken,
-            toChainId: decodedData.toChainId
-              ? decodedData.toChainId.toString()
-              : null,
-            bridgeFee: toBN(decodedData.bridgeFee).toFixed(),
-          };
-          break;
-        case "swap":
-          payload = {
-            type,
-            buyAmount: toBN(decodedData.buyAmount).toFixed(),
-            sellAmount: toBN(decodedData.sellAmount).toFixed(),
-            buyToken: decodedData.buyToken,
-            sellToken: decodedData.sellToken,
-            receiver: decodedData.receiver,
-            protocol: utils.parseBytes32String(decodedData?.protocol || ""),
-          };
-          break;
-        case "upgrade":
-          payload = {
-            type,
-            version: utils.parseBytes32String(decodedData?.version || ""),
-            walletImpl: decodedData?.walletImpl,
-          };
-          break;
-        case "gas-topup":
-          payload = {
-            type,
-            amount: toBN(decodedData.amount).toFixed(),
-            token: decodedData.token,
-            onBehalf: decodedData.onBehalf,
-          };
-          break;
-        case "dapp":
-          payload = {
-            type,
-            name: decodedData?.name,
-            url: decodedData?.url,
-          };
-          break;
-        case "deploy":
-          payload = {
-            type,
-          };
-
-        case "permit2":
-          payload = {
-            type,
-            token: decodedData.token,
-            spender: decodedData.spender,
-            amount: toBN(decodedData.amount).toFixed(),
-            expiration: decodedData.expiration,
-          };
-
-          break;
-      }
-
-      metadataArr.push(payload);
+  return metadata;
+};
+
+const parseMetadata = (metadata: string) => {
+  const metadataArr = [];
+  let payload = {};
+
+  const [decodedMultiMetadata = []] =
+    (ethers.utils.defaultAbiCoder.decode(
+      multiMetadataTypes,
+      metadata
+    ) as string[]) || [];
+
+  for (let metadata of decodedMultiMetadata) {
+    const decodedMetadata = ethers.utils.defaultAbiCoder.decode(
+      metadataTypes,
+      metadata
+    );
+
+    const type = ethers.utils.parseBytes32String(
+      decodedMetadata.type
+    ) as keyof typeof actionMetadataTypes;
+
+    const decodedData = ethers.utils.defaultAbiCoder.decode(
+      actionMetadataTypes[type],
+      decodedMetadata.data
+    );
+
+    switch (type) {
+      case "transfer":
+        payload = {
+          type,
+          token: decodedData.token,
+          amount: toBN(decodedData.amount).toFixed(),
+          receiver: decodedData.receiver,
+        };
+        break;
+      case "bridge":
+        payload = {
+          type,
+          amount: toBN(decodedData.amount).toFixed(),
+          receiver: decodedData.receiver,
+          toToken: decodedData.toToken,
+          fromToken: decodedData.fromToken,
+          toChainId: decodedData.toChainId
+            ? decodedData.toChainId.toString()
+            : null,
+          bridgeFee: toBN(decodedData.bridgeFee).toFixed(),
+        };
+        break;
+      case "swap":
+        payload = {
+          type,
+          buyAmount: toBN(decodedData.buyAmount).toFixed(),
+          sellAmount: toBN(decodedData.sellAmount).toFixed(),
+          buyToken: decodedData.buyToken,
+          sellToken: decodedData.sellToken,
+          receiver: decodedData.receiver,
+          protocol: utils.parseBytes32String(decodedData?.protocol || ""),
+        };
+        break;
+      case "upgrade":
+        payload = {
+          type,
+          version: utils.parseBytes32String(decodedData?.version || ""),
+          walletImpl: decodedData?.walletImpl,
+        };
+        break;
+      case "gas-topup":
+        payload = {
+          type,
+          amount: toBN(decodedData.amount).toFixed(),
+          token: decodedData.token,
+          onBehalf: decodedData.onBehalf,
+        };
+        break;
+      case "dapp":
+        payload = {
+          type,
+          name: decodedData?.name,
+          url: decodedData?.url,
+        };
+        break;
+      case "deploy":
+        payload = {
+          type,
+        };
+        break;
+
+      case "permit2":
+        payload = {
+          type,
+          token: decodedData.token,
+          spender: decodedData.spender,
+          amount: toBN(decodedData.amount).toFixed(),
+          expiration: decodedData.expiration,
+        };
+        break;
+
+      case "cross-transfer":
+        payload = {
+          type,
+          fromToken: decodedData.fromToken,
+          toToken: decodedData.toToken,
+          toChainId: decodedData.toChainId
+            ? decodedData.toChainId.toString()
+            : null,
+          amount: toBN(decodedData.amount).toFixed(),
+          receiver: decodedData.receiver,
+        };
+
+        break;
+      case "auth":
+        payload = {
+          type: decodedData.remove ? "remove-authority" : "add-authority",
+          address: decodedData.address,
+          chainId: decodedData.chainId ? decodedData.chainId.toString() : null,
+          remove: decodedData.remove,
+        };
+
+        break;
+      case "instadapp-pro":
+        payload = {
+          type,
+          castDetails: decodedData.castDetails,
+        };
+
+        break;
+
+      case "reject":
+        payload = {
+          type,
+          reason: decodedData.reason,
+        };
+        break;
     }
 
-    return metadataArr;
-  } catch (e) {
-    console.log(e);
-    return null;
+    metadataArr.push(payload);
   }
+
+  return metadataArr;
+};
+
+/**
+ * Replaces hyphens with spaces and capitalizes the first letter of each word in a sentence.
+ * @param {string} txType - The input sentence to modify
+ *
+ * @returns {string} - The modified sentence with hyphens replaced with spaces and the first letter of each word capitalized.
+ */
+export const formatTxType = (txType: string) => {
+  const finalSentence = txType
+    .replace("-", " ")
+    .replace(/(^\w{1})|(\s+\w{1})/g, (letter) => letter.toUpperCase());
+
+  return finalSentence;
 };