@instadapp/avocado-base 0.0.1 → 0.0.3

package/utils/metadata.ts

@@ -0,0 +1,326 @@
+import { ethers, utils } from "ethers";
+import { Forwarder__factory } from "@/contracts";
+
+const multiMetadataTypes = ["bytes[]"];
+
+const metadataTypes = ["bytes32 type", "uint8 version", "bytes data"];
+
+const actionMetadataTypes = {
+  transfer: ["address token", "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"],
+  deploy: [],
+  permit2: [
+    "address token",
+    "address spender",
+    "uint160 amount",
+    "uint48 expiration",
+  ],
+};
+
+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: "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: "transfer",
+    encodedData,
+  });
+
+  return single ? encodeMultipleActions(data) : data;
+};
+
+export const encodeDeployMetadata = (single = true) => {
+  const data = encodeMetadata({
+    type: "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: "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: "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: "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]
+  );
+
+  console.log(params);
+
+  const data = encodeMetadata({
+    type: "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: "bridge",
+    encodedData,
+  });
+
+  return single ? encodeMultipleActions(data) : data;
+};
+
+export const encodeMultipleActions = (...actionData: string[]) => {
+  return ethers.utils.defaultAbiCoder.encode(multiMetadataTypes, [actionData]);
+};
+
+export const decodeMetadata = (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_;
+      }
+    } else {
+      const executeDataV2 = iface.decodeFunctionData("executeV2", data);
+      if (
+        executeDataV2.params_.metadata === "0x" ||
+        !executeDataV2.params_.metadata
+      ) {
+        return null;
+      } else {
+        metadata = executeDataV2.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 metadataArr;
+  } catch (e) {
+    console.log(e);
+    return null;
+  }
+};

package/utils/network.ts

@@ -1,21 +1,21 @@
 import { ethers } from "ethers";
-import {
-  AVO_PROD_CHAIN_NAME,
-  AVO_PROD_CHAIN_ID,
-  AVO_STAGING_CHAIN_NAME,
-  AVO_STAGING_RPC_URL,
-  AVO_PROD_RPC_URL,
-  AVO_STAGING_CHAIN_ID,
-} from "./avocado";
 
 export const bridgeDisabledNetworks = [1101];
 
 export const networks: Network[] = [
   {
     name: "Mainnet",
+    debankName: "eth",
+    ankrName: "eth",
     chainId: 1,
     params: {
       rpcUrls: ["https://rpc.ankr.com/eth"],
+      explorerUrl: "https://etherscan.io",
+      get serverRpcUrl() {
+        return process.env?.MAINNET_RPC_URL || this.rpcUrls[0];
+      },
+      balanceResolverAddress: "0x5b7D61b389D12e1f5873d0cCEe7E675915AB5F43",
+      usdcAddress: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
       nativeCurrency: {
         name: "Ethereum",
         symbol: "ETH",
@@ -25,6 +25,8 @@ export const networks: Network[] = [
   },
   {
     name: "Polygon",
+    debankName: "matic",
+    ankrName: "polygon",
     chainId: 137,
     params: {
       chainName: "Matic(Polygon) Mainnet",
@@ -33,12 +35,19 @@ export const networks: Network[] = [
         symbol: "MATIC",
         decimals: 18,
       },
+      balanceResolverAddress: "0x58632D23120b20650262b8A629a14e4F4043E0D9",
+      usdcAddress: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
       rpcUrls: ["https://polygon-rpc.com"],
-      blockExplorerUrls: ["https://polygonscan.com/"],
+      get serverRpcUrl() {
+        return process.env?.POLYGON_RPC_URL || this.rpcUrls[0];
+      },
+      explorerUrl: "https://polygonscan.com",
     },
   },
   {
     name: "Arbitrum",
+    debankName: "arb",
+    ankrName: "arbitrum",
     chainId: 42161,
     params: {
       chainName: "Arbitrum One",
@@ -47,12 +56,19 @@ export const networks: Network[] = [
         symbol: "ETH",
         decimals: 18,
       },
+      usdcAddress: "0xff970a61a04b1ca14834a43f5de4533ebddb5cc8",
+      balanceResolverAddress: "0xca5f37e6D8bB24c5A7958d5eccE7Bd9Aacc944f2",
+      get serverRpcUrl() {
+        return process.env?.ARBITRUM_RPC_URL || this.rpcUrls[0];
+      },
       rpcUrls: ["https://arb1.arbitrum.io/rpc"],
-      blockExplorerUrls: ["https://arbiscan.io"],
+      explorerUrl: "https://arbiscan.io",
     },
   },
   {
     name: "Optimism",
+    debankName: "op",
+    ankrName: "optimism",
     chainId: 10,
     params: {
       chainName: "Optimistic Ethereum",
@@ -61,30 +77,50 @@ export const networks: Network[] = [
         symbol: "ETH",
         decimals: 18,
       },
+      usdcAddress: "0x7f5c764cbc14f9669b88837ca1490cca17c31607",
+      balanceResolverAddress: "0xca5f37e6D8bB24c5A7958d5eccE7Bd9Aacc944f2",
+      get serverRpcUrl() {
+        return process.env?.OPTIMISM_RPC_URL || this.rpcUrls[0];
+      },
       rpcUrls: ["https://mainnet.optimism.io"],
-      blockExplorerUrls: ["https://optimistic.etherscan.io"],
+      explorerUrl: "https://optimistic.etherscan.io",
     },
   },
   {
     name: "Avalanche",
+    debankName: "avax",
+    ankrName: "avalanche",
     chainId: 43114,
     params: {
       chainName: "Avalanche Network",
+      get serverRpcUrl() {
+        return process.env?.AVALANCHE_RPC_URL || this.rpcUrls[0];
+      },
       nativeCurrency: {
         name: "Avalanche",
         symbol: "AVAX",
         decimals: 18,
       },
+      usdcAddress: "0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e",
+      balanceResolverAddress: "0x63009f31D054E0ac9F321Cf0D642375236A4Bf1E",
       rpcUrls: ["https://api.avax.network/ext/bc/C/rpc"],
-      blockExplorerUrls: ["https://snowtrace.io/"],
+      explorerUrl: "https://snowtrace.io",
     },
   },
   {
     name: "BSC",
+    debankName: "bsc",
+    ankrName: "bsc",
     chainId: 56,
     params: {
       chainName: "Binance Smart Chain",
+      explorerUrl: "https://bscscan.com",
       rpcUrls: ["https://rpc.ankr.com/bsc"],
+      get serverRpcUrl() {
+        return process.env?.BSC_RPC_URL || this.rpcUrls[0];
+      },
+      usdcAddress: "0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d",
+      balanceResolverAddress: "0xb808cff38706e267067b0af427726aa099f69f89",
       nativeCurrency: {
         name: "Binance Coin",
         symbol: "BNB",
@@ -94,10 +130,18 @@ export const networks: Network[] = [
   },
   {
     name: "Gnosis",
+    debankName: "xdai",
+    ankrName: "gnosis",
     chainId: 100,
     params: {
       chainName: "Gnosis Safe",
+      explorerUrl: "https://gnosisscan.io",
       rpcUrls: ["https://rpc.ankr.com/gnosis"],
+      get serverRpcUrl() {
+        return process.env?.GNOSIS_RPC_URL || this.rpcUrls[0];
+      },
+      balanceResolverAddress: "0xfaa244e276b1597f663975ed007ee4ff70d27849",
+      usdcAddress: "0xddafbb505ad214d7b80b1f830fccc89b60fb7a83",
       nativeCurrency: {
         name: "xdaistable",
         symbol: "xDAI",
@@ -110,7 +154,13 @@ export const networks: Network[] = [
     chainId: 1101,
     params: {
       chainName: "polygon zkEVM",
+      explorerUrl: "https://zkevm.polygonscan.com",
       rpcUrls: ["https://rpc.ankr.com/polygon_zkevm"],
+      get serverRpcUrl() {
+        return process.env?.POLYGON_ZKEVM_RPC_URL || this.rpcUrls[0];
+      },
+      balanceResolverAddress: "0x48D1Fa5Ee6691a1E0B45d2B515650997BEA27a01",
+      usdcAddress: "0xa8ce8aee21bc2a48a5ef670afcc9274c7bbbc035",
       nativeCurrency: {
         name: "Ethereum",
         symbol: "ETH",
@@ -121,6 +171,7 @@ export const networks: Network[] = [
   {
     name: AVO_PROD_CHAIN_NAME,
     chainId: AVO_PROD_CHAIN_ID,
+    isAvocado: true,
     params: {
       chainName: AVO_PROD_CHAIN_NAME,
       nativeCurrency: {
@@ -129,13 +180,17 @@ export const networks: Network[] = [
         decimals: 18,
       },
       iconUrls: ["https://avocado.instadapp.io/logo.svg"],
+      balanceResolverAddress: "",
+      usdcAddress: "",
+      serverRpcUrl: AVO_PROD_RPC_URL,
       rpcUrls: [AVO_PROD_RPC_URL],
-      blockExplorerUrls: ["https://avocado.instadapp.io"],
+      explorerUrl: AVO_PROD_EXPLORER_URL,
     },
   },
   {
     name: AVO_STAGING_CHAIN_NAME,
     chainId: AVO_STAGING_CHAIN_ID,
+    isAvocado: true,
     params: {
       chainName: AVO_STAGING_CHAIN_NAME,
       nativeCurrency: {
@@ -143,23 +198,24 @@ export const networks: Network[] = [
         symbol: "USDC",
         decimals: 18,
       },
+      serverRpcUrl: AVO_STAGING_RPC_URL,
+      balanceResolverAddress: "",
+      usdcAddress: "",
       iconUrls: ["https://avocado.instadapp.io/logo.svg"],
       rpcUrls: [AVO_STAGING_RPC_URL],
-      blockExplorerUrls: ["https://avocado.instadapp.io"],
+      explorerUrl: AVO_STAGING_EXPLORER_URL,
     },
   },
 ];
 
 export const getNetworkByChainId = (
-  chainId: Network["chainId"] | number | string
-) => {
-  return networks.find((i) => i.chainId === Number(chainId))!;
+  chainId: ChainId | number | string
+): Network => {
+  return networks.find((i) => i.chainId == chainId)!;
 };
 
 export const availableNetworks = networks.filter(
-  (network) =>
-    network.chainId != AVO_STAGING_CHAIN_ID &&
-    network.chainId != AVO_PROD_CHAIN_ID
+  (network) => !network.isAvocado
 );
 
 export const chainIdToName = (chainId: ChainId | number | string) => {
@@ -180,6 +236,18 @@ export const RPCMap = networks.reduce((acc, network) => {
 export const networkIds = networks.map((network) => network.chainId);
 
 const rpcInstances: Record<string, ethers.providers.JsonRpcProvider> = {};
+const serverRpcInstances: Record<string, ethers.providers.JsonRpcProvider> = {};
+
+export const getServerRpcProvider = (chainId: number | string) => {
+  if (!rpcInstances[chainId]) {
+    const network = networks.find((n) => n.chainId == chainId);
+    serverRpcInstances[chainId] = new ethers.providers.JsonRpcProvider(
+      network?.params.serverRpcUrl
+    );
+  }
+
+  return serverRpcInstances[chainId];
+};
 
 export const getRpcProvider = (chainId: number | string) => {
   if (!rpcInstances[chainId]) {
@@ -190,3 +258,11 @@ export const getRpcProvider = (chainId: number | string) => {
 
   return rpcInstances[chainId];
 };
+
+export const getExplorerUrl = (
+  chainId: ChainId | number | string,
+  suffix: `/${string}` = "/"
+) => {
+  const network = getNetworkByChainId(chainId);
+  return `${network.params.explorerUrl}${suffix}`;
+};

package/utils/utils.d.ts

@@ -1,12 +1,20 @@
 type ChainId = 1 | 137 | 42161 | 10 | 56 | 43114 | 100 | 1101 | 634 | 63400;
 
+type ISlackMessageType = "danger" | "error" | "success" | "banner";
+
 interface Network {
   name: string;
+  debankName?: string;
+  ankrName?: string;
   chainId: ChainId;
+  isAvocado?: boolean;
   params: {
     chainName?: string;
     rpcUrls: string[];
-    blockExplorerUrls?: string[];
+    serverRpcUrl: string | undefined;
+    balanceResolverAddress?: string;
+    usdcAddress: string;
+    explorerUrl: string;
     iconUrls?: string[];
     nativeCurrency?: {
       name: string;
@@ -15,3 +23,66 @@ interface Network {
     };
   };
 }
+
+type SignMetadataProps = {
+  token: string;
+  spender: string;
+  amount: string;
+  expiration: string;
+};
+
+type DappMetadataProps = {
+  name: string;
+  url: string;
+};
+
+type SendMetadataProps = {
+  token: string;
+  amount: string;
+  receiver: string;
+};
+
+type UpgradeMetadataProps = {
+  version: string;
+  walletImpl: string;
+};
+
+type TopupMetadataProps = {
+  amount: string;
+  token: string;
+  onBehalf: string;
+};
+
+type BridgeMetadataProps = {
+  amount: string;
+  receiver: string;
+  fromToken: string;
+  toToken: string;
+  toChainId: string;
+  bridgeFee: string;
+  nativeToken: string;
+};
+
+type SwapMetadataProps = {
+  sellToken: string;
+  buyToken: string;
+  sellAmount: string;
+  buyAmount: string;
+  receiver: string;
+  protocol?: string;
+};
+
+type MetadataProps = {
+  type:
+    | "transfer"
+    | "bridge"
+    | "swap"
+    | "multi"
+    | "gas-topup"
+    | "upgrade"
+    | "dapp"
+    | "deploy"
+    | "permit2";
+  encodedData: string;
+  version?: string;
+};