npm - @primuslabs/fund-js-sdk - Versions diffs - 0.1.0 - Mend

@primuslabs/fund-js-sdk 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/dist/index.mjs ADDED Viewed

@@ -0,0 +1,1358 @@
+// src/index.ts
+import { ethers as ethers3 } from "ethers";
+// src/classes/Fund.ts
+import { ethers as ethers2 } from "ethers";
+import { PrimusZKTLS } from "@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
+import { ethers } from "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 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 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 ethers2.Contract(tokenInfo.tokenAddress, erc20Abi_default, this.provider);
+          decimals = await erc20Contract.decimals();
+        }
+        const tokenAmount = ethers2.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 ethers2.Contract(tokenInfo.tokenAddress, erc20Abi_default, this.provider);
+          decimals = await erc20Contract.decimals();
+        }
+        let totalFormatAmount = recipientInfoList.reduce((acc, cur) => acc.add(ethers2.utils.parseUnits(cur.tokenAmount.toString(), decimals)), ethers2.BigNumber.from(0));
+        const newRecipientInfoList = recipientInfoList.map((i) => {
+          const formatAmount = ethers2.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 ethers2.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(ethers2.utils.parseUnits(cur.tokenAmount.toString(), decimals)), ethers2.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 ethers3.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 = ethers3.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);
+      }
+    });
+  }
+};
+export {
+  PrimusFund
+};