@instadapp/avocado-base 0.0.0-dev.19925f5 → 0.0.0-dev.2177c3e

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 = 4;
+    } 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

@@ -0,0 +1,62 @@
+export const indexSorter = (aIndex: number, bIndex: number) => {
+  if (aIndex === -1 && bIndex === -1) {
+    return 0; // fallback to other sorting criteria
+  } else if (aIndex === -1) {
+    return 1; // b comes first if a is not in the priority list
+  } else if (bIndex === -1) {
+    return -1; // a comes first if b is not in the priority list
+  } else {
+    return aIndex - bIndex; // sort by the index in the priority list
+  }
+};
+
+export function sortByMany<T>(
+  items: T[],
+  callback: ((a: T, b: T) => number)[]
+) {
+  return items.sort(function (a, b) {
+    var result = 0;
+    for (var i = 0; i < callback.length; i++) {
+      var func = callback[i];
+      result = func(a, b);
+      if (result !== 0) {
+        break;
+      }
+    }
+    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");
+  }
+}
+
+export function formatMultipleAddresses(addresses: string[], shorten = true) {
+  const formatter = new Intl.ListFormat('en', { style: 'long', type: 'conjunction' })
+  const formattedString = formatter.format(addresses.map(i => shorten ? shortenHash(i) || '' : i))
+  
+  return formattedString
+}
+

package/utils/metadata.ts

@@ -0,0 +1,536 @@
+import { ethers, utils } from "ethers";
+import { Forwarder__factory } from "../contracts";
+
+  export const MetadataEnums = {
+    "transfer": "transfer",
+    "bridge": "bridge",
+    "swap": "swap",
+    "gas-topup": "gas-topup",
+    "upgrade": "upgrade",
+    "dapp": "dapp",
+    "deploy": "deploy",
+    "permit2": "permit2",
+    "cross-transfer": "cross-transfer",
+    "auth": "auth",
+    "rejection": "rejection",
+    "instadapp-pro": "instadapp-pro",
+    "add-signers": "add-signers",
+    "remove-signers": "remove-signers",
+    "change-threshold": "change-threshold",
+  } as const;
+
+const multiMetadataTypes = ["bytes[]"];
+
+const metadataTypes = ["bytes32 type", "uint8 version", "bytes data"];
+
+const actionMetadataTypes: Record<MetadataTypes, string[]> = {
+  transfer: ["address token", "uint256 amount", "address receiver"],
+  "cross-transfer": [
+    "address fromToken",
+    "address toToken",
+    "uint256 toChainId",
+    "uint256 amount",
+    "address receiver",
+  ],
+  bridge: [
+    "uint256 amount",
+    "address receiver",
+    "address fromToken",
+    "address toToken",
+    "uint256 toChainId",
+    "uint256 bridgeFee",
+    "address nativeToken",
+  ],
+  swap: [
+    "address sellToken",
+    "address buyToken",
+    "uint256 sellAmount",
+    "uint256 buyAmount",
+    "address receiver",
+    "bytes32 protocol",
+  ],
+  "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",
+    "address spender",
+    "uint160 amount",
+    "uint48 expiration",
+  ],
+  "instadapp-pro": ["string castDetails"],
+  'add-signers': ['address[] signers'],
+  'remove-signers': ['address[] signers'],
+  'change-threshold': ['uint8 count'],
+  'rejection': ['bytes32 id'],
+};
+
+const encodeMetadata = (props: MetadataProps) => {
+  return ethers.utils.defaultAbiCoder.encode(metadataTypes, [
+    ethers.utils.formatBytes32String(props.type),
+    props.version || "1",
+    props.encodedData,
+  ]);
+};
+
+export const encodeDappMetadata = (
+  params: DappMetadataProps,
+  single = true
+) => {
+  const encodedData = ethers.utils.defaultAbiCoder.encode(
+    actionMetadataTypes.dapp,
+    [params.name, params.url]
+  );
+
+  const data = encodeMetadata({
+    type: MetadataEnums.dapp,
+    encodedData,
+  });
+
+  return single ? encodeMultipleActions(data) : data;
+};
+
+export const encodeTransferMetadata = (
+  params: SendMetadataProps,
+  single = true
+) => {
+  const encodedData = ethers.utils.defaultAbiCoder.encode(
+    actionMetadataTypes.transfer,
+    [params.token, params.amount, params.receiver]
+  );
+
+  const data = encodeMetadata({
+    type: MetadataEnums.transfer,
+    encodedData,
+  });
+
+  return single ? encodeMultipleActions(data) : data;
+};
+
+export const encodeRejectionMetadata = (id: string, single = true) => {
+  const encodedData = ethers.utils.defaultAbiCoder.encode(
+    actionMetadataTypes.rejection,
+    [id]
+  );
+
+  const data = encodeMetadata({
+    type: MetadataEnums.rejection,
+    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: MetadataEnums["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: MetadataEnums.auth,
+    encodedData,
+  });
+
+  return single ? encodeMultipleActions(data) : data;
+};
+
+export const encodeDeployMetadata = (single = true) => {
+  const data = encodeMetadata({
+    type: MetadataEnums.deploy,
+    encodedData: "0x",
+  });
+
+  return single ? encodeMultipleActions(data) : data;
+};
+
+export const encodeWCSignMetadata = (
+  params: SignMetadataProps,
+  single = true
+) => {
+  const encodedData = ethers.utils.defaultAbiCoder.encode(
+    actionMetadataTypes["permit2"],
+    [params.token, params.spender, params.amount, params.expiration]
+  );
+
+  const data = encodeMetadata({
+    type: MetadataEnums.permit2,
+    encodedData,
+  });
+
+  return single ? encodeMultipleActions(data) : data;
+};
+
+export const encodeUpgradeMetadata = (
+  params: UpgradeMetadataProps,
+  single = true
+) => {
+  const encodedData = ethers.utils.defaultAbiCoder.encode(
+    actionMetadataTypes.upgrade,
+    [params.version, params.walletImpl]
+  );
+
+  const data = encodeMetadata({
+    type: MetadataEnums.upgrade,
+    encodedData,
+  });
+
+  return single ? encodeMultipleActions(data) : data;
+};
+
+export const encodeSwapMetadata = (
+  params: SwapMetadataProps,
+  single = true
+) => {
+  const encodedData = ethers.utils.defaultAbiCoder.encode(
+    actionMetadataTypes.swap,
+    [
+      params.sellToken,
+      params.buyToken,
+      params.sellAmount,
+      params.buyAmount,
+      params.receiver,
+      params.protocol,
+    ]
+  );
+
+  const data = encodeMetadata({
+    type: MetadataEnums.swap,
+    encodedData,
+  });
+
+  return single ? encodeMultipleActions(data) : data;
+};
+
+export const encodeTopupMetadata = (
+  params: TopupMetadataProps,
+  single = true
+) => {
+  const encodedData = ethers.utils.defaultAbiCoder.encode(
+    actionMetadataTypes["gas-topup"],
+    [params.amount, params.token, params.onBehalf]
+  );
+
+  const data = encodeMetadata({
+    type: MetadataEnums["gas-topup"],
+    encodedData,
+  });
+
+  return single ? encodeMultipleActions(data) : data;
+};
+
+export const encodeBridgeMetadata = (
+  params: BridgeMetadataProps,
+  single = true
+) => {
+  const encodedData = ethers.utils.defaultAbiCoder.encode(
+    actionMetadataTypes.bridge,
+    [
+      params.amount,
+      params.receiver,
+      params.fromToken,
+      params.toToken,
+      params.toChainId,
+      params.bridgeFee,
+      params.nativeToken,
+    ]
+  );
+
+  const data = encodeMetadata({
+    type: MetadataEnums.bridge,
+    encodedData,
+  });
+
+  return single ? encodeMultipleActions(data) : data;
+};
+
+export const encodeChangeThresholdMetadata = (
+  threshold: string | number,
+  single = true
+) => {
+  const encodedData = ethers.utils.defaultAbiCoder.encode(
+    actionMetadataTypes["change-threshold"],
+    [toBN(threshold).toNumber()]
+  );
+
+  const data = encodeMetadata({
+    type: MetadataEnums["change-threshold"],
+    encodedData,
+  });
+
+  return single ? encodeMultipleActions(data) : data;
+};
+
+export const encodeRemoveSignersMetadata = (
+  addresses: string[],
+  single = true
+) => {
+  const encodedData = ethers.utils.defaultAbiCoder.encode(
+    actionMetadataTypes["remove-signers"],
+    [addresses]
+  );
+
+  const data = encodeMetadata({
+    type: MetadataEnums["remove-signers"],
+    encodedData,
+  });
+
+  return single ? encodeMultipleActions(data) : data;
+};
+
+export const encodeAddSignersMetadata = (
+  addresses: string[],
+  single = true
+) => {
+  const encodedData = ethers.utils.defaultAbiCoder.encode(
+    actionMetadataTypes["add-signers"],
+    [addresses]
+  );
+
+  const data = encodeMetadata({
+    type: MetadataEnums["add-signers"],
+    encodedData,
+  });
+
+  return single ? encodeMultipleActions(data) : data;
+};
+
+export const encodeMultipleActions = (...actionData: string[]) => {
+  return ethers.utils.defaultAbiCoder.encode(multiMetadataTypes, [actionData]);
+};
+
+export const decodeData = (data: string) => {
+  try {
+    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 {
+      metadata = executeDataMultisigV3.params_.metadata;
+    }
+  }
+
+  return metadata;
+};
+
+
+const typesPayload: IPayload = {
+  transfer: (data, type) => ({
+    type,
+    token: data.token,
+    amount: toBN(data.amount).toFixed(),
+    receiver: data.receiver,
+  }),
+  bridge: (data, type) => ({
+    type,
+    amount: toBN(data.amount).toFixed(),
+    receiver: data.receiver,
+    toToken: data.toToken,
+    fromToken: data.fromToken,
+    toChainId: data.toChainId ? data.toChainId.toString() : null,
+    bridgeFee: toBN(data.bridgeFee).toFixed(),
+  }),
+  swap: (data, type) => ({
+    type,
+    buyAmount: toBN(data.buyAmount).toFixed(),
+    sellAmount: toBN(data.sellAmount).toFixed(),
+    buyToken: data.buyToken,
+    sellToken: data.sellToken,
+    receiver: data.receiver,
+    protocol: utils.parseBytes32String(data.protocol || ""),
+  }),
+  upgrade: (data, type) => ({
+    type,
+    version: utils.parseBytes32String(data.version || ""),
+    walletImpl: data.walletImpl,
+  }),
+  "gas-topup": (data, type) => ({
+    type,
+    amount: toBN(data.amount).toFixed(),
+    token: data.token,
+    onBehalf: data.onBehalf,
+  }),
+  "dapp": (data, type) => ({
+    type,
+    name: data.name,
+    url: data.url,
+  }),
+  "deploy": (data, type) => ({
+    type,
+  }),
+  "permit2": (data, type) => ({
+    type,
+    token: data.token,
+    spender: data.spender,
+    amount: toBN(data.amount).toFixed(),
+    expiration: data.expiration,
+  }),
+  "cross-transfer": (data, type) => ({
+    type,
+    fromToken: data.fromToken,
+    toToken: data.toToken,
+    toChainId: data.toChainId ? data.toChainId.toString() : null,
+    amount: toBN(data.amount).toFixed(),
+    receiver: data.receiver,
+  }),
+  "auth": (data) => ({
+    type: data.remove ? "remove-authority" : "add-authority",
+    address: data.address,
+    chainId: data.chainId ? data.chainId.toString() : null,
+    remove: data.remove,
+  }),
+  "instadapp-pro": (data, type) => ({
+    type,
+    castDetails: data.castDetails,
+  }),
+  "rejection": (data, type) => ({
+    type,
+    id: data.id,
+  }),
+  "add-signers": (data, type) => ({
+    type,
+    addresses: data.signers,
+  }),
+  "remove-signers": (data, type) => ({
+    type,
+    addresses: data.signers,
+  }),
+  "change-threshold": (data, type) => ({
+    type,
+    count: data.count,
+  }),
+};
+
+const parseMetadata = (metadata: string) => {
+  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
+    );
+
+    const payloadFunc = typesPayload[type]
+    
+    if (payloadFunc) {
+      const payload = payloadFunc(decodedData, type)
+      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;
+};