@primuslabs/fund-js-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1383 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PrimusFund: () => PrimusFund
+});
+module.exports = __toCommonJS(index_exports);
+var import_ethers3 = require("ethers");
+
+// src/classes/Fund.ts
+var import_ethers2 = require("ethers");
+var import_zktls_js_sdk = require("@primuslabs/zktls-js-sdk");
+
+// src/config/constants.ts
+var Fund_CONTRACTS = {
+  // monad testnet
+  10143: "0xcd1Ed9C1595A7e9DADe76808dd5e66aA95940A92"
+};
+var SUPPORTEDCHAINIDS = Object.keys(Fund_CONTRACTS).map((i) => Number(i));
+var DATASOURCETEMPLATEMAP = {
+  x: "2e3160ae-8b1e-45e3-8c59-426366278b9d",
+  tiktok: "2b22c9f8-686d-4482-a0cf-c9c43c1181ad",
+  "google account": ""
+};
+var SUPPORTEDSOCIALPLATFORMS = Object.keys(DATASOURCETEMPLATEMAP);
+
+// src/classes/Contract.ts
+var import_ethers = require("ethers");
+var Contract = class {
+  address;
+  provider;
+  contractInstance;
+  /**
+   * @param chainName The name of the chain, used to identify and differentiate between different chains.
+   * @param provider The provider object for the blockchain, used to establish and manage the connection with the blockchain.
+   */
+  constructor(provider, address, abiJson) {
+    if (!provider || !address || !abiJson) {
+      throw new Error("provider, address, and abiJson are required");
+    }
+    this.address = address;
+    this.provider = provider;
+    const signer = this.provider.getSigner();
+    this.contractInstance = new import_ethers.ethers.Contract(this.address, abiJson, signer);
+  }
+  // Example method to read from the contract
+  async callMethod(functionName, functionParams) {
+    return new Promise(async (resolve, reject) => {
+      if (!this.contractInstance[functionName]) {
+        return reject(`Method ${functionName} does not exist on the contract`);
+      }
+      try {
+        const result = await this.contractInstance[functionName](...functionParams);
+        return resolve(result);
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  // Example method to send a transaction
+  async sendTransaction(functionName, functionParams) {
+    return new Promise(async (resolve, reject) => {
+      if (!this.contractInstance[functionName]) {
+        return reject(`Method ${functionName} does not exist on the contract`);
+      }
+      try {
+        console.log("sendTransaction params:", ...functionParams);
+        const tx = await this.contractInstance[functionName](...functionParams);
+        const txreceipt = await tx.wait();
+        console.log("txreceipt", txreceipt);
+        resolve(txreceipt);
+      } catch (error) {
+        console.log("sendTransaction error:", error);
+        if (error?.code === "ACTION_REJECTED") {
+          return reject("user rejected transaction");
+        }
+        if (error?.reason) {
+          return reject(error.reason);
+        }
+        if (error?.data?.message === "insufficient balance") {
+          return reject(error?.data?.message);
+        }
+      }
+    });
+  }
+};
+var Contract_default = Contract;
+
+// src/config/abi.json
+var abi_default = [
+  {
+    type: "function",
+    name: "addBatchIdSource",
+    inputs: [
+      { name: "sourceName_", type: "string[]", internalType: "string[]" },
+      { name: "url_", type: "string[]", internalType: "string[]" },
+      { name: "jsonPath_", type: "string[]", internalType: "string[]" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "claimByMultiSource",
+    inputs: [
+      { name: "idSources", type: "string[]", internalType: "string[]" },
+      {
+        name: "att",
+        type: "tuple[]",
+        internalType: "struct Attestation[]",
+        components: [
+          { name: "recipient", type: "address", internalType: "address" },
+          {
+            name: "request",
+            type: "tuple",
+            internalType: "struct AttNetworkRequest",
+            components: [
+              { name: "url", type: "string", internalType: "string" },
+              { name: "header", type: "string", internalType: "string" },
+              { name: "method", type: "string", internalType: "string" },
+              { name: "body", type: "string", internalType: "string" }
+            ]
+          },
+          {
+            name: "reponseResolve",
+            type: "tuple[]",
+            internalType: "struct AttNetworkResponseResolve[]",
+            components: [
+              { name: "keyName", type: "string", internalType: "string" },
+              {
+                name: "parseType",
+                type: "string",
+                internalType: "string"
+              },
+              {
+                name: "parsePath",
+                type: "string",
+                internalType: "string"
+              }
+            ]
+          },
+          { name: "data", type: "string", internalType: "string" },
+          {
+            name: "attConditions",
+            type: "string",
+            internalType: "string"
+          },
+          { name: "timestamp", type: "uint64", internalType: "uint64" },
+          {
+            name: "additionParams",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "attestors",
+            type: "tuple[]",
+            internalType: "struct Attestor[]",
+            components: [
+              {
+                name: "attestorAddr",
+                type: "address",
+                internalType: "address"
+              },
+              { name: "url", type: "string", internalType: "string" }
+            ]
+          },
+          { name: "signatures", type: "bytes[]", internalType: "bytes[]" }
+        ]
+      }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "claimBySource",
+    inputs: [
+      { name: "idSource", type: "string", internalType: "string" },
+      {
+        name: "att",
+        type: "tuple",
+        internalType: "struct Attestation",
+        components: [
+          { name: "recipient", type: "address", internalType: "address" },
+          {
+            name: "request",
+            type: "tuple",
+            internalType: "struct AttNetworkRequest",
+            components: [
+              { name: "url", type: "string", internalType: "string" },
+              { name: "header", type: "string", internalType: "string" },
+              { name: "method", type: "string", internalType: "string" },
+              { name: "body", type: "string", internalType: "string" }
+            ]
+          },
+          {
+            name: "reponseResolve",
+            type: "tuple[]",
+            internalType: "struct AttNetworkResponseResolve[]",
+            components: [
+              { name: "keyName", type: "string", internalType: "string" },
+              {
+                name: "parseType",
+                type: "string",
+                internalType: "string"
+              },
+              {
+                name: "parsePath",
+                type: "string",
+                internalType: "string"
+              }
+            ]
+          },
+          { name: "data", type: "string", internalType: "string" },
+          {
+            name: "attConditions",
+            type: "string",
+            internalType: "string"
+          },
+          { name: "timestamp", type: "uint64", internalType: "uint64" },
+          {
+            name: "additionParams",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "attestors",
+            type: "tuple[]",
+            internalType: "struct Attestor[]",
+            components: [
+              {
+                name: "attestorAddr",
+                type: "address",
+                internalType: "address"
+              },
+              { name: "url", type: "string", internalType: "string" }
+            ]
+          },
+          { name: "signatures", type: "bytes[]", internalType: "bytes[]" }
+        ]
+      }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "claimBySourceAndTipIndex",
+    inputs: [
+      { name: "idSource", type: "string", internalType: "string" },
+      {
+        name: "att",
+        type: "tuple",
+        internalType: "struct Attestation",
+        components: [
+          { name: "recipient", type: "address", internalType: "address" },
+          {
+            name: "request",
+            type: "tuple",
+            internalType: "struct AttNetworkRequest",
+            components: [
+              { name: "url", type: "string", internalType: "string" },
+              { name: "header", type: "string", internalType: "string" },
+              { name: "method", type: "string", internalType: "string" },
+              { name: "body", type: "string", internalType: "string" }
+            ]
+          },
+          {
+            name: "reponseResolve",
+            type: "tuple[]",
+            internalType: "struct AttNetworkResponseResolve[]",
+            components: [
+              { name: "keyName", type: "string", internalType: "string" },
+              {
+                name: "parseType",
+                type: "string",
+                internalType: "string"
+              },
+              {
+                name: "parsePath",
+                type: "string",
+                internalType: "string"
+              }
+            ]
+          },
+          { name: "data", type: "string", internalType: "string" },
+          {
+            name: "attConditions",
+            type: "string",
+            internalType: "string"
+          },
+          { name: "timestamp", type: "uint64", internalType: "uint64" },
+          {
+            name: "additionParams",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "attestors",
+            type: "tuple[]",
+            internalType: "struct Attestor[]",
+            components: [
+              {
+                name: "attestorAddr",
+                type: "address",
+                internalType: "address"
+              },
+              { name: "url", type: "string", internalType: "string" }
+            ]
+          },
+          { name: "signatures", type: "bytes[]", internalType: "bytes[]" }
+        ]
+      },
+      { name: "index", type: "uint32", internalType: "uint32" }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "claimFee",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "feeRecipient",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getTipRecords",
+    inputs: [
+      {
+        name: "tipRecipient",
+        type: "tuple",
+        internalType: "struct TipRecipient",
+        components: [
+          { name: "idSource", type: "string", internalType: "string" },
+          { name: "id", type: "string", internalType: "string" }
+        ]
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple[]",
+        internalType: "struct TipRecord[]",
+        components: [
+          { name: "amount", type: "uint256", internalType: "uint256" },
+          {
+            name: "tipToken",
+            type: "tuple",
+            internalType: "struct TipToken",
+            components: [
+              {
+                name: "tokenType",
+                type: "uint32",
+                internalType: "uint32"
+              },
+              {
+                name: "tokenAddress",
+                type: "address",
+                internalType: "address"
+              }
+            ]
+          },
+          { name: "timestamp", type: "uint64", internalType: "uint64" },
+          { name: "tipper", type: "address", internalType: "address" },
+          { name: "nftIds", type: "uint256[]", internalType: "uint256[]" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "idSourceCache",
+    inputs: [{ name: "", type: "string", internalType: "string" }],
+    outputs: [
+      { name: "url", type: "string", internalType: "string" },
+      { name: "jsonPath", type: "string", internalType: "string" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "initialize",
+    inputs: [
+      { name: "owner", type: "address", internalType: "address" },
+      {
+        name: "primusZKTLS_",
+        type: "address",
+        internalType: "contract IPrimusZKTLS"
+      },
+      { name: "feeRecipient_", type: "address", internalType: "address" },
+      { name: "claimFee_", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "owner",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "primusZKTLS",
+    inputs: [],
+    outputs: [
+      { name: "", type: "address", internalType: "contract IPrimusZKTLS" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "renounceOwnership",
+    inputs: [],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setClaimFee",
+    inputs: [
+      { name: "claimFee_", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setFeeRecipient",
+    inputs: [
+      { name: "feeRecipient_", type: "address", internalType: "address" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setPrimusZKTLS",
+    inputs: [
+      {
+        name: "primusZKTLS_",
+        type: "address",
+        internalType: "contract IPrimusZKTLS"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setWithdrawDelay",
+    inputs: [
+      { name: "delay", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "tip",
+    inputs: [
+      {
+        name: "token",
+        type: "tuple",
+        internalType: "struct TipToken",
+        components: [
+          { name: "tokenType", type: "uint32", internalType: "uint32" },
+          {
+            name: "tokenAddress",
+            type: "address",
+            internalType: "address"
+          }
+        ]
+      },
+      {
+        name: "recipient",
+        type: "tuple",
+        internalType: "struct TipRecipientInfo",
+        components: [
+          { name: "idSource", type: "string", internalType: "string" },
+          { name: "id", type: "string", internalType: "string" },
+          { name: "amount", type: "uint256", internalType: "uint256" },
+          { name: "nftIds", type: "uint256[]", internalType: "uint256[]" }
+        ]
+      }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "tipBatch",
+    inputs: [
+      {
+        name: "token",
+        type: "tuple",
+        internalType: "struct TipToken",
+        components: [
+          { name: "tokenType", type: "uint32", internalType: "uint32" },
+          {
+            name: "tokenAddress",
+            type: "address",
+            internalType: "address"
+          }
+        ]
+      },
+      {
+        name: "recipients",
+        type: "tuple[]",
+        internalType: "struct TipRecipientInfo[]",
+        components: [
+          { name: "idSource", type: "string", internalType: "string" },
+          { name: "id", type: "string", internalType: "string" },
+          { name: "amount", type: "uint256", internalType: "uint256" },
+          { name: "nftIds", type: "uint256[]", internalType: "uint256[]" }
+        ]
+      }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "tipperWithdraw",
+    inputs: [
+      {
+        name: "tipRecipients",
+        type: "tuple[]",
+        internalType: "struct TipRecipient[]",
+        components: [
+          { name: "idSource", type: "string", internalType: "string" },
+          { name: "id", type: "string", internalType: "string" }
+        ]
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "transferOwnership",
+    inputs: [
+      { name: "newOwner", type: "address", internalType: "address" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "withdrawDelay",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "ClaimEvent",
+    inputs: [
+      {
+        name: "recipient",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "idSource",
+        type: "string",
+        indexed: false,
+        internalType: "string"
+      },
+      {
+        name: "id",
+        type: "string",
+        indexed: false,
+        internalType: "string"
+      },
+      {
+        name: "tipper",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      },
+      {
+        name: "tokenAddr",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Initialized",
+    inputs: [
+      {
+        name: "version",
+        type: "uint64",
+        indexed: false,
+        internalType: "uint64"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "OwnershipTransferred",
+    inputs: [
+      {
+        name: "previousOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "newOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "TipEvent",
+    inputs: [
+      {
+        name: "idSource",
+        type: "string",
+        indexed: false,
+        internalType: "string"
+      },
+      {
+        name: "id",
+        type: "string",
+        indexed: false,
+        internalType: "string"
+      },
+      {
+        name: "tipper",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "WithdrawEvent",
+    inputs: [
+      {
+        name: "tipper",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "tokenAddr",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  { type: "error", name: "InvalidInitialization", inputs: [] },
+  { type: "error", name: "NotInitializing", inputs: [] },
+  {
+    type: "error",
+    name: "OwnableInvalidOwner",
+    inputs: [
+      { name: "owner", type: "address", internalType: "address" }
+    ]
+  },
+  {
+    type: "error",
+    name: "OwnableUnauthorizedAccount",
+    inputs: [
+      { name: "account", type: "address", internalType: "address" }
+    ]
+  },
+  { type: "error", name: "ReentrancyGuardReentrantCall", inputs: [] }
+];
+
+// src/config/erc20Abi.json
+var erc20Abi_default = [
+  {
+    type: "function",
+    name: "allowance",
+    inputs: [
+      {
+        name: "owner",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "spender",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "approve",
+    inputs: [
+      {
+        name: "spender",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "value",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "decimals",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint8",
+        internalType: "uint8"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "name",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "symbol",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totalSupply",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      {
+        name: "to",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "value",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "transferFrom",
+    inputs: [
+      {
+        name: "from",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "to",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "value",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "Approval",
+    inputs: [
+      {
+        name: "owner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "spender",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "value",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      {
+        name: "from",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "to",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "value",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "error",
+    name: "ERC20InsufficientAllowance",
+    inputs: [
+      {
+        name: "spender",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "allowance",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "needed",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ERC20InsufficientBalance",
+    inputs: [
+      {
+        name: "sender",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "balance",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "needed",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ERC20InvalidApprover",
+    inputs: [
+      {
+        name: "approver",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ERC20InvalidReceiver",
+    inputs: [
+      {
+        name: "receiver",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ERC20InvalidSender",
+    inputs: [
+      {
+        name: "sender",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ERC20InvalidSpender",
+    inputs: [
+      {
+        name: "spender",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  }
+];
+
+// src/classes/Fund.ts
+var Fund = class {
+  _attestLoading;
+  zkTlsSdk;
+  fundContract;
+  provider;
+  _dataSourceTemplateMap = DATASOURCETEMPLATEMAP;
+  constructor() {
+    this._attestLoading = false;
+  }
+  getZkTlsSdk() {
+    return this.zkTlsSdk;
+  }
+  async init(provider, chainId, appId) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const network = await provider.getNetwork();
+        const providerChainId = network.chainId;
+        console.log("init provider", provider, network);
+        if (providerChainId !== chainId) {
+          return reject(`Please connect to the chain with ID ${chainId} first.`);
+        }
+        const fundContractAddress = Fund_CONTRACTS[chainId];
+        if (!fundContractAddress) {
+          return reject(`Unsupported chainId:${chainId}`);
+        }
+        this.fundContract = new Contract_default(provider, fundContractAddress, abi_default);
+        this.provider = provider;
+        if (appId) {
+          this.zkTlsSdk = new import_zktls_js_sdk.PrimusZKTLS();
+          const extensionVersion = await this.zkTlsSdk.init(
+            appId
+          );
+          resolve(extensionVersion);
+        } else {
+          resolve("success");
+        }
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  async fund(tokenInfo, recipientInfo) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const recipientInfos = [];
+        recipientInfos[0] = recipientInfo;
+        let decimals = 18;
+        let params = [];
+        if (tokenInfo.tokenType === 0) {
+          await this.approve(tokenInfo, recipientInfos);
+          const erc20Contract = new import_ethers2.ethers.Contract(tokenInfo.tokenAddress, erc20Abi_default, this.provider);
+          decimals = await erc20Contract.decimals();
+        }
+        const tokenAmount = import_ethers2.ethers.utils.parseUnits(recipientInfo.tokenAmount.toString(), decimals);
+        const newFundRecipientInfo = {
+          idSource: recipientInfo.socialPlatform,
+          id: recipientInfo.userIdentifier,
+          amount: tokenAmount,
+          nftIds: []
+        };
+        if (tokenInfo.tokenType === 0) {
+          params = [tokenInfo, newFundRecipientInfo];
+        } else {
+          params = [tokenInfo, newFundRecipientInfo, { value: tokenAmount }];
+        }
+        const result = await this.fundContract.sendTransaction("tip", params);
+        resolve(result);
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  async refund(recipients) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const newRecipients = recipients.map((i) => {
+          return {
+            idSource: i.socialPlatform,
+            id: i.userIdentifier
+          };
+        });
+        const result = await this.fundContract.sendTransaction("tipperWithdraw", [newRecipients]);
+        return resolve(result);
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  async fundBatch(tokenInfo, recipientInfoList) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        let decimals = 18;
+        let params = [];
+        if (tokenInfo.tokenType === 0) {
+          await this.approve(tokenInfo, recipientInfoList);
+          const erc20Contract = new import_ethers2.ethers.Contract(tokenInfo.tokenAddress, erc20Abi_default, this.provider);
+          decimals = await erc20Contract.decimals();
+        }
+        let totalFormatAmount = recipientInfoList.reduce((acc, cur) => acc.add(import_ethers2.ethers.utils.parseUnits(cur.tokenAmount.toString(), decimals)), import_ethers2.ethers.BigNumber.from(0));
+        const newRecipientInfoList = recipientInfoList.map((i) => {
+          const formatAmount = import_ethers2.ethers.utils.parseUnits(i.tokenAmount.toString(), decimals);
+          return {
+            idSource: i.socialPlatform,
+            id: i.userIdentifier,
+            amount: formatAmount,
+            nftIds: []
+          };
+        });
+        if (tokenInfo.tokenType === 0) {
+          params = [tokenInfo, newRecipientInfoList];
+        } else {
+          params = [tokenInfo, newRecipientInfoList, { value: totalFormatAmount }];
+        }
+        const result = await this.fundContract.sendTransaction("tipBatch", params);
+        return resolve(result);
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  async approve(tokenInfo, recipientInfoList) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const signer = this.provider.getSigner();
+        const address = await signer.getAddress();
+        const erc20Contract = new import_ethers2.ethers.Contract(tokenInfo.tokenAddress, erc20Abi_default, signer);
+        const allowance = await erc20Contract.allowance(address, this.fundContract.address);
+        const decimals = await erc20Contract.decimals();
+        const requiredAllowance = recipientInfoList.reduce((acc, cur) => acc.add(import_ethers2.ethers.utils.parseUnits(cur.tokenAmount.toString(), decimals)), import_ethers2.ethers.BigNumber.from(0));
+        if (allowance.lt(requiredAllowance)) {
+          const tx = await erc20Contract.approve(this.fundContract.address, requiredAllowance);
+          await tx.wait();
+          console.log(`Approved: ${requiredAllowance.toString()}`);
+        } else {
+          console.log(`Already approved: ${allowance.toString()}`);
+        }
+        resolve("Approved");
+      } catch (error) {
+        console.error("Approval failed:", error);
+        if (error?.code === "ACTION_REJECTED") {
+          return reject("user rejected transaction");
+        }
+        return reject(error);
+      }
+    });
+  }
+  async attest(socialPlatform, address, genAppSignature) {
+    return new Promise(async (resolve, reject) => {
+      if (!this.zkTlsSdk?.padoExtensionVersion) {
+        return reject(`Uninitialized!`);
+      }
+      if (this._attestLoading) {
+        return reject(`Under proof!`);
+      }
+      this._attestLoading = true;
+      const templateId = this._dataSourceTemplateMap[socialPlatform];
+      const attRequest = this.zkTlsSdk.generateRequestParams(
+        templateId,
+        address
+      );
+      const signParams = attRequest.toJsonString();
+      const signature = await genAppSignature(signParams);
+      if (!signature) {
+        return reject(`appSignature is empty!`);
+      }
+      try {
+        const formatAttestParams = {
+          attRequest: {
+            ...JSON.parse(signParams)
+          },
+          appSignature: signature
+        };
+        const attestation = await this.zkTlsSdk.startAttestation(
+          JSON.stringify(formatAttestParams)
+        );
+        this._attestLoading = false;
+        resolve(attestation);
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  async claimBySource(socialPlatform, userIdentifier, attestation) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const claimFee = await this.fundContract.callMethod("claimFee", []);
+        const fundRecords = await this.fundContract.callMethod("getTipRecords", [{ idSource: socialPlatform, id: userIdentifier }]);
+        console.log("fundRecords", fundRecords);
+        const recordCount = fundRecords.length;
+        if (fundRecords <= 0) {
+          return reject(`No fund records.`);
+        } else {
+          const totalFee = claimFee.mul(recordCount);
+          const txreceipt = await this.fundContract.sendTransaction("claimBySource", [socialPlatform, attestation, { value: totalFee }]);
+          return resolve(txreceipt);
+        }
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  async claimByMultiSource(socialPlatforms, userIdentifiers, attestationList) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        if (socialPlatforms.length !== userIdentifiers.length || socialPlatforms.length !== attestationList.length) {
+          return reject(`socialPlatforms, userIdentifiers, attestationList length must be equal.`);
+        }
+        const claimFee = await this.fundContract.callMethod("claimFee", []);
+        let allFundRecords = [];
+        let recordCount = 0;
+        for (const [index, value] of socialPlatforms.entries()) {
+          const fundRecords = await this.fundContract.callMethod("getTipRecords", [{ idSource: value, id: userIdentifiers[index] }]);
+          allFundRecords.push(...fundRecords);
+          recordCount += fundRecords.length;
+        }
+        if (recordCount <= 0) {
+          return reject(`No fund records.`);
+        } else {
+          const totalFee = claimFee.mul(recordCount);
+          const txreceipt = await this.fundContract.sendTransaction("claimByMultiSource", [socialPlatforms, userIdentifiers, attestationList, { value: totalFee }]);
+          return resolve(txreceipt);
+        }
+      } catch (error) {
+        console.error("claimByMultiSource", error);
+        return reject(error);
+      }
+    });
+  }
+};
+
+// src/index.ts
+var PrimusFund = class {
+  supportedChainIds = SUPPORTEDCHAINIDS;
+  supportedSocialPlatforms = SUPPORTEDSOCIALPLATFORMS;
+  _fund;
+  async init(provider, chainId, appId) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        if (!this.supportedChainIds.includes(chainId)) {
+          return reject("chainId is not supported");
+        }
+        this._fund = new Fund();
+        const result = await this._fund.init(new import_ethers3.ethers.providers.Web3Provider(provider), chainId, appId);
+        return resolve(result);
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  async fund(fundParam) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const { tokenInfo, recipientInfos } = fundParam;
+        if (!recipientInfos || recipientInfos.length === 0) {
+          return reject("recipientInfos is empty");
+        }
+        const hasUnsupportedSocialPlatforms = recipientInfos.some((i) => !this.supportedSocialPlatforms.includes(i.socialPlatform.toLowerCase()));
+        if (hasUnsupportedSocialPlatforms) {
+          return reject("socialPlatform is not supported");
+        }
+        if (tokenInfo.tokenType === 1) {
+          tokenInfo.tokenAddress = import_ethers3.ethers.constants.AddressZero;
+        }
+        const newFundRecipientInfos = recipientInfos.map((i) => {
+          i.nftIds = [];
+          i.socialPlatform = i.socialPlatform.toLowerCase();
+          return i;
+        });
+        if (recipientInfos.length === 1) {
+          const result = await this._fund?.fund(tokenInfo, newFundRecipientInfos[0]);
+          return resolve(result);
+        } else if (recipientInfos.length > 1) {
+          const result = await this._fund?.fundBatch(tokenInfo, newFundRecipientInfos);
+          return resolve(result);
+        }
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  async refund(recipients) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        if (!recipients || recipients.length === 0) {
+          return reject("recipients is empty");
+        }
+        const newRecipients = recipients.map((i) => {
+          i.socialPlatform = i.socialPlatform.toLowerCase();
+          return i;
+        });
+        const result = await this._fund?.refund(newRecipients);
+        return resolve(result);
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  async attest(socialPlatform, address, genAppSignature) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const lcSocialPlatform = socialPlatform.toLowerCase();
+        const attestation = await this._fund?.attest(lcSocialPlatform, address, genAppSignature);
+        return resolve(attestation);
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  async claim(claimParams) {
+    const claimParamList = Array.isArray(claimParams) ? claimParams : [claimParams];
+    return new Promise(async (resolve, reject) => {
+      if (!claimParamList || claimParamList?.length === 0) {
+        const error = new Error("claimParams is empty");
+        return reject(error);
+      }
+      const socialPlatforms = [];
+      const userIdentifiers = [];
+      const attestations = [];
+      for (let i = 0; i < claimParamList.length; i++) {
+        socialPlatforms[i] = claimParamList[i].socialPlatform.toLowerCase();
+        attestations[i] = claimParamList[i].attestation;
+        userIdentifiers[i] = claimParamList[i].userIdentifier;
+      }
+      if (socialPlatforms.length !== userIdentifiers.length || socialPlatforms.length !== attestations.length) {
+        return reject(`claimParamList is wrong`);
+      }
+      try {
+        if (socialPlatforms.length === 1) {
+          const result = await this._fund?.claimBySource(socialPlatforms[0], userIdentifiers[0], attestations[0]);
+          resolve(result);
+        } else if (socialPlatforms.length > 1) {
+          const result = await this._fund?.claimByMultiSource(socialPlatforms, userIdentifiers, attestations);
+          return resolve(result);
+        }
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PrimusFund
+});