@cfxjs/sirius-next-common 0.0.7 → 0.0.9-patch.1

package/dist/chunk-6M3ESXKT.js

@@ -0,0 +1,1463 @@
+import {
+  Zero,
+  eventOne,
+  eventZero
+} from "./chunk-YTRCJJP7.js";
+
+// src/components/TransactionAction/minibus.ts
+import { Interface } from "@ethersproject/abi";
+import { formatUnits } from "@ethersproject/units";
+import { BigNumber } from "@ethersproject/bignumber";
+var ERC20_ABI = [
+  {
+    constant: true,
+    inputs: [],
+    name: "name",
+    outputs: [
+      {
+        name: "",
+        type: "string"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        name: "_spender",
+        type: "address"
+      },
+      {
+        name: "_value",
+        type: "uint256"
+      }
+    ],
+    name: "approve",
+    outputs: [
+      {
+        name: "",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "totalSupply",
+    outputs: [
+      {
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        name: "_from",
+        type: "address"
+      },
+      {
+        name: "_to",
+        type: "address"
+      },
+      {
+        name: "_value",
+        type: "uint256"
+      }
+    ],
+    name: "transferFrom",
+    outputs: [
+      {
+        name: "",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "decimals",
+    outputs: [
+      {
+        name: "",
+        type: "uint8"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [
+      {
+        name: "_owner",
+        type: "address"
+      }
+    ],
+    name: "balanceOf",
+    outputs: [
+      {
+        name: "balance",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "symbol",
+    outputs: [
+      {
+        name: "",
+        type: "string"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        name: "_to",
+        type: "address"
+      },
+      {
+        name: "_value",
+        type: "uint256"
+      }
+    ],
+    name: "transfer",
+    outputs: [
+      {
+        name: "",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [
+      {
+        name: "_owner",
+        type: "address"
+      },
+      {
+        name: "_spender",
+        type: "address"
+      }
+    ],
+    name: "allowance",
+    outputs: [
+      {
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    payable: true,
+    stateMutability: "payable",
+    type: "fallback"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        name: "owner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        name: "spender",
+        type: "address"
+      },
+      {
+        indexed: false,
+        name: "value",
+        type: "uint256"
+      }
+    ],
+    name: "Approval",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        name: "from",
+        type: "address"
+      },
+      {
+        indexed: true,
+        name: "to",
+        type: "address"
+      },
+      {
+        indexed: false,
+        name: "value",
+        type: "uint256"
+      }
+    ],
+    name: "Transfer",
+    type: "event"
+  }
+];
+var ERC721_ABI = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "owner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "approved",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "tokenId",
+        type: "uint256"
+      }
+    ],
+    name: "Approval",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "owner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "operator",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "bool",
+        name: "approved",
+        type: "bool"
+      }
+    ],
+    name: "ApprovalForAll",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "tokenId",
+        type: "uint256"
+      }
+    ],
+    name: "Transfer",
+    type: "event"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "tokenId",
+        type: "uint256"
+      }
+    ],
+    name: "approve",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "totalSupply",
+    outputs: [
+      {
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "owner",
+        type: "address"
+      }
+    ],
+    name: "balanceOf",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "balance",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "tokenId",
+        type: "uint256"
+      }
+    ],
+    name: "getApproved",
+    outputs: [
+      {
+        internalType: "address",
+        name: "operator",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "owner",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "operator",
+        type: "address"
+      }
+    ],
+    name: "isApprovedForAll",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "name",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "tokenId",
+        type: "uint256"
+      }
+    ],
+    name: "ownerOf",
+    outputs: [
+      {
+        internalType: "address",
+        name: "owner",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "tokenId",
+        type: "uint256"
+      }
+    ],
+    name: "safeTransferFrom",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "tokenId",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes",
+        name: "data",
+        type: "bytes"
+      }
+    ],
+    name: "safeTransferFrom",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "operator",
+        type: "address"
+      },
+      {
+        internalType: "bool",
+        name: "_approved",
+        type: "bool"
+      }
+    ],
+    name: "setApprovalForAll",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "interfaceId",
+        type: "bytes4"
+      }
+    ],
+    name: "supportsInterface",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "symbol",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "tokenId",
+        type: "uint256"
+      }
+    ],
+    name: "tokenURI",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "tokenId",
+        type: "uint256"
+      }
+    ],
+    name: "transferFrom",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var ERC1155_ABI = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "account",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "operator",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "bool",
+        name: "approved",
+        type: "bool"
+      }
+    ],
+    name: "ApprovalForAll",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "operator",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256[]",
+        name: "ids",
+        type: "uint256[]"
+      },
+      {
+        indexed: false,
+        internalType: "uint256[]",
+        name: "values",
+        type: "uint256[]"
+      }
+    ],
+    name: "TransferBatch",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "operator",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "id",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      }
+    ],
+    name: "TransferSingle",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "string",
+        name: "value",
+        type: "string"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "id",
+        type: "uint256"
+      }
+    ],
+    name: "URI",
+    type: "event"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "account",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "id",
+        type: "uint256"
+      }
+    ],
+    name: "balanceOf",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address[]",
+        name: "accounts",
+        type: "address[]"
+      },
+      {
+        internalType: "uint256[]",
+        name: "ids",
+        type: "uint256[]"
+      }
+    ],
+    name: "balanceOfBatch",
+    outputs: [
+      {
+        internalType: "uint256[]",
+        name: "",
+        type: "uint256[]"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "account",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "operator",
+        type: "address"
+      }
+    ],
+    name: "isApprovedForAll",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "uint256[]",
+        name: "ids",
+        type: "uint256[]"
+      },
+      {
+        internalType: "uint256[]",
+        name: "amounts",
+        type: "uint256[]"
+      },
+      {
+        internalType: "bytes",
+        name: "data",
+        type: "bytes"
+      }
+    ],
+    name: "safeBatchTransferFrom",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "id",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes",
+        name: "data",
+        type: "bytes"
+      }
+    ],
+    name: "safeTransferFrom",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "operator",
+        type: "address"
+      },
+      {
+        internalType: "bool",
+        name: "approved",
+        type: "bool"
+      }
+    ],
+    name: "setApprovalForAll",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "interfaceId",
+        type: "bytes4"
+      }
+    ],
+    name: "supportsInterface",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "id",
+        type: "uint256"
+      }
+    ],
+    name: "uri",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var ERC20_INTERFACE = new Interface(ERC20_ABI);
+var ERC721_INTERFACE = new Interface(ERC721_ABI);
+var ERC1155_INTERFACE = new Interface(ERC1155_ABI);
+var ActionTranslate = {
+  // transfer (ERC20)
+  "0xa9059cbb": (arg) => {
+    const { decimals, data, address, to } = arg;
+    const parsed = ERC20_INTERFACE.parseTransaction({ data });
+    const value = decimals ? formatUnits(parsed.args[1].toString(), decimals) : parsed.args[1].toString();
+    return {
+      type: "ERC20_Transfer",
+      title: "Transfer",
+      args: parsed.args,
+      address: to || address,
+      toAddress: parsed.args[0],
+      value,
+      customInfo: arg
+    };
+  },
+  // transferFrom (ERC20,ERC721)
+  "0x23b872dd": (arg) => {
+    const { decimals, data, address, to } = arg;
+    const parsed = ERC20_INTERFACE.parseTransaction({ data });
+    const value = decimals ? formatUnits(parsed.args[2].toString(), decimals) : parsed.args[2].toString();
+    if (parsed.args[1] === Zero) {
+      return {
+        type: "ERC721_Burn",
+        title: "Burn",
+        args: parsed.args,
+        value,
+        address: to || address,
+        customInfo: arg
+      };
+    }
+    const tokenInfo = arg?.token?.transferType || arg.transferType || filterByTokenAddress(arg.token, arg.to)?.token.transferType;
+    if (tokenInfo === "ERC721") {
+      return {
+        type: "ERC721_Transfer",
+        title: "Transfer",
+        args: parsed.args,
+        value: "1",
+        address: to || address,
+        toAddress: parsed.args[1],
+        customInfo: arg
+      };
+    }
+    return {
+      type: "ERC20_Transfer",
+      title: "Transfer",
+      args: parsed.args,
+      address: to || address,
+      toAddress: parsed.args[1],
+      value,
+      customInfo: arg
+    };
+  },
+  // approve (ERC20)
+  "0x095ea7b3": (arg) => {
+    const { data, address, to } = arg;
+    const parsed = ERC20_INTERFACE.parseTransaction({ data });
+    if (parsed.args[1].isZero()) {
+      return {
+        type: "ERC20_Revoked",
+        address: to || address,
+        toAddress: parsed.args[0],
+        title: "Revoked",
+        args: parsed.args,
+        customInfo: arg
+      };
+    } else {
+      return {
+        type: "ERC20_Approved",
+        address: to || address,
+        toAddress: parsed.args[0],
+        title: "Approved",
+        args: parsed.args,
+        customInfo: arg
+      };
+    }
+  },
+  // safeTransferFrom (ERC721)
+  "0x42842e0e": (arg) => {
+    const { data, address, to } = arg;
+    const parsed = ERC721_INTERFACE.parseTransaction({ data });
+    return {
+      type: "ERC721_SafeTransferFrom",
+      title: "Transfer",
+      args: parsed.args,
+      value: "1",
+      address: to || address,
+      toAddress: parsed.args[1],
+      customInfo: arg
+    };
+  },
+  // safeTransferFrom (ERC721)
+  "0xb88d4fde": (arg) => {
+    const { data, address, to } = arg;
+    const parsed = ERC721_INTERFACE.parseTransaction({ data });
+    return {
+      type: "ERC721_SafeTransferFrom",
+      title: "Transfer",
+      args: parsed.args,
+      value: "1",
+      address: to || address,
+      toAddress: parsed.args[0],
+      customInfo: arg
+    };
+  },
+  // setApprovalForAll (ERC721, ERC1155)
+  "0xa22cb465": (arg) => {
+    const { data, address, to } = arg;
+    const parsed = ERC721_INTERFACE.parseTransaction({ data });
+    const tokenInfo = arg?.token?.transferType || arg.transferType || filterByTokenAddress(arg.token, arg.to)?.token.transferType;
+    if (tokenInfo === "ERC721") {
+      if (parsed.args[1] === false) {
+        return {
+          type: "ERC721_Revoked",
+          title: "Revoked",
+          args: parsed.args,
+          address: to || address,
+          toAddress: parsed.args[0],
+          customInfo: arg
+        };
+      } else {
+        return {
+          type: "ERC721_Approved",
+          title: "Approved",
+          args: parsed.args,
+          address: to || address,
+          toAddress: parsed.args[0],
+          customInfo: arg
+        };
+      }
+    }
+    if (parsed.args[1] === false) {
+      return {
+        type: "ERC1155_Revoked",
+        title: "Revoked",
+        args: parsed.args,
+        address: to || address,
+        toAddress: parsed.args[0],
+        customInfo: arg
+      };
+    } else {
+      return {
+        type: "ERC1155_Approved",
+        title: "Approved",
+        args: parsed.args,
+        address: to || address,
+        toAddress: parsed.args[0],
+        customInfo: arg
+      };
+    }
+  },
+  // safeTransferFrom (ERC1155)
+  "0xf242432a": (arg) => {
+    const { data, address, to } = arg;
+    const parsed = ERC1155_INTERFACE.parseTransaction({ data });
+    const value = parsed.args[3].toString();
+    if (parsed.args[1] === Zero) {
+      return {
+        ...arg,
+        type: "ERC1155_Burn",
+        title: "Burn",
+        args: parsed.args,
+        value,
+        address: to || address,
+        toAddress: parsed.args[0],
+        customInfo: arg
+      };
+    } else {
+      return {
+        ...arg,
+        type: "ERC1155_SafeTransferFrom",
+        title: "Transfer",
+        args: parsed.args,
+        value,
+        address: to || address,
+        toAddress: parsed.args[0],
+        customInfo: arg
+      };
+    }
+  },
+  // safeBatchTransferFrom (ERC1155)
+  "0x2eb2c2d6": (arg) => {
+    const { data, address, to } = arg;
+    const parsed = ERC1155_INTERFACE.parseTransaction({ data });
+    const value = parsed.args[3].reduce((a, b) => a.add(b), BigNumber.from("0")).toString();
+    if (parsed.args[1] === Zero) {
+      return {
+        type: "ERC1155_BatchBurn",
+        title: "Burn",
+        args: parsed.args,
+        value,
+        address: to || address,
+        customInfo: arg
+      };
+    } else if (parsed.args[2] === Zero) {
+      return {
+        type: "ERC1155_BatchMint",
+        title: "Mint",
+        args: parsed.args,
+        address: to || address,
+        toAddress: parsed.args[0],
+        value,
+        customInfo: arg
+      };
+    }
+    return {
+      type: "ERC1155_SafeBatchTransferFrom",
+      title: "Transfer",
+      args: parsed.args,
+      value,
+      address: to || address,
+      customInfo: arg
+    };
+  }
+};
+var EventTranslate = {
+  // Approval (ERC20,ERC721)
+  "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925": (arg) => {
+    const { icon, symbol, decimals, name } = arg;
+    let methodId = "0x095ea7b3";
+    if (arg.topics.length > 3) {
+      methodId = "0xa22cb465";
+      if (arg.token) {
+        arg.token.transferType = "ERC721";
+      }
+      arg.transferType = "ERC721";
+      const parsed = ERC721_INTERFACE.parseLog(arg);
+      const value = parsed.args[2] instanceof BigNumber ? eventOne.substring(2) : eventZero.substring(2);
+      const eTransaction2 = {
+        ...arg,
+        data: methodId + arg.topics[2].substring(2) + value,
+        // spender, value
+        icon,
+        symbol,
+        decimals,
+        name
+      };
+      return ActionTranslate[methodId](eTransaction2);
+    }
+    const eTransaction = {
+      ...arg,
+      data: methodId + arg.topics[2].substring(2) + arg.data.substring(2),
+      // spender, value
+      icon,
+      symbol,
+      decimals,
+      name
+    };
+    return ActionTranslate[methodId](eTransaction);
+  },
+  // Transfer (ERC20,ERC721)
+  "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef": (arg) => {
+    const methodId = "0x23b872dd";
+    let eTransaction = {
+      ...arg
+    };
+    if (arg.data === "0x") {
+      if (arg.topics[1] === eventZero) {
+        return {
+          type: "ERC721_Mint",
+          title: "Mint",
+          args: [arg.topics[2], arg.topics[3]],
+          // to, tokenId
+          address: arg.address,
+          //`0x${Buffer.from(stripZeros(arg.topics[2])).toString('hex',)}`,
+          value: "1",
+          customInfo: arg
+        };
+      }
+      if (arg.topics[2] === eventZero) {
+        return {
+          type: "ERC721_Burn",
+          title: "Mint",
+          args: [arg.topics[2], arg.topics[3]],
+          // to, tokenId
+          address: arg.address,
+          //`0x${Buffer.from(stripZeros(arg.topics[2])).toString('hex',)}`,
+          value: "1",
+          customInfo: arg
+        };
+      } else {
+        eTransaction.decimals = 0;
+        if (arg.topics[2] === eventZero) {
+          eTransaction.data = methodId + arg.topics[1].substring(2) + arg.topics[2].substring(2) + "0000000000000000000000000000000000000000000000000000000000000001";
+        } else {
+          eTransaction.data = methodId + arg.topics[1].substring(2) + arg.topics[2].substring(2) + "0000000000000000000000000000000000000000000000000000000000000001";
+          if (eTransaction.token) {
+            eTransaction.token.transferType = "ERC721";
+          }
+          eTransaction.transferType = "ERC721";
+        }
+      }
+    } else {
+      if (arg.topics.length === 2) {
+        eTransaction.data = "0xa9059cbb" + arg.topics[1].substring(2) + arg.data.substring(2);
+        return ActionTranslate["0xa9059cbb"](eTransaction);
+      } else {
+        eTransaction.data = methodId + arg.topics[1].substring(2) + arg.topics[2].substring(2) + arg.data.substring(2);
+        return ActionTranslate[methodId](eTransaction);
+      }
+    }
+    return ActionTranslate[methodId](eTransaction);
+  },
+  // ApprovalForAll (ERC721, 1155)
+  "0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31": (arg) => {
+    const parsed = ERC1155_INTERFACE.parseLog(arg);
+    const tokenInfo = arg?.token?.transferType || arg.transferType || filterByTokenAddress(arg.token, arg.to || arg.address)?.token.transferType;
+    if (tokenInfo === "ERC721") {
+      if (parsed.args[2] === false) {
+        return {
+          ...arg,
+          type: "ERC721_Revoked",
+          title: "Revoked",
+          args: parsed.args,
+          address: arg.address,
+          toAddress: parsed.args[1],
+          customInfo: arg
+        };
+      } else {
+        return {
+          ...arg,
+          type: "ERC721_Approved",
+          title: "Approved",
+          args: parsed.args,
+          address: arg.address,
+          toAddress: parsed.args[1],
+          customInfo: arg
+        };
+      }
+    }
+    if (parsed.args[2] === false) {
+      return {
+        ...arg,
+        type: "ERC1155_Revoked",
+        title: "Revoked",
+        args: parsed.args,
+        address: arg.address,
+        toAddress: parsed.args[1],
+        customInfo: arg
+      };
+    } else {
+      return {
+        ...arg,
+        type: "ERC1155_Approved",
+        title: "Approved",
+        args: parsed.args,
+        address: arg.address,
+        toAddress: parsed.args[1],
+        customInfo: arg
+      };
+    }
+  },
+  // TransferSingle (ERC1155)
+  "0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62": (arg) => {
+    const parsed = ERC1155_INTERFACE.parseLog(arg);
+    let value;
+    if (Array.isArray(parsed.args[4])) {
+      value = parsed.args[4].reduce((a, b) => a.add(b), BigNumber.from("0")).toString();
+    } else {
+      value = parsed.args[4].toString();
+    }
+    if (parsed.args[1] === Zero && parsed.args[2] !== Zero) {
+      return {
+        type: "ERC1155_Mint",
+        address: arg.address,
+        toAddress: parsed.args[0],
+        title: "Mint",
+        args: parsed.args,
+        value,
+        customInfo: arg
+      };
+    }
+    if (parsed.args[2] === Zero && parsed.args[1] !== Zero) {
+      return {
+        type: "ERC1155_Burn",
+        address: arg.address,
+        toAddress: parsed.args[0],
+        title: "Mint",
+        args: parsed.args,
+        value,
+        customInfo: arg
+      };
+    }
+    return {
+      type: "ERC1155_Transfer",
+      title: "TransferSingle",
+      args: parsed.args,
+      address: arg.address,
+      toAddress: parsed.args[0],
+      value,
+      customInfo: arg
+    };
+  },
+  // TransferBatch (ERC1155)
+  "0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb": (arg) => {
+    const parsed = ERC1155_INTERFACE.parseLog(arg);
+    const value = parsed.args[4].reduce((a, b) => a.add(b), BigNumber.from("0")).toString();
+    if (parsed.args[2] === Zero) {
+      return {
+        type: "ERC1155_BatchBurn",
+        title: "Burn",
+        args: parsed.args,
+        address: arg.address,
+        toAddress: parsed.args[0],
+        value,
+        customInfo: arg
+      };
+    } else if (parsed.args[1] === Zero) {
+      return {
+        type: "ERC1155_BatchMint",
+        title: "Mint",
+        args: parsed.args,
+        address: arg.address,
+        toAddress: parsed.args[0],
+        value,
+        customInfo: arg
+      };
+    }
+    return {
+      type: "ERC1155_SafeBatchTransferFrom",
+      title: "Transfer",
+      args: parsed.args,
+      address: arg.address,
+      toAddress: parsed.args[0],
+      value,
+      customInfo: arg
+    };
+  }
+};
+function isObjectAndNotEmpty(obj) {
+  return obj !== null && typeof obj === "object" && !Array.isArray(obj) && Object.keys(obj).length > 0;
+}
+var filterByTokenAddress = (data, address) => {
+  if (Array.isArray(data)) {
+    const found = data.find((item) => item.token?.address === address);
+    return found ?? void 0;
+  } else if (typeof data === "object" && data !== null) {
+    if (data.token?.address === address) {
+      return data;
+    }
+  }
+  return void 0;
+};
+var decodeData = (transaction, event, customInfo, customUI) => {
+  try {
+    if (!isObjectAndNotEmpty(transaction))
+      return {
+        args: void 0,
+        content: void 0
+      };
+    let result;
+    let dataContent = [];
+    let methodId = transaction?.data?.slice(0, 10) ?? "";
+    if (ActionTranslate[methodId]) {
+      result = ActionTranslate[methodId]({
+        token: customInfo,
+        ...transaction
+      });
+      const actionType = result.type;
+      if (actionType && customUI && customUI[actionType]) {
+        const customResult = customUI[actionType](result);
+        dataContent.push(customResult);
+      }
+    }
+    if (dataContent && dataContent.length > 0 && event && event.length > 0) {
+      let eventContent = [];
+      event.forEach((e, i) => {
+        const evnetHash = e.topics[0];
+        if (customUI && evnetHash && EventTranslate[evnetHash]) {
+          const eResult = EventTranslate[evnetHash]({
+            token: customInfo,
+            ...e
+          });
+          if ([
+            "0x23b872dd",
+            "0x42842e0e",
+            "0xb88d4fde",
+            "0xf242432a",
+            "0x2eb2c2d6"
+          ].includes(methodId) && (eResult.type === "ERC721_Revoked" || eResult.type === "ERC721_Approved")) {
+            return;
+          }
+          const actionType = eResult.type;
+          if (evnetHash && customUI[actionType]) {
+            eventContent.push(customUI[actionType](eResult));
+          }
+        }
+      });
+      if (eventContent.length > 0) {
+        dataContent = eventContent;
+      }
+    }
+    if (dataContent && dataContent.length === 0 && event && event.length > 0 && customUI) {
+      let eventContent = [];
+      let eResultArr = [];
+      event.forEach((e, i) => {
+        const EventWihtelist = [
+          "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+          "0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62",
+          "0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb"
+        ];
+        if (e.topics[0] && EventWihtelist.includes(e.topics[0])) {
+          if ([
+            "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
+          ].includes(e.topics[0]) && e.data !== "0x") {
+            return;
+          }
+          if (!(e.topics[1] === eventZero || e.topics[2] === eventZero)) {
+            return;
+          }
+          const evnetHash = e.topics[0];
+          if (EventTranslate[evnetHash]) {
+            const eResult = EventTranslate[evnetHash]({
+              token: customInfo,
+              ...e
+            });
+            const actionType = eResult.type;
+            if (customUI[actionType]) {
+              eResultArr.push(eResult);
+            }
+          }
+        }
+      });
+      const uniqueArray = eResultArr.reduce(
+        (acc, current) => {
+          const found = acc.find(
+            (item) => item["address"] === current["address"] && [
+              "ERC721_Mint",
+              "ERC721_Burn",
+              "ERC721_Transfer",
+              "ERC1155_Mint",
+              "ERC1155_Burn",
+              "ERC1155_Transfer"
+            ].includes(item["type"])
+          );
+          if (found) {
+            found.value = Number(found.value) + Number(current.value);
+          } else {
+            acc.push(current);
+          }
+          return acc;
+        },
+        []
+      );
+      uniqueArray.forEach((item) => {
+        eventContent.push(customUI[item.type](item));
+      });
+      if (eventContent.length > 0) {
+        dataContent = eventContent;
+      }
+    }
+    return {
+      args: result && result.args,
+      content: dataContent
+    };
+  } catch (error) {
+    return {
+      args: void 0,
+      content: void 0
+    };
+  }
+};
+
+export {
+  filterByTokenAddress,
+  decodeData
+};
+//# sourceMappingURL=chunk-6M3ESXKT.js.map