@primuslabs/fund-js-sdk 0.1.15 → 0.1.17

package/dist/index.mjs

@@ -112,6 +112,7 @@ var Fund_CONTRACTS = Object.values(SUPPORTEDCHAINIDSMAP).reduce((prev, curr) =>
   };
 }, {});
 var SUPPORTEDCHAINIDS = Object.keys(Fund_CONTRACTS).map((i) => Number(i));
+var SUPPORTEDSOLANACHAINIDS = ["EtWTRABZaYq6iMfeYKouRu166VU2xqa1", "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"];
 var FundForRedPacket_CONTRACTS = Object.values(SUPPORTEDCHAINIDSMAP).filter(
   (item) => {
     return item.redPacketContractAddress;
@@ -134,6 +135,41 @@ var hasErrorFlagFn = (curErrorArr, targetErrorStrArr) => {
     return f;
   });
 };
+var getErrArrFn = (error) => {
+  const errorMsg1 = typeof error === "string" ? error : error instanceof Error ? error.message : typeof error.message === "string" ? error.message : JSON.stringify(error);
+  const errorMsg2 = typeof error === "object" ? JSON.stringify(error) : error?.toString();
+  const curErrorStrArr = [errorMsg1, errorMsg2];
+  return curErrorStrArr;
+};
+var formatErrFn = (error) => {
+  let formatError = error;
+  const curErrorStrArr = getErrArrFn(error);
+  const userRejectErrStrArr = ["user rejected", "approval denied"];
+  const isUserRejected = hasErrorFlagFn(curErrorStrArr, userRejectErrStrArr);
+  if (error?.code === "ACTION_REJECTED" || isUserRejected) {
+    formatError = "user rejected transaction";
+  }
+  const isNoPendingWithdrawals = hasErrorFlagFn(curErrorStrArr, ["no pending withdrawals"]);
+  if (isNoPendingWithdrawals) {
+    formatError = "no pending withdrawals";
+  }
+  const insufficientBalanceErrStrArr = ["insufficient balance", "INSUFFICIENT_FUNDS", "The caller does not have enough funds for value transfer."];
+  const isInsufficientBalance = hasErrorFlagFn(curErrorStrArr, insufficientBalanceErrStrArr);
+  if (isInsufficientBalance) {
+    formatError = "insufficient balance";
+  }
+  const alreadyClaimedErrStrArr = ["Already claimed"];
+  const isAlreadyClaimed = hasErrorFlagFn(curErrorStrArr, alreadyClaimedErrStrArr);
+  if (isAlreadyClaimed) {
+    formatError = "already claimed";
+  }
+  const allClaimedErrStrArr = ["All claimed"];
+  const isAllClaimed = hasErrorFlagFn(curErrorStrArr, allClaimedErrStrArr);
+  if (isAllClaimed) {
+    formatError = "all claimed";
+  }
+  return formatError;
+};
 
 // src/classes/Contract.ts
 var Contract = class {
@@ -2717,234 +2753,3650 @@ var FundForRedPacket = class {
   }
 };
 
-// src/classes/ZktlsSdk.ts
-import { PrimusZKTLS } from "@primuslabs/zktls-js-sdk";
-var ZktlsSdk = class {
-  zkTlsSdk;
-  constructor() {
+// src/classes/FundOnSolanaForRedPacket.ts
+import * as anchor3 from "@coral-xyz/anchor";
+
+// src/classes/solana/program.ts
+import { Program } from "@coral-xyz/anchor";
+import * as anchor from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+import { getMint, TOKEN_2022_PROGRAM_ID } from "@solana/spl-token";
+import { encode as encodeBase58 } from "micro-base58";
+import * as borsh from "borsh";
+var { deserialize } = borsh;
+var BN2 = anchor.BN;
+var getProgram = (idl, anchorProvider) => {
+  return new Program(idl, anchorProvider);
+};
+var toTokenAmount = (amount, decimals) => {
+  const [integerPart, fractionalPart = ""] = String(amount).split(".");
+  const fractionalPadded = fractionalPart.padEnd(decimals, "0").slice(0, decimals);
+  const raw = integerPart + fractionalPadded;
+  const cleaned = raw.replace(/^0+/, "") || "0";
+  return new BN2(cleaned);
+};
+var getTokenProgramType = async (mintAddress, connection) => {
+  if (!connection) {
+    return "";
   }
-  getZkTlsSdk() {
-    return this.zkTlsSdk;
+  const mintPubkey = new PublicKey(mintAddress);
+  const accountInfo = await connection.getAccountInfo(mintPubkey);
+  if (!accountInfo) {
+    throw new Error("Mint account not found");
   }
-  async init(appId) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        this.zkTlsSdk = new PrimusZKTLS();
-        let platformDevice = "pc";
-        const isIpad = () => {
-          const userAgent = navigator.userAgent.toLowerCase();
-          const isTabletSize = window.innerWidth > 768 && window.innerWidth < 1366;
-          return /ipad/.test(userAgent) || navigator.platform === "MacIntel" && navigator.maxTouchPoints > 0 && isTabletSize;
-        };
-        if (navigator.userAgent.toLocaleLowerCase().includes("android")) {
-          platformDevice = "android";
-        } else if (navigator.userAgent.toLocaleLowerCase().includes("iphone") || isIpad()) {
-          platformDevice = "ios";
-        }
-        console.log("init appId", appId, platformDevice);
-        const extensionVersion = await this.zkTlsSdk.init(
-          appId,
-          "",
-          { platform: platformDevice }
-        );
-        resolve(extensionVersion);
-      } catch (error) {
-        return reject(error);
-      }
-    });
+  const TOKEN_PROGRAM_ID2 = new PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+  const TOKEN_2022_PROGRAM_ID3 = new PublicKey("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
+  if (accountInfo.owner.equals(TOKEN_PROGRAM_ID2)) {
+    return "Token";
+  } else if (accountInfo.owner.equals(TOKEN_2022_PROGRAM_ID3)) {
+    return "Token-2022";
+  } else {
+    return `Unknown Program: ${accountInfo.owner.toBase58()}`;
   }
-  async attest(attestParams, signFn, backUrl) {
-    return new Promise(async (resolve, reject) => {
-      console.log("this.zkTlsSdk", this.zkTlsSdk);
-      const { socialPlatform, userIdentifier, address } = attestParams;
-      const { id: templateId, field } = DATASOURCETEMPLATESMAP[socialPlatform];
-      const attRequest = this.zkTlsSdk.generateRequestParams(
-        templateId,
-        address
-      );
-      if (backUrl) {
-        attRequest.setBackUrl(backUrl);
-      }
-      console.log(`attRequest: ${JSON.stringify(attRequest)}`);
-      attRequest.setAttConditions([
-        [
-          {
-            field,
-            op: "STREQ",
-            value: userIdentifier
-          }
-        ]
-      ]);
-      const signParams = attRequest.toJsonString();
-      const signature = await signFn(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)
-        );
-        return resolve(attestation);
-      } catch (error) {
-        return reject(error);
-      }
-    });
+};
+async function getTokenDecimals(mintAddress, connection) {
+  const mintPubkey = new PublicKey(mintAddress);
+  const tokenProgramType = await getTokenProgramType(mintAddress, connection);
+  if (tokenProgramType === "Token-2022") {
+    const mintInfo = await getMint(connection, mintPubkey, "confirmed", TOKEN_2022_PROGRAM_ID);
+    return mintInfo.decimals;
+  } else if (tokenProgramType === "Token") {
+    const mintInfo = await getMint(connection, mintPubkey);
+    return mintInfo.decimals;
   }
-  async attestCommon(attestParams) {
-    const { templateId, address, signFn, conditions, additionParams, backUrl } = attestParams;
-    return new Promise(async (resolve, reject) => {
-      console.log("this.zkTlsSdk", this.zkTlsSdk);
-      const attRequest = this.zkTlsSdk.generateRequestParams(
-        templateId,
-        address
-      );
-      if (backUrl) {
-        attRequest.setBackUrl(backUrl);
-      }
-      console.log(`attRequest: ${JSON.stringify(attRequest)}`);
-      if (conditions) {
-        attRequest.setAttConditions(conditions);
-      }
-      if (additionParams) {
-        console.log("setAdditionParams--", additionParams);
-        attRequest.setAdditionParams(additionParams);
-      }
-      const signParams = attRequest.toJsonString();
-      const signature = await signFn(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)
-        );
-        return resolve(attestation);
-      } catch (error) {
-        return reject(error);
-      }
-    });
+}
+var hexToUint8Array = (hex) => {
+  let hexStr = hex.startsWith("0x") ? hex.slice(2) : hex;
+  return Buffer.from(hexStr.toLowerCase(), "hex");
+};
+function formatAttestation(attestation) {
+  const {
+    additionParams,
+    attConditions,
+    attestors,
+    data,
+    recipient,
+    responseResolve,
+    request,
+    signatures,
+    timestamp
+  } = attestation;
+  const formatAttestors = attestors.map(({ attestorAddr, url }) => {
+    return {
+      attestorAddr: hexToUint8Array(attestorAddr),
+      url
+    };
+  });
+  const formatSignatures = signatures.map((s) => hexToUint8Array(s));
+  const formatAtt = {
+    additionParams,
+    attConditions,
+    attestors: formatAttestors,
+    data,
+    recipient: new PublicKey(recipient).toBytes(),
+    responseResolve,
+    request,
+    signatures: formatSignatures,
+    timestamp: new anchor.BN(timestamp)
+  };
+  return formatAtt;
+}
+async function decodeReSendEvent(eventData) {
+  const eventBuffer = Buffer.from(eventData, "base64");
+  const raw = eventBuffer.slice(8);
+  console.log("eventBuffer first 8 bytes:", Array.from(eventBuffer.slice(0, 8)));
+  class CheckParams {
+    check_type;
+    params;
+    constructor(fields) {
+      this.check_type = fields.check_type;
+      this.params = fields.params;
+    }
+  }
+  class RESendEvent {
+    id;
+    re_sender;
+    token_type;
+    token_address;
+    amount;
+    re_type;
+    number;
+    timestamp;
+    check_params;
+    empty_ratio;
+    constructor(fields) {
+      this.id = fields.id;
+      this.re_sender = fields.re_sender;
+      this.token_type = fields.token_type;
+      this.token_address = fields.token_address;
+      this.amount = fields.amount;
+      this.re_type = fields.re_type;
+      this.number = fields.number;
+      this.timestamp = fields.timestamp;
+      this.check_params = new CheckParams(fields.check_params);
+      this.empty_ratio = fields.empty_ratio;
+    }
+  }
+  const CheckParamsJson = {
+    "kind": "struct",
+    "fields": [
+      ["check_type", "u32"],
+      ["params", "string"]
+    ]
+  };
+  const RESendEventJson = {
+    "kind": "struct",
+    "fields": [
+      ["id", [32]],
+      ["re_sender", [32]],
+      ["token_type", "u32"],
+      ["token_address", [32]],
+      ["amount", "u64"],
+      ["re_type", "u32"],
+      ["number", "u32"],
+      ["timestamp", "u64"],
+      ["check_params", CheckParams],
+      ["empty_ratio", "u8"]
+    ]
+  };
+  const schema2 = /* @__PURE__ */ new Map([
+    [CheckParams, CheckParamsJson],
+    [RESendEvent, RESendEventJson]
+  ]);
+  const res = deserialize(schema2, RESendEvent, raw);
+  console.log("decodeReSendEvent=", res);
+  return res;
+}
+async function decodeClaimEvent(eventData) {
+  const eventBuffer = Buffer.from(eventData, "base64");
+  const raw = eventBuffer.slice(8);
+  console.log("eventBuffer first 8 bytes:", Array.from(eventBuffer.slice(0, 8)));
+  class REClaimEvent {
+    id;
+    user;
+    user_id;
+    amount;
+    index;
+    timestamp;
+    token_address;
+    constructor(fields) {
+      this.id = fields.id;
+      this.user = fields.user;
+      this.user_id = fields.user_id;
+      this.amount = fields.amount;
+      this.index = fields.index;
+      this.timestamp = fields.timestamp;
+      this.token_address = fields.token_address;
+    }
+  }
+  const REClaimEventJson = {
+    "kind": "struct",
+    "fields": [
+      ["id", [32]],
+      ["user", [32]],
+      ["user_id", "string"],
+      ["amount", "u64"],
+      ["index", "u32"],
+      ["timestamp", "u64"],
+      ["token_address", [32]]
+    ]
+  };
+  const schema2 = /* @__PURE__ */ new Map([
+    [REClaimEvent, REClaimEventJson]
+  ]);
+  const res = deserialize(schema2, REClaimEvent, raw);
+  console.log("res=", res);
+  console.log("res=", new PublicKey(res.user).toBase58());
+  return res;
+}
+var getTxSigStrFromTx = (signedTx) => {
+  if (signedTx?.signatures[0] && signedTx?.signatures[0].signature) {
+    const signatureBytes = signedTx.signatures[0].signature;
+    const signatureStr = encodeBase58(signatureBytes);
+    return signatureStr;
   }
+  return "";
 };
-
-// src/index.ts
-console.log("SUPPORTEDCHAINIDS", SUPPORTEDCHAINIDS);
-var PrimusFund = class {
-  supportedChainIds = SUPPORTEDCHAINIDS;
-  supportedSocialPlatforms = SUPPORTEDSOCIALPLATFORMS;
-  provider;
-  _fund;
-  _fundForRedPacket;
-  _zkTlsSdk;
-  async init(provider, chainId, appId) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        if (!this.supportedChainIds.includes(chainId)) {
-          return reject("chainId is not supported");
-        }
-        let formatProvider;
-        let signer;
-        if (provider instanceof ethers5.providers.JsonRpcProvider) {
-          formatProvider = provider;
-        } else {
-          formatProvider = new ethers5.providers.Web3Provider(provider);
-          signer = formatProvider.getSigner();
-        }
-        await formatProvider.ready;
-        const network = await formatProvider.getNetwork();
-        const providerChainId = network.chainId;
-        console.log("init provider", provider, network);
-        console.log("init providerChainId", providerChainId, chainId);
-        if (providerChainId !== chainId) {
-          return reject(`Please connect to the chain with ID ${chainId} first.`);
-        }
-        this.provider = signer ?? formatProvider;
-        this._fund = new Fund();
-        const result = await this._fund.init(this.provider, chainId);
-        this._fundForRedPacket = new FundForRedPacket();
-        await this._fundForRedPacket.init(this.provider, chainId);
-        if (appId) {
-          this._zkTlsSdk = new ZktlsSdk();
-          await this._zkTlsSdk.init(appId);
-        }
-        return resolve(result);
-      } catch (error) {
-        return reject(error);
-      }
-    });
+var getTxIsOnChain = async (signatureStr, connection) => {
+  if (signatureStr) {
+    const { value } = await connection.getSignatureStatus(signatureStr);
+    if (value && value.confirmationStatus) {
+      return true;
+    } else {
+      return false;
+    }
   }
-  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");
+  return false;
+};
+var getTxIsOnProcess = (err) => {
+  const strArr = ["This transaction has already been processed"];
+  const curErrorStrArr = getErrArrFn(err);
+  const isOnProcess = hasErrorFlagFn(curErrorStrArr, strArr);
+  return isOnProcess;
+};
+
+// src/config/redPacketIdl.json
+var redPacketIdl_default = {
+  address: "EmK8RSeeHBxb1iZUipon2QqvatcuJyJZM4cpTtSAYzud",
+  metadata: {
+    name: "primus_red_envelope",
+    version: "0.1.0",
+    spec: "0.1.0",
+    description: "Created with Anchor"
+  },
+  instructions: [
+    {
+      name: "initialize",
+      discriminator: [
+        175,
+        175,
+        109,
+        31,
+        13,
+        152,
+        155,
+        237
+      ],
+      accounts: [
+        {
+          name: "state",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  100,
+                  95,
+                  101,
+                  110,
+                  118,
+                  101,
+                  108,
+                  111,
+                  112,
+                  101
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "owner",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
         }
-        if (tokenInfo.tokenType === 1) {
-          tokenInfo.tokenAddress = ethers5.constants.AddressZero;
+      ],
+      args: [
+        {
+          name: "primus_zktls",
+          type: "pubkey"
+        },
+        {
+          name: "fee_recipient",
+          type: "pubkey"
+        },
+        {
+          name: "claim_fee",
+          type: "u64"
         }
-        const newFundRecipientInfos = recipientInfos.map((i) => {
-          const formatSocialPlatform = i.socialPlatform.toLowerCase();
-          let formatUserIdentifier = i.userIdentifier;
-          if (i.socialPlatform === "x" && i.userIdentifier.startsWith("@")) {
-            formatUserIdentifier = i.userIdentifier.slice(1);
+      ]
+    },
+    {
+      name: "re_claim",
+      discriminator: [
+        105,
+        179,
+        220,
+        94,
+        121,
+        140,
+        144,
+        24
+      ],
+      accounts: [
+        {
+          name: "state",
+          writable: true
+        },
+        {
+          name: "re_record",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  95,
+                  114,
+                  101,
+                  99,
+                  111,
+                  114,
+                  100
+                ]
+              },
+              {
+                kind: "arg",
+                path: "re_id"
+              }
+            ]
           }
-          return {
-            nftIds: i.nftIds ?? [],
-            socialPlatform: formatSocialPlatform,
-            userIdentifier: formatUserIdentifier,
-            tokenAmount: i.tokenAmount
-          };
-        });
-        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 approve(fundParam) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const { tokenInfo, recipientInfos } = fundParam;
-        if (!recipientInfos || recipientInfos.length === 0) {
-          return reject("recipientInfos is empty");
+        },
+        {
+          name: "re_record_data",
+          writable: true
+        },
+        {
+          name: "claimer",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        },
+        {
+          name: "primus_zktls_state",
+          writable: true
+        },
+        {
+          name: "primus_zktls_program",
+          address: "3qG9pUbAHfizoqnvj9GxnTPaVgkyb7Ry6Q5vozMYdVAA"
+        },
+        {
+          name: "fee_recipient",
+          writable: true
+        },
+        {
+          name: "att_recipient",
+          writable: true
+        },
+        {
+          name: "data_buffer",
+          writable: true,
+          optional: true
+        },
+        {
+          name: "from_token_account",
+          writable: true,
+          optional: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "state"
+              },
+              {
+                kind: "account",
+                path: "token_program"
+              },
+              {
+                kind: "account",
+                path: "mint"
+              }
+            ],
+            program: {
+              kind: "const",
+              value: [
+                140,
+                151,
+                37,
+                143,
+                78,
+                36,
+                137,
+                241,
+                187,
+                61,
+                16,
+                41,
+                20,
+                142,
+                13,
+                131,
+                11,
+                90,
+                19,
+                153,
+                218,
+                255,
+                16,
+                132,
+                4,
+                142,
+                123,
+                216,
+                219,
+                233,
+                248,
+                89
+              ]
+            }
+          }
+        },
+        {
+          name: "to_token_account",
+          writable: true,
+          optional: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "att_recipient"
+              },
+              {
+                kind: "account",
+                path: "token_program"
+              },
+              {
+                kind: "account",
+                path: "mint"
+              }
+            ],
+            program: {
+              kind: "const",
+              value: [
+                140,
+                151,
+                37,
+                143,
+                78,
+                36,
+                137,
+                241,
+                187,
+                61,
+                16,
+                41,
+                20,
+                142,
+                13,
+                131,
+                11,
+                90,
+                19,
+                153,
+                218,
+                255,
+                16,
+                132,
+                4,
+                142,
+                123,
+                216,
+                219,
+                233,
+                248,
+                89
+              ]
+            }
+          }
+        },
+        {
+          name: "mint",
+          optional: true
+        },
+        {
+          name: "token_program"
+        },
+        {
+          name: "associated_token_program",
+          address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
         }
-        const hasUnsupportedSocialPlatforms = recipientInfos.some((i) => !this.supportedSocialPlatforms.includes(i.socialPlatform.toLowerCase()));
-        if (hasUnsupportedSocialPlatforms) {
-          return reject("socialPlatform is not supported");
+      ],
+      args: [
+        {
+          name: "_re_id",
+          type: {
+            array: [
+              "u8",
+              32
+            ]
+          }
+        },
+        {
+          name: "_att",
+          type: {
+            option: {
+              defined: {
+                name: "Attestation"
+              }
+            }
+          }
         }
-        if (tokenInfo.tokenType === 1) {
-          tokenInfo.tokenAddress = ethers5.constants.AddressZero;
+      ]
+    },
+    {
+      name: "re_record_data_init",
+      discriminator: [
+        211,
+        91,
+        95,
+        249,
+        111,
+        81,
+        103,
+        124
+      ],
+      accounts: [
+        {
+          name: "re_record_data",
+          writable: true
+        },
+        {
+          name: "sender",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
         }
-        const newFundRecipientInfos = recipientInfos.map((i) => {
-          const formatSocialPlatform = i.socialPlatform.toLowerCase();
-          let formatUserIdentifier = i.userIdentifier;
-          if (i.socialPlatform === "x" && i.userIdentifier.startsWith("@")) {
-            formatUserIdentifier = i.userIdentifier.slice(1);
+      ],
+      args: []
+    },
+    {
+      name: "re_send",
+      discriminator: [
+        31,
+        123,
+        130,
+        212,
+        113,
+        174,
+        167,
+        63
+      ],
+      accounts: [
+        {
+          name: "state",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  100,
+                  95,
+                  101,
+                  110,
+                  118,
+                  101,
+                  108,
+                  111,
+                  112,
+                  101
+                ]
+              }
+            ]
           }
-          return {
-            nftIds: i.nftIds ?? [],
+        },
+        {
+          name: "re_record",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  95,
+                  114,
+                  101,
+                  99,
+                  111,
+                  114,
+                  100
+                ]
+              },
+              {
+                kind: "arg",
+                path: "re_id"
+              }
+            ]
+          }
+        },
+        {
+          name: "re_record_data",
+          writable: true
+        },
+        {
+          name: "sender",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        },
+        {
+          name: "from_token_account",
+          writable: true,
+          optional: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "sender"
+              },
+              {
+                kind: "account",
+                path: "token_program"
+              },
+              {
+                kind: "account",
+                path: "mint"
+              }
+            ],
+            program: {
+              kind: "const",
+              value: [
+                140,
+                151,
+                37,
+                143,
+                78,
+                36,
+                137,
+                241,
+                187,
+                61,
+                16,
+                41,
+                20,
+                142,
+                13,
+                131,
+                11,
+                90,
+                19,
+                153,
+                218,
+                255,
+                16,
+                132,
+                4,
+                142,
+                123,
+                216,
+                219,
+                233,
+                248,
+                89
+              ]
+            }
+          }
+        },
+        {
+          name: "to_token_account",
+          writable: true,
+          optional: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "state"
+              },
+              {
+                kind: "account",
+                path: "token_program"
+              },
+              {
+                kind: "account",
+                path: "mint"
+              }
+            ],
+            program: {
+              kind: "const",
+              value: [
+                140,
+                151,
+                37,
+                143,
+                78,
+                36,
+                137,
+                241,
+                187,
+                61,
+                16,
+                41,
+                20,
+                142,
+                13,
+                131,
+                11,
+                90,
+                19,
+                153,
+                218,
+                255,
+                16,
+                132,
+                4,
+                142,
+                123,
+                216,
+                219,
+                233,
+                248,
+                89
+              ]
+            }
+          }
+        },
+        {
+          name: "mint",
+          optional: true
+        },
+        {
+          name: "token_program"
+        },
+        {
+          name: "associated_token_program",
+          address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        }
+      ],
+      args: [
+        {
+          name: "re_id",
+          type: {
+            array: [
+              "u8",
+              32
+            ]
+          }
+        },
+        {
+          name: "token",
+          type: {
+            defined: {
+              name: "TipToken"
+            }
+          }
+        },
+        {
+          name: "send_param",
+          type: {
+            defined: {
+              name: "RESendParam"
+            }
+          }
+        }
+      ]
+    },
+    {
+      name: "re_sender_withdraw",
+      discriminator: [
+        231,
+        140,
+        27,
+        36,
+        175,
+        206,
+        105,
+        68
+      ],
+      accounts: [
+        {
+          name: "state",
+          writable: true
+        },
+        {
+          name: "re_record",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  95,
+                  114,
+                  101,
+                  99,
+                  111,
+                  114,
+                  100
+                ]
+              },
+              {
+                kind: "arg",
+                path: "re_id"
+              }
+            ]
+          }
+        },
+        {
+          name: "re_sender",
+          writable: true,
+          signer: true,
+          relations: [
+            "re_record"
+          ]
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        },
+        {
+          name: "from_token_account",
+          writable: true,
+          optional: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "state"
+              },
+              {
+                kind: "account",
+                path: "token_program"
+              },
+              {
+                kind: "account",
+                path: "mint"
+              }
+            ],
+            program: {
+              kind: "const",
+              value: [
+                140,
+                151,
+                37,
+                143,
+                78,
+                36,
+                137,
+                241,
+                187,
+                61,
+                16,
+                41,
+                20,
+                142,
+                13,
+                131,
+                11,
+                90,
+                19,
+                153,
+                218,
+                255,
+                16,
+                132,
+                4,
+                142,
+                123,
+                216,
+                219,
+                233,
+                248,
+                89
+              ]
+            }
+          }
+        },
+        {
+          name: "to_token_account",
+          writable: true,
+          optional: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "re_sender"
+              },
+              {
+                kind: "account",
+                path: "token_program"
+              },
+              {
+                kind: "account",
+                path: "mint"
+              }
+            ],
+            program: {
+              kind: "const",
+              value: [
+                140,
+                151,
+                37,
+                143,
+                78,
+                36,
+                137,
+                241,
+                187,
+                61,
+                16,
+                41,
+                20,
+                142,
+                13,
+                131,
+                11,
+                90,
+                19,
+                153,
+                218,
+                255,
+                16,
+                132,
+                4,
+                142,
+                123,
+                216,
+                219,
+                233,
+                248,
+                89
+              ]
+            }
+          }
+        },
+        {
+          name: "mint",
+          optional: true
+        },
+        {
+          name: "token_program"
+        },
+        {
+          name: "associated_token_program",
+          address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        }
+      ],
+      args: [
+        {
+          name: "_re_id",
+          type: {
+            array: [
+              "u8",
+              32
+            ]
+          }
+        }
+      ]
+    },
+    {
+      name: "set_claim_fee",
+      discriminator: [
+        124,
+        3,
+        184,
+        17,
+        133,
+        67,
+        255,
+        50
+      ],
+      accounts: [
+        {
+          name: "state",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  100,
+                  95,
+                  101,
+                  110,
+                  118,
+                  101,
+                  108,
+                  111,
+                  112,
+                  101
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "owner",
+          writable: true,
+          signer: true,
+          relations: [
+            "state"
+          ]
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "claim_fee",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "set_fee_recipient",
+      discriminator: [
+        227,
+        18,
+        215,
+        42,
+        237,
+        246,
+        151,
+        66
+      ],
+      accounts: [
+        {
+          name: "state",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  100,
+                  95,
+                  101,
+                  110,
+                  118,
+                  101,
+                  108,
+                  111,
+                  112,
+                  101
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "owner",
+          writable: true,
+          signer: true,
+          relations: [
+            "state"
+          ]
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "fee_recipient",
+          type: "pubkey"
+        }
+      ]
+    },
+    {
+      name: "set_primus_zktls",
+      discriminator: [
+        248,
+        182,
+        45,
+        229,
+        46,
+        5,
+        95,
+        71
+      ],
+      accounts: [
+        {
+          name: "state",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  100,
+                  95,
+                  101,
+                  110,
+                  118,
+                  101,
+                  108,
+                  111,
+                  112,
+                  101
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "owner",
+          writable: true,
+          signer: true,
+          relations: [
+            "state"
+          ]
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "primus_zktls",
+          type: "pubkey"
+        }
+      ]
+    },
+    {
+      name: "set_withdraw_delay",
+      discriminator: [
+        184,
+        89,
+        21,
+        192,
+        34,
+        24,
+        3,
+        142
+      ],
+      accounts: [
+        {
+          name: "state",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  100,
+                  95,
+                  101,
+                  110,
+                  118,
+                  101,
+                  108,
+                  111,
+                  112,
+                  101
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "owner",
+          writable: true,
+          signer: true,
+          relations: [
+            "state"
+          ]
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "withdraw_delay",
+          type: "u64"
+        }
+      ]
+    }
+  ],
+  accounts: [
+    {
+      name: "DataBuffer",
+      discriminator: [
+        235,
+        220,
+        51,
+        248,
+        56,
+        77,
+        241,
+        89
+      ]
+    },
+    {
+      name: "PrimusState",
+      discriminator: [
+        200,
+        136,
+        35,
+        84,
+        173,
+        237,
+        163,
+        179
+      ]
+    },
+    {
+      name: "RERecord",
+      discriminator: [
+        242,
+        171,
+        141,
+        17,
+        123,
+        107,
+        153,
+        15
+      ]
+    },
+    {
+      name: "RERecordData",
+      discriminator: [
+        165,
+        107,
+        251,
+        115,
+        50,
+        118,
+        32,
+        148
+      ]
+    },
+    {
+      name: "RedEnvelopeState",
+      discriminator: [
+        89,
+        134,
+        184,
+        61,
+        201,
+        123,
+        226,
+        180
+      ]
+    }
+  ],
+  events: [
+    {
+      name: "REClaimEvent",
+      discriminator: [
+        214,
+        100,
+        41,
+        0,
+        45,
+        92,
+        31,
+        248
+      ]
+    },
+    {
+      name: "RESWithdrawEvent",
+      discriminator: [
+        26,
+        207,
+        42,
+        68,
+        36,
+        174,
+        127,
+        205
+      ]
+    },
+    {
+      name: "RESendEvent",
+      discriminator: [
+        147,
+        8,
+        237,
+        225,
+        123,
+        64,
+        157,
+        199
+      ]
+    }
+  ],
+  errors: [
+    {
+      code: 6e3,
+      name: "InvalidZktlsProgram",
+      msg: "Invalid Zktls Program"
+    },
+    {
+      code: 6001,
+      name: "InvalidTokenProgram",
+      msg: "Invalid token program"
+    },
+    {
+      code: 6002,
+      name: "InvalidTokenType",
+      msg: "Invalid token type"
+    },
+    {
+      code: 6003,
+      name: "InvalidREType",
+      msg: "Invalid red envelope type"
+    },
+    {
+      code: 6004,
+      name: "InvalidNumber",
+      msg: "Invalid number"
+    },
+    {
+      code: 6005,
+      name: "InvalidEmptyRatio",
+      msg: "Invalid empty ratio"
+    },
+    {
+      code: 6006,
+      name: "AmountTooLow",
+      msg: "Amount too low"
+    },
+    {
+      code: 6007,
+      name: "WrongAmount",
+      msg: "Wrong amount"
+    },
+    {
+      code: 6008,
+      name: "NoReId",
+      msg: "Red envelope ID does not exist"
+    },
+    {
+      code: 6009,
+      name: "AllClaimed",
+      msg: "All envelopes claimed"
+    },
+    {
+      code: 6010,
+      name: "UserIdEmpty",
+      msg: "User ID empty"
+    },
+    {
+      code: 6011,
+      name: "InvalidUserAddress",
+      msg: "Invalid User Address"
+    },
+    {
+      code: 6012,
+      name: "AlreadyClaimed",
+      msg: "Already claimed"
+    },
+    {
+      code: 6013,
+      name: "AmountUnderflow",
+      msg: "Amount underflow"
+    },
+    {
+      code: 6014,
+      name: "InvalidFeeRecipient",
+      msg: "Invalid fee recipient"
+    },
+    {
+      code: 6015,
+      name: "InvalidStateAccount",
+      msg: "Invalid state account"
+    },
+    {
+      code: 6016,
+      name: "RecipientIsZero",
+      msg: "Recipient cannot be zero"
+    },
+    {
+      code: 6017,
+      name: "InvalidCheckType",
+      msg: "Invalid checkType"
+    },
+    {
+      code: 6018,
+      name: "InvalidCheckParams",
+      msg: "CheckParams decode failed"
+    },
+    {
+      code: 6019,
+      name: "NoFund",
+      msg: "No fund"
+    },
+    {
+      code: 6020,
+      name: "NotOwner",
+      msg: "Not owner"
+    },
+    {
+      code: 6021,
+      name: "NotExpired",
+      msg: "Not expired"
+    },
+    {
+      code: 6022,
+      name: "UnsupportedTokenType",
+      msg: "Unsupported Token Type"
+    },
+    {
+      code: 6023,
+      name: "InsufficientSOL",
+      msg: "Insufficient SOL"
+    },
+    {
+      code: 6024,
+      name: "WrongTokenMint",
+      msg: "Wrong token mint"
+    },
+    {
+      code: 6025,
+      name: "DeserializationFailed",
+      msg: "Deserialization Failed"
+    },
+    {
+      code: 6026,
+      name: "JsonParseError",
+      msg: "JSON Parse Error"
+    },
+    {
+      code: 6027,
+      name: "ResponseLengthError",
+      msg: "response length error"
+    },
+    {
+      code: 6028,
+      name: "AttUrlError",
+      msg: "att url error"
+    },
+    {
+      code: 6029,
+      name: "AttSuffixUrlError",
+      msg: "att suffix url error"
+    },
+    {
+      code: 6030,
+      name: "JsonPathError",
+      msg: "json path error"
+    },
+    {
+      code: 6031,
+      name: "UsernameKeyError",
+      msg: "username key error"
+    },
+    {
+      code: 6032,
+      name: "FollowingError",
+      msg: "following error"
+    },
+    {
+      code: 6033,
+      name: "FollowingNameError",
+      msg: "following name error"
+    },
+    {
+      code: 6034,
+      name: "NameOpError",
+      msg: "name op error"
+    },
+    {
+      code: 6035,
+      name: "AttConditionsError",
+      msg: "att conditions error"
+    },
+    {
+      code: 6036,
+      name: "TooManyUrls",
+      msg: "too many urls"
+    },
+    {
+      code: 6037,
+      name: "TooManyResponseresolve",
+      msg: "too many responseResolve"
+    },
+    {
+      code: 6038,
+      name: "UserNameEmpty",
+      msg: "user name empty"
+    },
+    {
+      code: 6039,
+      name: "SourceError",
+      msg: "source error"
+    },
+    {
+      code: 6040,
+      name: "AccountResponseLengthError",
+      msg: "account response length error"
+    },
+    {
+      code: 6041,
+      name: "TiktokAttUrlError",
+      msg: "tiktok att url error"
+    },
+    {
+      code: 6042,
+      name: "TiktokJsonPathError",
+      msg: "tiktok json path error"
+    },
+    {
+      code: 6043,
+      name: "XAttUrlError",
+      msg: "x att url error"
+    },
+    {
+      code: 6044,
+      name: "XJsonPathError",
+      msg: "x json path error"
+    },
+    {
+      code: 6045,
+      name: "GoogleAttUrlError",
+      msg: "google att url error"
+    },
+    {
+      code: 6046,
+      name: "GoogleJsonPathError",
+      msg: "google json path error"
+    },
+    {
+      code: 6047,
+      name: "XiaohongshuAttUrlError",
+      msg: "xiaohongshu att url error"
+    },
+    {
+      code: 6048,
+      name: "XiaohongshuJsonPathError",
+      msg: "xiaohongshu json path error"
+    }
+  ],
+  types: [
+    {
+      name: "AttNetworkRequest",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "url",
+            type: "string"
+          },
+          {
+            name: "header",
+            type: "string"
+          },
+          {
+            name: "method",
+            type: "string"
+          },
+          {
+            name: "body",
+            type: "string"
+          }
+        ]
+      }
+    },
+    {
+      name: "AttNetworkResponseResolve",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "key_name",
+            type: "string"
+          },
+          {
+            name: "parse_type",
+            type: "string"
+          },
+          {
+            name: "parse_path",
+            type: "string"
+          }
+        ]
+      }
+    },
+    {
+      name: "Attestation",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "recipient",
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "request",
+            type: {
+              defined: {
+                name: "AttNetworkRequest"
+              }
+            }
+          },
+          {
+            name: "response_resolve",
+            type: {
+              vec: {
+                defined: {
+                  name: "AttNetworkResponseResolve"
+                }
+              }
+            }
+          },
+          {
+            name: "data",
+            type: "string"
+          },
+          {
+            name: "att_conditions",
+            type: "string"
+          },
+          {
+            name: "timestamp",
+            type: "u64"
+          },
+          {
+            name: "addition_params",
+            type: "string"
+          },
+          {
+            name: "attestors",
+            type: {
+              vec: {
+                defined: {
+                  name: "Attestor"
+                }
+              }
+            }
+          },
+          {
+            name: "signatures",
+            type: {
+              vec: "bytes"
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "Attestor",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "attestor_addr",
+            type: {
+              array: [
+                "u8",
+                20
+              ]
+            }
+          },
+          {
+            name: "url",
+            type: "string"
+          }
+        ]
+      }
+    },
+    {
+      name: "CheckParams",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "check_type",
+            type: "u32"
+          },
+          {
+            name: "params",
+            type: "string"
+          }
+        ]
+      }
+    },
+    {
+      name: "DataBuffer",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "user",
+            type: "pubkey"
+          },
+          {
+            name: "length",
+            type: "u32"
+          },
+          {
+            name: "data",
+            type: "bytes"
+          }
+        ]
+      }
+    },
+    {
+      name: "PrimusState",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "owner",
+            type: "pubkey"
+          },
+          {
+            name: "attestors",
+            type: {
+              vec: {
+                defined: {
+                  name: "Attestor"
+                }
+              }
+            }
+          },
+          {
+            name: "bump",
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "REClaimEvent",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "id",
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "user",
+            type: "pubkey"
+          },
+          {
+            name: "user_id",
+            type: "string"
+          },
+          {
+            name: "amount",
+            type: "u64"
+          },
+          {
+            name: "index",
+            type: "u32"
+          },
+          {
+            name: "timestamp",
+            type: "u64"
+          },
+          {
+            name: "token_address",
+            type: "pubkey"
+          }
+        ]
+      }
+    },
+    {
+      name: "RERecord",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "id",
+            docs: [
+              "Red envelope ID"
+            ],
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "token_type",
+            docs: [
+              "Token type (ERC20 / NATIVE)"
+            ],
+            type: "u32"
+          },
+          {
+            name: "re_type",
+            docs: [
+              "Red envelope type"
+            ],
+            type: "u32"
+          },
+          {
+            name: "number",
+            docs: [
+              "Number of recipients"
+            ],
+            type: "u32"
+          },
+          {
+            name: "remaining_number",
+            docs: [
+              "Remaining recipients"
+            ],
+            type: "u32"
+          },
+          {
+            name: "timestamp",
+            docs: [
+              "Timestamp sent"
+            ],
+            type: "u64"
+          },
+          {
+            name: "token_address",
+            docs: [
+              "Token address"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "re_sender",
+            docs: [
+              "Sender address"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "check_contract",
+            docs: [
+              "Eligibility check contract"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "amount",
+            docs: [
+              "Total amount"
+            ],
+            type: "u64"
+          },
+          {
+            name: "remaining_amount",
+            docs: [
+              "Remaining amount"
+            ],
+            type: "u64"
+          },
+          {
+            name: "check_params",
+            docs: [
+              "Eligibility check params"
+            ],
+            type: {
+              defined: {
+                name: "CheckParams"
+              }
+            }
+          },
+          {
+            name: "empty_ratio",
+            docs: [
+              "Empty red envelope ratio, 0\u2013100"
+            ],
+            type: "u8"
+          },
+          {
+            name: "record_data",
+            docs: [
+              "RE Record account, refer to Account<RERecordData>"
+            ],
+            type: "pubkey"
+          }
+        ]
+      }
+    },
+    {
+      name: "RERecordData",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "id",
+            docs: [
+              "Red envelope ID"
+            ],
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "amounts",
+            docs: [
+              "Red envelope amount array, containing 0 amounts."
+            ],
+            type: {
+              vec: "u64"
+            }
+          },
+          {
+            name: "re_claimed",
+            type: {
+              vec: {
+                array: [
+                  "u8",
+                  8
+                ]
+              }
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "RESWithdrawEvent",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "re_id",
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "sender",
+            type: "pubkey"
+          },
+          {
+            name: "amount",
+            type: "u64"
+          },
+          {
+            name: "remaining_number",
+            type: "u32"
+          },
+          {
+            name: "timestamp",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "RESendEvent",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "id",
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "re_sender",
+            type: "pubkey"
+          },
+          {
+            name: "token_type",
+            type: "u32"
+          },
+          {
+            name: "token_address",
+            type: "pubkey"
+          },
+          {
+            name: "amount",
+            type: "u64"
+          },
+          {
+            name: "re_type",
+            type: "u32"
+          },
+          {
+            name: "number",
+            type: "u32"
+          },
+          {
+            name: "timestamp",
+            type: "u64"
+          },
+          {
+            name: "check_params",
+            type: {
+              defined: {
+                name: "CheckParams"
+              }
+            }
+          },
+          {
+            name: "empty_ratio",
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "RESendParam",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "re_type",
+            docs: [
+              "Red envelope type: 0 = random, 1 = average"
+            ],
+            type: "u32"
+          },
+          {
+            name: "number",
+            docs: [
+              "Number of recipients"
+            ],
+            type: "u32"
+          },
+          {
+            name: "amount",
+            docs: [
+              "Total amount, the smallest unit"
+            ],
+            type: "u64"
+          },
+          {
+            name: "check_contract",
+            docs: [
+              "Eligibility check contract"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "check_params",
+            docs: [
+              "Params passed to check_contract"
+            ],
+            type: {
+              defined: {
+                name: "CheckParams"
+              }
+            }
+          },
+          {
+            name: "empty_ratio",
+            docs: [
+              "Empty red envelope ratio, 0\u2013100"
+            ],
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "RedEnvelopeState",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "owner",
+            type: "pubkey"
+          },
+          {
+            name: "id_counter",
+            type: "u128"
+          },
+          {
+            name: "primus_zktls",
+            type: "pubkey"
+          },
+          {
+            name: "claim_fee",
+            type: "u64"
+          },
+          {
+            name: "fee_recipient",
+            type: "pubkey"
+          },
+          {
+            name: "withdraw_delay",
+            type: "u64"
+          },
+          {
+            name: "bump",
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "TipToken",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "token_type",
+            docs: [
+              "tokenType is erc20, native or nft. 0 means erc20, 1 means native and 2 means nft."
+            ],
+            type: "u32"
+          },
+          {
+            name: "token_address",
+            docs: [
+              "Token address"
+            ],
+            type: "pubkey"
+          }
+        ]
+      }
+    }
+  ]
+};
+
+// src/config/zktlsIdl.json
+var zktlsIdl_default = {
+  address: "3qG9pUbAHfizoqnvj9GxnTPaVgkyb7Ry6Q5vozMYdVAA",
+  metadata: {
+    name: "primus_zktls",
+    version: "0.1.0",
+    spec: "0.1.0",
+    description: "Created with Anchor"
+  },
+  instructions: [
+    {
+      name: "initialize",
+      discriminator: [
+        175,
+        175,
+        109,
+        31,
+        13,
+        152,
+        155,
+        237
+      ],
+      accounts: [
+        {
+          name: "state",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  114,
+                  105,
+                  109,
+                  117,
+                  115,
+                  95,
+                  115,
+                  116,
+                  97,
+                  116,
+                  101
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "owner",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "default_addr",
+          type: {
+            array: [
+              "u8",
+              20
+            ]
+          }
+        }
+      ]
+    },
+    {
+      name: "remove_attestor",
+      discriminator: [
+        108,
+        232,
+        239,
+        229,
+        84,
+        249,
+        29,
+        22
+      ],
+      accounts: [
+        {
+          name: "state",
+          writable: true
+        },
+        {
+          name: "owner",
+          writable: true,
+          signer: true,
+          relations: [
+            "state"
+          ]
+        }
+      ],
+      args: [
+        {
+          name: "target_addr",
+          type: {
+            array: [
+              "u8",
+              20
+            ]
+          }
+        }
+      ]
+    },
+    {
+      name: "set_attestor",
+      discriminator: [
+        95,
+        11,
+        236,
+        157,
+        234,
+        146,
+        163,
+        237
+      ],
+      accounts: [
+        {
+          name: "state",
+          writable: true
+        },
+        {
+          name: "owner",
+          writable: true,
+          signer: true,
+          relations: [
+            "state"
+          ]
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "attestor",
+          type: {
+            defined: {
+              name: "Attestor"
+            }
+          }
+        }
+      ]
+    },
+    {
+      name: "store_chunk",
+      discriminator: [
+        100,
+        147,
+        78,
+        157,
+        82,
+        197,
+        253,
+        165
+      ],
+      accounts: [
+        {
+          name: "data_buffer",
+          writable: true
+        },
+        {
+          name: "user",
+          signer: true,
+          relations: [
+            "data_buffer"
+          ]
+        }
+      ],
+      args: [
+        {
+          name: "chunk",
+          type: "bytes"
+        }
+      ]
+    },
+    {
+      name: "store_close",
+      discriminator: [
+        231,
+        65,
+        66,
+        193,
+        128,
+        236,
+        61,
+        11
+      ],
+      accounts: [
+        {
+          name: "data_buffer",
+          writable: true
+        },
+        {
+          name: "user",
+          signer: true,
+          relations: [
+            "data_buffer"
+          ]
+        }
+      ],
+      args: []
+    },
+    {
+      name: "store_initialize",
+      docs: [
+        "DataBuffer Store"
+      ],
+      discriminator: [
+        58,
+        143,
+        215,
+        232,
+        184,
+        29,
+        233,
+        116
+      ],
+      accounts: [
+        {
+          name: "data_buffer",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "user",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "data_length",
+          type: "u32"
+        }
+      ]
+    },
+    {
+      name: "verify_attestation",
+      discriminator: [
+        144,
+        30,
+        116,
+        186,
+        33,
+        176,
+        35,
+        60
+      ],
+      accounts: [
+        {
+          name: "state",
+          writable: true
+        },
+        {
+          name: "user",
+          signer: true,
+          relations: [
+            "data_buffer"
+          ]
+        },
+        {
+          name: "data_buffer",
+          writable: true,
+          optional: true
+        }
+      ],
+      args: [
+        {
+          name: "_att",
+          type: {
+            option: {
+              defined: {
+                name: "Attestation"
+              }
+            }
+          }
+        }
+      ]
+    }
+  ],
+  accounts: [
+    {
+      name: "DataBuffer",
+      discriminator: [
+        235,
+        220,
+        51,
+        248,
+        56,
+        77,
+        241,
+        89
+      ]
+    },
+    {
+      name: "PrimusState",
+      discriminator: [
+        200,
+        136,
+        35,
+        84,
+        173,
+        237,
+        163,
+        179
+      ]
+    }
+  ],
+  events: [
+    {
+      name: "AddAttestorEvent",
+      discriminator: [
+        36,
+        104,
+        4,
+        119,
+        98,
+        31,
+        220,
+        145
+      ]
+    },
+    {
+      name: "DelAttestorEvent",
+      discriminator: [
+        103,
+        73,
+        88,
+        10,
+        15,
+        78,
+        23,
+        49
+      ]
+    }
+  ],
+  errors: [
+    {
+      code: 6e3,
+      name: "Unauthorized",
+      msg: "Unauthorized"
+    },
+    {
+      code: 6001,
+      name: "AttestationExpired",
+      msg: "Attestation expired"
+    },
+    {
+      code: 6002,
+      name: "AttestorLimitReached",
+      msg: "Attestor limit reached"
+    },
+    {
+      code: 6003,
+      name: "AttestorNotFound",
+      msg: "Attestor not found"
+    },
+    {
+      code: 6004,
+      name: "InvalidSignatureLength",
+      msg: "Invalid signature length"
+    },
+    {
+      code: 6005,
+      name: "InvalidSignatureVValue",
+      msg: "Invalid signature v value"
+    },
+    {
+      code: 6006,
+      name: "InvalidSignature",
+      msg: "Invalid signature"
+    },
+    {
+      code: 6007,
+      name: "TooLarge",
+      msg: "Too Large"
+    },
+    {
+      code: 6008,
+      name: "DeserializationFailed",
+      msg: "Deserialization Failed"
+    },
+    {
+      code: 6009,
+      name: "OutOfBounds",
+      msg: "Out Of Bounds"
+    }
+  ],
+  types: [
+    {
+      name: "AddAttestorEvent",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "address",
+            type: {
+              array: [
+                "u8",
+                20
+              ]
+            }
+          },
+          {
+            name: "attestor",
+            type: {
+              defined: {
+                name: "Attestor"
+              }
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "AttNetworkRequest",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "url",
+            type: "string"
+          },
+          {
+            name: "header",
+            type: "string"
+          },
+          {
+            name: "method",
+            type: "string"
+          },
+          {
+            name: "body",
+            type: "string"
+          }
+        ]
+      }
+    },
+    {
+      name: "AttNetworkResponseResolve",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "key_name",
+            type: "string"
+          },
+          {
+            name: "parse_type",
+            type: "string"
+          },
+          {
+            name: "parse_path",
+            type: "string"
+          }
+        ]
+      }
+    },
+    {
+      name: "Attestation",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "recipient",
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "request",
+            type: {
+              defined: {
+                name: "AttNetworkRequest"
+              }
+            }
+          },
+          {
+            name: "response_resolve",
+            type: {
+              vec: {
+                defined: {
+                  name: "AttNetworkResponseResolve"
+                }
+              }
+            }
+          },
+          {
+            name: "data",
+            type: "string"
+          },
+          {
+            name: "att_conditions",
+            type: "string"
+          },
+          {
+            name: "timestamp",
+            type: "u64"
+          },
+          {
+            name: "addition_params",
+            type: "string"
+          },
+          {
+            name: "attestors",
+            type: {
+              vec: {
+                defined: {
+                  name: "Attestor"
+                }
+              }
+            }
+          },
+          {
+            name: "signatures",
+            type: {
+              vec: "bytes"
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "Attestor",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "attestor_addr",
+            type: {
+              array: [
+                "u8",
+                20
+              ]
+            }
+          },
+          {
+            name: "url",
+            type: "string"
+          }
+        ]
+      }
+    },
+    {
+      name: "DataBuffer",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "user",
+            type: "pubkey"
+          },
+          {
+            name: "length",
+            type: "u32"
+          },
+          {
+            name: "data",
+            type: "bytes"
+          }
+        ]
+      }
+    },
+    {
+      name: "DelAttestorEvent",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "address",
+            type: {
+              array: [
+                "u8",
+                20
+              ]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "PrimusState",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "owner",
+            type: "pubkey"
+          },
+          {
+            name: "attestors",
+            type: {
+              vec: {
+                defined: {
+                  name: "Attestor"
+                }
+              }
+            }
+          },
+          {
+            name: "bump",
+            type: "u8"
+          }
+        ]
+      }
+    }
+  ]
+};
+
+// src/classes/solana/sdk.ts
+import * as anchor2 from "@coral-xyz/anchor";
+import {
+  PublicKey as PublicKey3,
+  SystemProgram,
+  Transaction,
+  Keypair
+} from "@solana/web3.js";
+
+// src/classes/solana/attestation_schema.ts
+import * as borsh2 from "borsh";
+var { serialize } = borsh2;
+var Attestor = class {
+  attestorAddr;
+  url;
+  constructor(fields) {
+    this.attestorAddr = fields.attestorAddr;
+    this.url = fields.url;
+  }
+};
+var AttNetworkRequest = class {
+  url;
+  header;
+  method;
+  body;
+  constructor(fields) {
+    this.url = fields.url;
+    this.header = fields.header;
+    this.method = fields.method;
+    this.body = fields.body;
+  }
+};
+var AttNetworkResponseResolve = class {
+  keyName;
+  parseType;
+  parsePath;
+  constructor(fields) {
+    this.keyName = fields.keyName;
+    this.parseType = fields.parseType;
+    this.parsePath = fields.parsePath;
+  }
+};
+var Attestation = class {
+  recipient;
+  request;
+  responseResolve;
+  data;
+  attConditions;
+  timestamp;
+  additionParams;
+  attestors;
+  signatures;
+  constructor(fields) {
+    this.recipient = fields.recipient;
+    this.request = new AttNetworkRequest(fields.request);
+    this.responseResolve = fields.responseResolve.map((x) => new AttNetworkResponseResolve(x));
+    this.data = fields.data;
+    this.attConditions = fields.attConditions;
+    this.timestamp = fields.timestamp;
+    this.additionParams = fields.additionParams;
+    this.attestors = fields.attestors.map((x) => new Attestor(x));
+    this.signatures = fields.signatures;
+  }
+};
+var schema = /* @__PURE__ */ new Map([
+  [Attestor, {
+    kind: "struct",
+    fields: [
+      ["attestorAddr", [20]],
+      ["url", "string"]
+    ]
+  }],
+  [AttNetworkRequest, {
+    kind: "struct",
+    fields: [
+      ["url", "string"],
+      ["header", "string"],
+      ["method", "string"],
+      ["body", "string"]
+    ]
+  }],
+  [AttNetworkResponseResolve, {
+    kind: "struct",
+    fields: [
+      ["keyName", "string"],
+      ["parseType", "string"],
+      ["parsePath", "string"]
+    ]
+  }],
+  [Attestation, {
+    kind: "struct",
+    fields: [
+      ["recipient", [32]],
+      ["request", AttNetworkRequest],
+      ["responseResolve", [AttNetworkResponseResolve]],
+      ["data", "string"],
+      ["attConditions", "string"],
+      ["timestamp", "u64"],
+      ["additionParams", "string"],
+      ["attestors", [Attestor]],
+      ["signatures", [["u8"]]]
+    ]
+  }]
+]);
+function normalizeAttestationInput(obj) {
+  return new Attestation({
+    ...obj,
+    request: new AttNetworkRequest(obj.request),
+    responseResolve: obj.responseResolve.map((x) => new AttNetworkResponseResolve(x)),
+    attestors: obj.attestors.map((x) => new Attestor(x))
+  });
+}
+function serializeAttestation(attObj) {
+  const borshObj = normalizeAttestationInput(attObj);
+  console.log("attObj", attObj, "serializeAttestation-borshObj", borshObj);
+  const buffer = serialize(schema, borshObj);
+  console.log("attObj=buffer", buffer);
+  return buffer;
+}
+
+// src/classes/solana/pda.ts
+import {
+  PublicKey as PublicKey2
+} from "@solana/web3.js";
+var SEED_PRIMUS_STATE = new TextEncoder().encode("primus_state");
+var SEED_PRIMUS_RE_STATE = new TextEncoder().encode("red_envelope");
+var SEED_PRIMUS_RE_RECORD = new TextEncoder().encode("re_record");
+function getPrimusZktlsPda({
+  programId
+}) {
+  return PublicKey2.findProgramAddressSync(
+    [SEED_PRIMUS_STATE],
+    programId
+  );
+}
+function getPrimusRedEnvelopePda({
+  programId
+}) {
+  return PublicKey2.findProgramAddressSync(
+    [SEED_PRIMUS_RE_STATE],
+    programId
+  );
+}
+function getPrimusRERecordPda({
+  programId,
+  reId
+}) {
+  return PublicKey2.findProgramAddressSync(
+    [SEED_PRIMUS_RE_RECORD, reId],
+    programId
+  );
+}
+
+// src/classes/solana/sdk.ts
+import { utils } from "ethers";
+import { getAssociatedTokenAddress, TOKEN_2022_PROGRAM_ID as TOKEN_2022_PROGRAM_ID2, TOKEN_PROGRAM_ID } from "@solana/spl-token";
+var ERC20_TYPE = 0;
+var CHUNK_SIZE = 960;
+var VERBOSE = 0;
+var RE_USERID_LEN = 8;
+var NATIVETOKENATTBUFFERMAXLEN = 718;
+var ERC20TOKENATTBUFFERMAXLEN = 622;
+async function getATAAndProgramId(connection, mint, owner, allowOwnerOffCurve = false) {
+  const accountInfo = await connection.getAccountInfo(mint);
+  if (!accountInfo) {
+    throw new Error("Mint account does not exist");
+  }
+  const mintOwner = accountInfo.owner;
+  let tokenProgramId;
+  if (mintOwner.equals(TOKEN_PROGRAM_ID)) {
+    tokenProgramId = TOKEN_PROGRAM_ID;
+  } else if (mintOwner.equals(TOKEN_2022_PROGRAM_ID2)) {
+    tokenProgramId = TOKEN_2022_PROGRAM_ID2;
+  } else {
+    throw new Error(
+      `Unknown mint owner: ${mintOwner.toBase58()}. Not SPL or Token-2022`
+    );
+  }
+  const ata = await getAssociatedTokenAddress(
+    mint,
+    owner,
+    allowOwnerOffCurve,
+    tokenProgramId
+  );
+  return { ata, tokenProgramId };
+}
+async function waitForTransactionConfirmation(provider, tx, retries = 5, delayMs = 1e3) {
+  for (let i = 0; i < retries; i++) {
+    const txDetails = await provider.connection.getTransaction(tx, {
+      maxSupportedTransactionVersion: 0,
+      commitment: "confirmed"
+    });
+    if (txDetails) {
+      console.log("Transaction details:", txDetails);
+      if (VERBOSE > 2) {
+        console.log("Program logs:", txDetails.meta?.logMessages);
+      }
+      return txDetails;
+    }
+    await new Promise((res) => setTimeout(res, delayMs));
+  }
+  console.warn(`Transaction ${tx} not found after ${retries} retries.`);
+  return null;
+}
+async function reSend({
+  redEnvelopeProgram,
+  userKey,
+  provider,
+  tipToken,
+  reSendParam
+}) {
+  return new Promise(async (resolve, reject) => {
+    let signatureStr;
+    try {
+      const spaceAccount = Keypair.generate();
+      const space = 8 + 32 + 4 + 8 * reSendParam.number + 4 + RE_USERID_LEN * reSendParam.number;
+      if (space > 10 * 1024 * 1024 - 256) {
+        throw "Cannot make so large space[" + space.toString() + "]";
+      }
+      const lamports = await provider.connection.getMinimumBalanceForRentExemption(space);
+      console.log("spaceAccount:", spaceAccount.publicKey.toBase58(), "space:", space, "minimum rent:", lamports / 1e9, "SOL");
+      const createIx = SystemProgram.createAccount({
+        fromPubkey: userKey,
+        newAccountPubkey: spaceAccount.publicKey,
+        lamports,
+        space,
+        programId: redEnvelopeProgram.programId
+      });
+      debugger;
+      const reRecordDataInitIx = await redEnvelopeProgram.methods.reRecordDataInit().accounts({
+        reRecordData: spaceAccount.publicKey,
+        sender: userKey
+      }).signers([spaceAccount]).instruction();
+      debugger;
+      const [redEnvelopePda] = getPrimusRedEnvelopePda({ programId: redEnvelopeProgram.programId });
+      const redEnvelopeState = await redEnvelopeProgram.account.redEnvelopeState.fetch(redEnvelopePda);
+      console.log("idCounter", redEnvelopeState.idCounter.toString());
+      const idCounter = new anchor2.BN(redEnvelopeState.idCounter);
+      const idCounterBytes = idCounter.toArrayLike(Buffer, "le", 16);
+      const reId = Buffer.from(utils.arrayify(utils.keccak256(idCounterBytes)));
+      const [reRecordPda] = getPrimusRERecordPda({ programId: redEnvelopeProgram.programId, reId });
+      let mint = null;
+      let fromTokenAccount = null;
+      let toTokenAccount = null;
+      let tokenProgram = TOKEN_PROGRAM_ID;
+      if (tipToken.tokenType == ERC20_TYPE) {
+        mint = tipToken.tokenAddress;
+        const from = await getATAAndProgramId(provider.connection, mint, userKey, false);
+        const to = await getATAAndProgramId(provider.connection, mint, redEnvelopePda, true);
+        if (from.tokenProgramId != to.tokenProgramId) {
+          throw new Error(
+            `from.tokenProgramId ${from.tokenProgramId.toBase58()} not equal to.tokenProgramId ${to.tokenProgramId.toBase58()}`
+          );
+        }
+        fromTokenAccount = from.ata;
+        toTokenAccount = to.ata;
+        tokenProgram = from.tokenProgramId;
+      }
+      debugger;
+      const reSendIx = await redEnvelopeProgram.methods.reSend(Array.from(reId), tipToken, reSendParam).accounts({
+        state: redEnvelopePda,
+        reRecord: reRecordPda,
+        reRecordData: spaceAccount.publicKey,
+        sender: userKey,
+        // SPL
+        fromTokenAccount,
+        toTokenAccount,
+        mint,
+        tokenProgram
+      }).instruction();
+      const tx = new Transaction().add(createIx).add(reRecordDataInitIx).add(reSendIx);
+      tx.feePayer = userKey;
+      tx.recentBlockhash = (await provider.connection.getLatestBlockhash()).blockhash;
+      tx.partialSign(spaceAccount);
+      const signedTx = await provider.wallet.signTransaction(tx);
+      signatureStr = getTxSigStrFromTx(signedTx);
+      const isOnChain = await getTxIsOnChain(signatureStr, provider.connection);
+      if (isOnChain) {
+        console.log("reSend done, reId: ", reId.toString("hex"), signatureStr);
+        return resolve(signatureStr);
+      } else {
+        const serializeSignedTx = signedTx.serialize();
+        console.log("signedTx", signedTx, serializeSignedTx, tx.recentBlockhash);
+        signatureStr = await provider.connection.sendRawTransaction(serializeSignedTx);
+        console.log("reSend done, reId: ", reId.toString("hex"), signatureStr);
+        return resolve(signatureStr);
+      }
+    } catch (err) {
+      if (getTxIsOnProcess(err)) {
+        console.log("reSenderWithdraw done");
+        return resolve(signatureStr);
+      } else {
+        console.error("reSend error:", err);
+        const formatErr = formatErrFn(err);
+        return reject(formatErr);
+      }
+    } finally {
+    }
+  });
+}
+async function reClaim({
+  redEnvelopeProgram,
+  userKey,
+  provider,
+  zktlsProgram,
+  reId,
+  attObj
+}) {
+  return new Promise(async (resolve, reject) => {
+    const [redEnvelopePda] = getPrimusRedEnvelopePda({ programId: redEnvelopeProgram.programId });
+    const [reRecordPda] = getPrimusRERecordPda({ programId: redEnvelopeProgram.programId, reId });
+    const [primusZktlsPda] = getPrimusZktlsPda({ programId: zktlsProgram.programId });
+    console.log("primusZktlsPda:", primusZktlsPda.toBase58());
+    console.log("reRecordPda:", reRecordPda.toBase58());
+    const attRecipient = new PublicKey3(attObj.recipient);
+    const redEnvelopeState = await redEnvelopeProgram.account.redEnvelopeState.fetch(redEnvelopePda);
+    console.log("redEnvelopeState.feeRecipient", redEnvelopeState.feeRecipient.toBase58());
+    const feeRecipient = redEnvelopeState.feeRecipient;
+    const reRecord = await redEnvelopeProgram.account.reRecord.fetch(reRecordPda);
+    let tx;
+    let signatureStr;
+    const dataBuffer = anchor2.web3.Keypair.generate();
+    const dataBufferKey = dataBuffer.publicKey;
+    const attBuffer = serializeAttestation(attObj);
+    console.log(`attBuffer.length=${attBuffer.length}`);
+    let storeInitialized = false;
+    let useStoreVersion = false;
+    debugger;
+    if (reRecord.tokenType == ERC20_TYPE && attBuffer.length > ERC20TOKENATTBUFFERMAXLEN || reRecord.tokenType != ERC20_TYPE && attBuffer.length > NATIVETOKENATTBUFFERMAXLEN) {
+      useStoreVersion = true;
+    }
+    try {
+      if (useStoreVersion) {
+        const txStoreInitialize = await zktlsProgram.methods.storeInitialize(attBuffer.length).accounts({ dataBuffer: dataBufferKey, user: userKey }).signers([dataBuffer]).rpc();
+        await waitForTransactionConfirmation(provider, txStoreInitialize);
+        storeInitialized = true;
+        console.log("storeInitialize done");
+        for (let offset = 0; offset < attBuffer.length; offset += CHUNK_SIZE) {
+          const chunk = attBuffer.slice(offset, offset + CHUNK_SIZE);
+          const txStoreChunk = await zktlsProgram.methods.storeChunk(Buffer.from(chunk)).accounts({ dataBuffer: dataBufferKey, user: userKey }).rpc();
+          await waitForTransactionConfirmation(provider, txStoreChunk);
+        }
+        console.log("storeChunk done");
+      }
+      const reRecordData2 = await redEnvelopeProgram.account.reRecordData.fetch(reRecord.recordData);
+      console.log("reRecordData2:", reRecordData2);
+      console.log("reRecord.tokenType:", reRecord.tokenType);
+      const reRecordData = reRecord.recordData;
+      console.log("reRecord.recordData", reRecord.recordData.toBase58());
+      let mint = null;
+      let fromTokenAccount = null;
+      let toTokenAccount = null;
+      let tokenProgram = TOKEN_PROGRAM_ID;
+      if (reRecord.tokenType == ERC20_TYPE) {
+        console.log("reRecord.tokenAddress:", reRecord.tokenAddress);
+        mint = reRecord.tokenAddress;
+        const from = await getATAAndProgramId(provider.connection, mint, redEnvelopePda, true);
+        const to = await getATAAndProgramId(provider.connection, mint, attRecipient, false);
+        if (from.tokenProgramId != to.tokenProgramId) {
+          throw new Error(
+            `from.tokenProgramId ${from.tokenProgramId.toBase58()} not equal to.tokenProgramId ${to.tokenProgramId.toBase58()}`
+          );
+        }
+        fromTokenAccount = from.ata;
+        toTokenAccount = to.ata;
+        tokenProgram = from.tokenProgramId;
+      }
+      let _att = attObj;
+      let _dataBufferKey = null;
+      if (useStoreVersion) {
+        _att = null;
+        _dataBufferKey = dataBufferKey;
+      }
+      tx = await redEnvelopeProgram.methods.reClaim(reId, _att).accounts({
+        state: redEnvelopePda,
+        reRecord: reRecordPda,
+        reRecordData,
+        claimer: userKey,
+        primusZktlsProgram: zktlsProgram.programId.toBase58(),
+        primusZktlsState: primusZktlsPda,
+        feeRecipient,
+        attRecipient,
+        dataBuffer: _dataBufferKey,
+        // SPL
+        fromTokenAccount,
+        toTokenAccount,
+        mint,
+        tokenProgram
+      }).transaction();
+      tx.feePayer = userKey;
+      tx.recentBlockhash = (await provider.connection.getLatestBlockhash()).blockhash;
+      const signedTx = await provider.wallet.signTransaction(tx);
+      signatureStr = getTxSigStrFromTx(signedTx);
+      const isOnChain = await getTxIsOnChain(signatureStr, provider.connection);
+      if (isOnChain) {
+        console.log("reClaim done", signatureStr);
+        return resolve(signatureStr);
+      } else {
+        const serializeSignedTx = signedTx.serialize();
+        signatureStr = await provider.connection.sendRawTransaction(serializeSignedTx);
+        console.log("reClaim done ", signatureStr);
+        return resolve(signatureStr);
+      }
+    } catch (err) {
+      if (getTxIsOnProcess(err)) {
+        console.log("reClaim done");
+      } else {
+        console.error("reClaim error:", err);
+        const formatErr = formatErrFn(err);
+        return reject(formatErr);
+      }
+    } finally {
+      if (useStoreVersion && storeInitialized) {
+        try {
+          const txStoreClose = await zktlsProgram.methods.storeClose().accounts({ dataBuffer: dataBufferKey, user: userKey }).rpc();
+          await waitForTransactionConfirmation(provider, txStoreClose);
+          console.log("storeClose done");
+          return resolve(signatureStr);
+        } catch (closeErr) {
+          console.error("Failed to close dataBuffer:", closeErr);
+        }
+      } else {
+        return resolve(signatureStr);
+      }
+    }
+  });
+}
+async function reSenderWithdraw({
+  redEnvelopeProgram,
+  userKey,
+  provider,
+  reId
+}) {
+  return new Promise(async (resolve, reject) => {
+    let tx;
+    let signatureStr;
+    try {
+      const [redEnvelopePda] = getPrimusRedEnvelopePda({ programId: redEnvelopeProgram.programId });
+      const [reRecordPda] = getPrimusRERecordPda({ programId: redEnvelopeProgram.programId, reId });
+      const reRecord = await redEnvelopeProgram.account.reRecord.fetch(reRecordPda);
+      console.log("reRecord.tokenType:", reRecord.tokenType);
+      let mint = null;
+      let fromTokenAccount = null;
+      let toTokenAccount = null;
+      let tokenProgram = TOKEN_PROGRAM_ID;
+      if (reRecord.tokenType == ERC20_TYPE) {
+        console.log("reRecord.tokenAddress:", reRecord.tokenAddress);
+        mint = reRecord.tokenAddress;
+        const from = await getATAAndProgramId(provider.connection, mint, redEnvelopePda, true);
+        const to = await getATAAndProgramId(provider.connection, mint, userKey, false);
+        if (from.tokenProgramId != to.tokenProgramId) {
+          throw new Error(
+            `from.tokenProgramId ${from.tokenProgramId.toBase58()} not equal to.tokenProgramId ${to.tokenProgramId.toBase58()}`
+          );
+        }
+        fromTokenAccount = from.ata;
+        toTokenAccount = to.ata;
+        tokenProgram = from.tokenProgramId;
+      }
+      tx = await redEnvelopeProgram.methods.reSenderWithdraw(reId).accounts({
+        state: redEnvelopePda,
+        reRecord: reRecordPda,
+        reSender: userKey,
+        // SPL
+        fromTokenAccount,
+        toTokenAccount,
+        mint,
+        tokenProgram
+      }).transaction();
+      tx.feePayer = userKey;
+      tx.recentBlockhash = (await provider.connection.getLatestBlockhash()).blockhash;
+      const signedTx = await provider.wallet.signTransaction(tx);
+      signatureStr = getTxSigStrFromTx(signedTx);
+      const isOnChain = await getTxIsOnChain(signatureStr, provider.connection);
+      if (isOnChain) {
+        console.log("reSenderWithdraw done", signatureStr);
+        return resolve(signatureStr);
+      } else {
+        const serializeSignedTx = signedTx.serialize();
+        signatureStr = await provider.connection.sendRawTransaction(serializeSignedTx);
+        console.log("reSenderWithdraw done", signatureStr);
+        return resolve(signatureStr);
+      }
+    } catch (err) {
+      if (getTxIsOnProcess(err)) {
+        console.log("reSenderWithdraw done");
+        return resolve(signatureStr);
+      } else {
+        console.error("reSenderWithdraw error:", err);
+        const formatErr = formatErrFn(err);
+        return reject(formatErr);
+      }
+    }
+  });
+}
+async function getREInfo({
+  redEnvelopeProgram,
+  reId
+}) {
+  return new Promise(async (resolve, reject) => {
+    try {
+      const [reRecordPda] = getPrimusRERecordPda({ programId: redEnvelopeProgram.programId, reId });
+      const reRecord = await redEnvelopeProgram.account.reRecord.fetch(reRecordPda);
+      console.log("getREInfo done", reRecord);
+      return resolve(reRecord);
+    } catch (err) {
+      console.error("getREInfo error:", err);
+      const formatErr = formatErrFn(err);
+      return reject(formatErr);
+    }
+  });
+}
+
+// src/classes/FundOnSolanaForRedPacket.ts
+import { PublicKey as PublicKey4 } from "@solana/web3.js";
+var FundOnSolanaForRedPacket = class {
+  fundContract;
+  provider;
+  constructor() {
+  }
+  async init(provider, chainId) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        this.fundContract = getProgram(redPacketIdl_default, provider);
+        this.provider = provider;
+        resolve("success");
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  async fund(tokenInfo, sendParam) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        let decimals = 9;
+        let amountOnChain;
+        let formatTokenInfo = { ...tokenInfo };
+        if (tokenInfo.tokenType === 1) {
+          formatTokenInfo.tokenAddress = anchor3.web3.PublicKey.default;
+          amountOnChain = toTokenAmount(sendParam.amount, decimals);
+        } else if (tokenInfo.tokenType === 0) {
+          decimals = await getTokenDecimals(tokenInfo.tokenAddress, this.provider.connection);
+          amountOnChain = toTokenAmount(sendParam.amount, decimals);
+          formatTokenInfo.tokenAddress = new PublicKey4(tokenInfo.tokenAddress);
+        }
+        const reSendParam = {
+          ...sendParam,
+          amount: amountOnChain,
+          checkContract: sendParam.checkContract || anchor3.web3.PublicKey.default
+        };
+        const result = await reSend({
+          redEnvelopeProgram: this.fundContract,
+          userKey: this.provider.publicKey,
+          provider: this.provider,
+          tipToken: formatTokenInfo,
+          reSendParam
+        });
+        resolve(result);
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  async claim(redPacketId, attestation) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const zktlsProgram = getProgram(zktlsIdl_default, this.provider);
+        const attObj = formatAttestation(attestation);
+        let formatReId = hexToUint8Array(redPacketId);
+        const result = await reClaim({
+          redEnvelopeProgram: this.fundContract,
+          userKey: this.provider.publicKey,
+          provider: this.provider,
+          zktlsProgram,
+          reId: formatReId,
+          attObj
+        });
+        return resolve(result);
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  async withdraw(redPacketId) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        let formatReId = hexToUint8Array(redPacketId);
+        const result = await reSenderWithdraw({
+          redEnvelopeProgram: this.fundContract,
+          userKey: this.provider.publicKey,
+          provider: this.provider,
+          reId: formatReId
+        });
+        return resolve(result);
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  async getRedPacketInfo(redPacketId) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        let formatReId = hexToUint8Array(redPacketId);
+        const result = await getREInfo({ redEnvelopeProgram: this.fundContract, reId: formatReId });
+        const redpacketInfo = { ...result, id: redPacketId };
+        return resolve(redpacketInfo);
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  async decodeReSendEvent(eventData) {
+    return await decodeReSendEvent(eventData);
+  }
+  async decodeClaimEvent(eventData) {
+    return await decodeClaimEvent(eventData);
+  }
+};
+
+// src/classes/ZktlsSdk.ts
+import { PrimusZKTLS } from "@primuslabs/zktls-js-sdk";
+var ZktlsSdk = class {
+  zkTlsSdk;
+  constructor() {
+  }
+  getZkTlsSdk() {
+    return this.zkTlsSdk;
+  }
+  async init(appId) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        this.zkTlsSdk = new PrimusZKTLS();
+        let platformDevice = "pc";
+        const isIpad = () => {
+          const userAgent = navigator.userAgent.toLowerCase();
+          const isTabletSize = window.innerWidth > 768 && window.innerWidth < 1366;
+          return /ipad/.test(userAgent) || navigator.platform === "MacIntel" && navigator.maxTouchPoints > 0 && isTabletSize;
+        };
+        if (navigator.userAgent.toLocaleLowerCase().includes("android")) {
+          platformDevice = "android";
+        } else if (navigator.userAgent.toLocaleLowerCase().includes("iphone") || isIpad()) {
+          platformDevice = "ios";
+        }
+        console.log("init appId", appId, platformDevice);
+        const extensionVersion = await this.zkTlsSdk.init(
+          appId,
+          "",
+          { platform: platformDevice }
+        );
+        resolve(extensionVersion);
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  async attest(attestParams, signFn, backUrl) {
+    return new Promise(async (resolve, reject) => {
+      console.log("this.zkTlsSdk", this.zkTlsSdk);
+      const { socialPlatform, userIdentifier, address } = attestParams;
+      const { id: templateId, field } = DATASOURCETEMPLATESMAP[socialPlatform];
+      const attRequest = this.zkTlsSdk.generateRequestParams(
+        templateId,
+        address
+      );
+      if (backUrl) {
+        attRequest.setBackUrl(backUrl);
+      }
+      console.log(`attRequest: ${JSON.stringify(attRequest)}`);
+      attRequest.setAttConditions([
+        [
+          {
+            field,
+            op: "STREQ",
+            value: userIdentifier
+          }
+        ]
+      ]);
+      const signParams = attRequest.toJsonString();
+      const signature = await signFn(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)
+        );
+        return resolve(attestation);
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  async attestCommon(attestParams) {
+    const { templateId, address, signFn, conditions, additionParams, backUrl } = attestParams;
+    return new Promise(async (resolve, reject) => {
+      console.log("this.zkTlsSdk", this.zkTlsSdk);
+      const attRequest = this.zkTlsSdk.generateRequestParams(
+        templateId,
+        address
+      );
+      if (backUrl) {
+        attRequest.setBackUrl(backUrl);
+      }
+      console.log(`attRequest: ${JSON.stringify(attRequest)}`);
+      if (conditions) {
+        attRequest.setAttConditions(conditions);
+      }
+      if (additionParams) {
+        console.log("setAdditionParams--", additionParams);
+        attRequest.setAdditionParams(additionParams);
+      }
+      const signParams = attRequest.toJsonString();
+      const signature = await signFn(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)
+        );
+        return resolve(attestation);
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+};
+
+// src/index.ts
+console.log("SUPPORTEDCHAINIDS444", SUPPORTEDCHAINIDS);
+var PrimusFund = class {
+  supportedChainIds = SUPPORTEDCHAINIDS;
+  supportedSocialPlatforms = SUPPORTEDSOCIALPLATFORMS;
+  provider;
+  _fund;
+  _fundForRedPacket;
+  _fundOnSolanaForRedPacket;
+  // TODO
+  _zkTlsSdk;
+  static utils = {
+    decodeReSendEvent,
+    decodeClaimEvent
+  };
+  async init(provider, chainId, appId) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        if (!this.supportedChainIds.includes(chainId) && !SUPPORTEDSOLANACHAINIDS.includes(chainId)) {
+          return reject("chainId is not supported");
+        }
+        if (this.supportedChainIds.includes(chainId)) {
+          let formatProvider;
+          let signer;
+          if (provider instanceof ethers5.providers.JsonRpcProvider) {
+            formatProvider = provider;
+          } else {
+            formatProvider = new ethers5.providers.Web3Provider(provider);
+            signer = formatProvider.getSigner();
+          }
+          await formatProvider.ready;
+          const network = await formatProvider.getNetwork();
+          const providerChainId = network.chainId;
+          console.log("init provider", provider, network);
+          console.log("init providerChainId", providerChainId, chainId);
+          if (providerChainId !== chainId) {
+            return reject(`Please connect to the chain with ID ${chainId} first.`);
+          }
+          this.provider = signer ?? formatProvider;
+          this._fund = new Fund();
+          await this._fund.init(this.provider, chainId);
+          this._fundForRedPacket = new FundForRedPacket();
+          await this._fundForRedPacket.init(this.provider, chainId);
+        } else if (SUPPORTEDSOLANACHAINIDS.includes(chainId)) {
+          this.provider = provider;
+          this._fundOnSolanaForRedPacket = new FundOnSolanaForRedPacket();
+          this._fundOnSolanaForRedPacket.init(provider, chainId);
+        }
+        if (appId) {
+          this._zkTlsSdk = new ZktlsSdk();
+          await this._zkTlsSdk.init(appId);
+        }
+        return resolve(true);
+      } 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 = ethers5.constants.AddressZero;
+        }
+        const newFundRecipientInfos = recipientInfos.map((i) => {
+          const formatSocialPlatform = i.socialPlatform.toLowerCase();
+          let formatUserIdentifier = i.userIdentifier;
+          if (i.socialPlatform === "x" && i.userIdentifier.startsWith("@")) {
+            formatUserIdentifier = i.userIdentifier.slice(1);
+          }
+          return {
+            nftIds: i.nftIds ?? [],
+            socialPlatform: formatSocialPlatform,
+            userIdentifier: formatUserIdentifier,
+            tokenAmount: i.tokenAmount
+          };
+        });
+        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 approve(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 = ethers5.constants.AddressZero;
+        }
+        const newFundRecipientInfos = recipientInfos.map((i) => {
+          const formatSocialPlatform = i.socialPlatform.toLowerCase();
+          let formatUserIdentifier = i.userIdentifier;
+          if (i.socialPlatform === "x" && i.userIdentifier.startsWith("@")) {
+            formatUserIdentifier = i.userIdentifier.slice(1);
+          }
+          return {
+            nftIds: i.nftIds ?? [],
             socialPlatform: formatSocialPlatform,
             userIdentifier: formatUserIdentifier,
             tokenAmount: i.tokenAmount
@@ -3188,10 +6640,15 @@ var PrimusFund = class {
       }
     });
   }
-  async getRedPacketInfo(redPacketId) {
+  async getRedPacketInfo(redPacketId, chainId) {
     return new Promise(async (resolve, reject) => {
       try {
-        const result = await this._fundForRedPacket?.getRedPacketInfo(redPacketId);
+        let result;
+        if (chainId && typeof chainId === "string") {
+          result = await this._fundOnSolanaForRedPacket?.getRedPacketInfo(redPacketId);
+        } else {
+          result = await this._fundForRedPacket?.getRedPacketInfo(redPacketId);
+        }
         return resolve(result);
       } catch (error) {
         return reject(error);
@@ -3229,6 +6686,52 @@ var PrimusFund = class {
       }
     });
   }
+  async fundonSolanaForRedPacket(fundParam) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const { tokenInfo, sendParam } = fundParam;
+        const result = await this._fundOnSolanaForRedPacket?.fund(tokenInfo, sendParam);
+        return resolve(result);
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  async claimOnSolanaForRedPacket(redPacketId, attestation) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        let formatAttestation2 = { ...attestation, responseResolve: attestation.reponseResolve };
+        delete formatAttestation2.reponseResolve;
+        const result = await this._fundOnSolanaForRedPacket?.claim(redPacketId, formatAttestation2);
+        return resolve(result);
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  async withdrawOnSolanaForRedPacket(redPacketId) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const result = await this._fundOnSolanaForRedPacket?.withdraw(redPacketId);
+        return resolve(result);
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+  // async testReSend(params: any) {
+  //   const p = getProgram(redPacketIdl, params.provider)
+  //   await testReSend({ redEnvelopeProgram: p, ...params })
+  // }
+  // async testReClaim(params: any) {
+  //   const resPacketP = getProgram(redPacketIdl, params.provider)
+  //   const zktlsP = getProgram(zktlsIdl, params.provider)
+  //   await testReClaim({ redEnvelopeProgram: resPacketP, zktlsProgram: zktlsP, ...params })
+  // }
+  // async testReSenderWithdraw(params: any) {
+  //   const resPacketP = getProgram(redPacketIdl, params.provider)
+  //   await testReSenderWithdraw({ redEnvelopeProgram: resPacketP, ...params })
+  // }
 };
 export {
   PrimusFund