@instadapp/avocado-base 0.0.0-dev.9e8d2fb → 0.0.0-dev.afb1d81

package/nuxt.config.ts

@@ -1,4 +1,20 @@
 // https://nuxt.com/docs/api/configuration/nuxt-config
-export default defineNuxtConfig({
+import ViteComponents from "unplugin-vue-components/vite";
 
-})
+export default defineNuxtConfig({
+  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.9e8d2fb",
+  "version": "0.0.0-dev.afb1d81",
   "type": "module",
   "main": "./nuxt.config.ts",
   "types": "global.d.ts",
@@ -14,12 +14,16 @@
   "devDependencies": {
     "@instadapp/avocado": "^0.1.10",
     "@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/server/utils/index.ts

@@ -1,2 +1,4 @@
 export * from "../../utils/avocado";
 export * from "../../utils/network";
+export * from "../../utils/bignumber";
+export * from "../../utils/formatter";

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

@@ -0,0 +1,51 @@
+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();
+export const times = (a: BigNumber.Value | BN, b: BigNumber.Value | BN) =>
+  toBN(a).times(toBN(b));
+export const minus = (a: BigNumber.Value | BN, b: BigNumber.Value | BN) =>
+  toBN(a).minus(toBN(b));
+export const plus = (a: BigNumber.Value | BN, b: BigNumber.Value | BN) =>
+  toBN(a).plus(toBN(b));
+export const lte = (a: BigNumber.Value | BN, b: BigNumber.Value | BN) =>
+  toBN(a).lte(toBN(b));
+export const gte = (a: BigNumber.Value | BN, b: BigNumber.Value | BN) =>
+  toBN(a).gte(toBN(b));
+export const div = (a: BigNumber.Value | BN, b: BigNumber.Value | BN) =>
+  toBN(a).div(toBN(b));
+export const lt = (a: BigNumber.Value | BN, b: BigNumber.Value | BN) =>
+  toBN(a).lt(toBN(b));
+export const gt = (a: BigNumber.Value | BN, b: BigNumber.Value | BN) =>
+  toBN(a).gt(toBN(b));
+export const ensureValue = (value: any) => {
+  if (!value) return toBN("0");
+  if (toBN(value).isNaN()) return toBN("0");
+
+  return toBN(value);
+};
+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

@@ -0,0 +1,94 @@
+export function formatPercent(
+  value?: number | string,
+  fractionDigits = 2,
+  maxValue = null
+) {
+  if (!value || isZero(value)) return "0.00%";
+
+  const valueAsNumber = toBN(value).toNumber();
+
+  if (maxValue && gt(times(valueAsNumber, "100"), maxValue))
+    return `>${maxValue}%`;
+
+  const formatter = new Intl.NumberFormat("en-US", {
+    style: "percent",
+    minimumFractionDigits: fractionDigits,
+    maximumFractionDigits: fractionDigits,
+  });
+
+  return formatter.format(valueAsNumber);
+}
+
+export function shortenHash(hash: string, length: number = 4) {
+  if (!hash) return;
+  if (hash.length < 12) return hash;
+  const beginningChars = hash.startsWith("0x") ? length + 2 : length;
+  const shortened =
+    hash.substr(0, beginningChars) + "..." + hash.substr(-length);
+  return shortened;
+}
+
+export function formatUsd(value: any, fractionDigits = 2) {
+  const formatter = new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD",
+    minimumFractionDigits: fractionDigits,
+    maximumFractionDigits: fractionDigits,
+  });
+
+  return formatter.format(value);
+}
+
+export function signedNumber(numb: string | number) {
+  return new Intl.NumberFormat("en-US", {
+    signDisplay: "exceptZero",
+  }).format(toBN(numb).toNumber());
+}
+
+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;
+    }
+
+    const formattedNumber = num.toFixed(fractionDigits || decimals);
+
+    return toBN(formattedNumber).toFormat();
+  }
+}

package/utils/helper.ts

@@ -26,3 +26,29 @@ export function sortByMany<T>(
     return result;
   });
 }
+
+export function cloneDeep<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value));
+}
+
+export function filterArray(array: any, filters: any) {
+  const filterKeys = Object.keys(filters);
+  return array.filter((item: any) => {
+    // validates all filter criteria
+    return filterKeys.every((key) => {
+      // ignores non-function predicates
+      if (typeof filters[key] !== "function") return true;
+      return filters[key](item[key], item);
+    });
+  });
+}
+
+export function onImageError(this: HTMLImageElement) {
+  const parentElement = this.parentElement;
+  this.onerror = null;
+  this.remove();
+
+  if (parentElement) {
+    parentElement.classList.add("bg-gray-300");
+  }
+}

package/utils/metadata.ts

@@ -1,6 +1,5 @@
 import { ethers, utils } from "ethers";
-import { Forwarder__factory } from "@/contracts";
-import { toBN } from "./index";
+import { Forwarder__factory } from "../contracts";
 
 const multiMetadataTypes = ["bytes[]"];
 
@@ -8,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",
@@ -28,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",
@@ -35,6 +42,7 @@ const actionMetadataTypes = {
     "uint160 amount",
     "uint48 expiration",
   ],
+  "instadapp-pro": ["string castDetails"],
 };
 
 const encodeMetadata = (props: MetadataProps) => {
@@ -79,6 +87,46 @@ export const encodeTransferMetadata = (
   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",
@@ -209,7 +257,7 @@ export const decodeMetadata = (data: string) => {
       } else {
         metadata = executeData.metadata_;
       }
-    } else {
+    } else if (data.startsWith("0x14f80a8d")) {
       const executeDataV2 = iface.decodeFunctionData("executeV2", data);
       if (
         executeDataV2.params_.metadata === "0x" ||
@@ -219,6 +267,29 @@ export const decodeMetadata = (data: string) => {
       } 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 {
+        metadata = executeDataMultisigV3.params_.metadata;
+      }
     }
 
     const metadataArr = [];
@@ -303,6 +374,7 @@ export const decodeMetadata = (data: string) => {
           payload = {
             type,
           };
+          break;
 
         case "permit2":
           payload = {
@@ -312,6 +384,37 @@ export const decodeMetadata = (data: string) => {
             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;
       }
@@ -321,7 +424,7 @@ export const decodeMetadata = (data: string) => {
 
     return metadataArr;
   } catch (e) {
-    console.log(e);
+    // console.log(e);
     return null;
   }
 };