@sign-global/tokentable 0.5.3-beta.0 → 1.0.0

package/dist/index.js

@@ -0,0 +1,828 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AirdropClient: () => AirdropClient,
+  SignatureAirdropClient: () => SignatureAirdropClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/AirdropClient.ts
+var import_tokentable_core5 = require("@sign-global/tokentable-core");
+
+// src/strategies/AirdropStrategyFactory.ts
+var import_tokentable_core4 = require("@sign-global/tokentable-core");
+
+// src/strategies/EvmAirdropStrategy.ts
+var import_tokentable_core = require("@sign-global/tokentable-core");
+var EvmAirdropStrategy = class {
+  service;
+  contractAddress;
+  chainId;
+  chainRpc;
+  walletClient;
+  cachedVersion = null;
+  constructor(params) {
+    this.contractAddress = params.contractAddress;
+    this.chainId = Number(params.chainId);
+    this.chainRpc = params.chainRpc;
+    if (params.walletClient) {
+      this.walletClient = params.walletClient;
+    }
+  }
+  async initialize(walletClient) {
+    if (walletClient) {
+      this.walletClient = walletClient;
+    }
+    this.service = new import_tokentable_core.EvmAirdropService({
+      contractAddress: this.contractAddress,
+      chainId: this.chainId,
+      walletClient: this.walletClient,
+      chainRpc: this.chainRpc
+    });
+  }
+  isInitialized() {
+    return !!this.service;
+  }
+  async getVersion() {
+    if (this.cachedVersion) {
+      return this.cachedVersion;
+    }
+    if (!this.service) throw new Error("Strategy not initialized");
+    this.cachedVersion = await this.service.getVersion();
+    return this.cachedVersion;
+  }
+  async claim(claimData) {
+    if (!this.service) throw new Error("Strategy not initialized");
+    const { proof, group, data, value, extraData } = claimData;
+    return this.service.claim({
+      proof,
+      group,
+      data,
+      value,
+      extraData
+    });
+  }
+  async checkClaimed(claimData) {
+    if (!this.service) throw new Error("Strategy not initialized");
+    return this.service.isLeafUsed(claimData.leaf);
+  }
+  async batchCheckClaimed(leafs) {
+    if (!this.service) throw new Error("Strategy not initialized");
+    return this.service.batchFetchClaimed(leafs);
+  }
+  async getNFT() {
+    if (!this.service) throw new Error("Strategy not initialized");
+    return this.service.getNFT();
+  }
+  async getKycThreshold() {
+    if (!this.service) throw new Error("Strategy not initialized");
+    return this.service.getKycThreshold();
+  }
+  async getClaimFee(contractAddress, amount) {
+    if (!this.service) throw new Error("Strategy not initialized");
+    return this.service.getClaimFee(contractAddress, amount);
+  }
+};
+
+// src/strategies/SolanaAirdropStrategy.ts
+var import_tokentable_core2 = require("@sign-global/tokentable-core");
+var SolanaAirdropStrategy = class {
+  service;
+  chainId;
+  chainRpc;
+  walletClient;
+  cachedVersion = null;
+  projectId;
+  constructor(params) {
+    this.chainId = params.chainId;
+    this.projectId = params.projectId;
+    this.chainRpc = params.chainRpc;
+    if (params.walletClient) {
+      this.walletClient = params.walletClient;
+    }
+  }
+  async initialize(walletClient) {
+    if (walletClient) {
+      this.walletClient = walletClient;
+    }
+    this.service = new import_tokentable_core2.SolanaAirdropService({
+      projectId: this.projectId,
+      chainId: this.chainId,
+      walletClient: this.walletClient,
+      chainRpc: this.chainRpc
+    });
+  }
+  isInitialized() {
+    return !!this.service;
+  }
+  async getVersion() {
+    if (this.cachedVersion) {
+      return this.cachedVersion;
+    }
+    if (!this.service) throw new Error("Strategy not initialized");
+    this.cachedVersion = await this.service.getVersion();
+    return this.cachedVersion;
+  }
+  async claim(claimData) {
+    if (!this.service) throw new Error("Strategy not initialized");
+    return this.service.claim(claimData);
+  }
+  async checkClaimed(claimData) {
+    if (!this.service) throw new Error("Strategy not initialized");
+    return this.service.isLeafUsed(claimData.leaf);
+  }
+  async batchCheckClaimed(leafs) {
+    if (!this.service) throw new Error("Strategy not initialized");
+    return this.service.batchFetchClaimed(leafs);
+  }
+  async getClaimFee(contractAddress, amount) {
+    if (!this.service) throw new Error("Strategy not initialized");
+    return this.service.getClaimFee(contractAddress, amount);
+  }
+  async getPaused() {
+    if (!this.service) throw new Error("Strategy not initialized");
+    return this.service.getPaused();
+  }
+};
+
+// src/strategies/TonAirdropStrategy.ts
+var import_tokentable_core3 = require("@sign-global/tokentable-core");
+var TonAirdropStrategy = class {
+  service;
+  contractAddress;
+  chainId;
+  tonClient;
+  walletClient;
+  cachedVersion = null;
+  constructor(params) {
+    this.contractAddress = params.contractAddress;
+    this.chainId = params.chainId.toString();
+    this.tonClient = params.tonClient;
+    if (params.walletClient) {
+      this.walletClient = params.walletClient;
+    }
+    if (params.version) {
+      this.cachedVersion = params.version;
+    }
+  }
+  async initialize(walletClient) {
+    if (walletClient) {
+      this.walletClient = walletClient;
+    }
+    this.service = new import_tokentable_core3.TonAirdropService({
+      address: this.contractAddress,
+      chainId: this.chainId,
+      walletClient: this.walletClient,
+      tonClient: this.tonClient,
+      version: this.cachedVersion || void 0
+    });
+  }
+  isInitialized() {
+    return !!this.service;
+  }
+  async getVersion() {
+    if (!this.service) throw new Error("Strategy not initialized");
+    if (!this.cachedVersion) {
+      this.cachedVersion = await this.service.getVersion();
+    }
+    return this.cachedVersion;
+  }
+  async claim(claimData, options) {
+    if (!this.service) throw new Error("Strategy not initialized");
+    return this.service.claim(claimData, options);
+  }
+  async checkClaimed(claimData) {
+    if (!this.service) throw new Error("Strategy not initialized");
+    return this.service.checkClaimed(claimData);
+  }
+  async getPaused() {
+    if (!this.service) throw new Error("Strategy not initialized");
+    return this.service.getPaused();
+  }
+  async getClaimFee(contractAddress, amount) {
+    if (!this.service) throw new Error("Strategy not initialized");
+    return this.service.getClaimFee(contractAddress, amount);
+  }
+};
+
+// src/strategies/AirdropStrategyFactory.ts
+var AirdropStrategyFactory = class {
+  static strategyMap = {
+    [import_tokentable_core4.ChainType.Evm]: EvmAirdropStrategy,
+    [import_tokentable_core4.ChainType.Ton]: TonAirdropStrategy,
+    [import_tokentable_core4.ChainType.Solana]: SolanaAirdropStrategy
+  };
+  static createStrategy(params) {
+    const { chainType, ...strategyParams } = params;
+    const StrategyClass = this.strategyMap[chainType];
+    if (!StrategyClass) {
+      throw new Error(`Unsupported chain type: ${chainType}`);
+    }
+    return new StrategyClass(strategyParams);
+  }
+};
+
+// src/strategies/StrategyCache.ts
+var StrategyCache = class {
+  readOnlyStrategies = /* @__PURE__ */ new Map();
+  walletStrategies = /* @__PURE__ */ new Map();
+  getCacheKey(contractAddress, chainId, chainType) {
+    return `${chainType}:${contractAddress}:${chainId}`;
+  }
+  getStrategy(contractAddress, chainId, chainType, hasWallet = false) {
+    const cache = hasWallet ? this.walletStrategies : this.readOnlyStrategies;
+    const cacheKey = this.getCacheKey(contractAddress, chainId, chainType);
+    return cache.get(cacheKey);
+  }
+  setStrategy(contractAddress, chainId, chainType, strategy, hasWallet = false) {
+    const cache = hasWallet ? this.walletStrategies : this.readOnlyStrategies;
+    const cacheKey = this.getCacheKey(contractAddress, chainId, chainType);
+    cache.set(cacheKey, strategy);
+  }
+  clearStrategy(contractAddress, chainId, chainType, hasWallet) {
+    const cacheKey = this.getCacheKey(contractAddress, chainId, chainType);
+    if (hasWallet === void 0 || hasWallet) {
+      this.walletStrategies.delete(cacheKey);
+    }
+    if (hasWallet === void 0 || !hasWallet) {
+      this.readOnlyStrategies.delete(cacheKey);
+    }
+  }
+};
+var strategyCache = new StrategyCache();
+
+// src/AirdropClient.ts
+var AirdropClient = class {
+  tonClient;
+  slug;
+  projectId;
+  endpoint;
+  project;
+  chainRpc;
+  claims;
+  projectPromise;
+  claimHook;
+  contractConfig = null;
+  constructor(params) {
+    if ("slug" in params) {
+      this.slug = params.slug;
+    }
+    this.projectId = params.projectId;
+    this.endpoint = params.endpoint;
+    this.chainRpc = params.chainRpc;
+    if (this.project) {
+      this.project = params.project;
+    } else {
+      this.projectPromise = this.initializeProjects();
+    }
+  }
+  setTonClient(tonClient) {
+    this.tonClient = tonClient;
+  }
+  getTonClient() {
+    if (!this.tonClient) {
+      return void 0;
+    }
+    return this.tonClient;
+  }
+  async fetchProjectFromSlug(address) {
+    if (!this.slug) return void 0;
+    const res = await (0, import_tokentable_core5.getAirdropPro)(this.slug, this.endpoint);
+    const projectMap = res?.childProjectMapping || {};
+    return (0, import_tokentable_core5.getTonProjectIdByAddress)({
+      address,
+      slug: this.slug,
+      data: projectMap
+    });
+  }
+  async fetchProjectDetails(projectId) {
+    const project = await (0, import_tokentable_core5.getAirdropProject)(projectId, this.endpoint);
+    this.project = project;
+    if (this.chainRpc) return;
+    const chainId = project.chainType === import_tokentable_core5.ChainType.Evm ? Number(project.chainId) : project.chainId;
+    this.chainRpc = (0, import_tokentable_core5.getChainRpc)(chainId);
+  }
+  async initializeProjects(address) {
+    try {
+      let projectId = this.projectId;
+      if (!projectId) {
+        projectId = await this.fetchProjectFromSlug(address);
+      }
+      if (!projectId) {
+        return;
+      }
+      await this.fetchProjectDetails(projectId);
+    } catch (error) {
+      throw new Error(`Failed to initialize project: ${error.message}`);
+    }
+  }
+  async getProjectInfo() {
+    if (this.projectPromise) {
+      await this.projectPromise;
+    }
+    if (!this.project) throw new Error("Project not found");
+    return this.project;
+  }
+  async getAirdropClaims(data) {
+    if (this.slug) {
+      await this.initializeProjects(data.address);
+    }
+    const project = await this.getProjectInfo();
+    const res = await (0, import_tokentable_core5.getAirdropQuery)(
+      {
+        recipient: data.address,
+        projectId: project.id,
+        recipientType: project.recipientType
+      },
+      this.endpoint
+    );
+    const claimsRes = res.claims?.map((it) => ({
+      ...it,
+      project,
+      claimId: project.chainType === import_tokentable_core5.ChainType.Evm ? `${project.id}:${it.leaf}` : `${project.id}:${it.index}`
+    }));
+    this.claims = claimsRes;
+    return this.claims;
+  }
+  async getStrategy(walletClient) {
+    const project = await this.getProjectInfo();
+    const version = this.contractConfig?.version || void 0;
+    const hasWallet = !!walletClient;
+    let strategy = strategyCache.getStrategy(project.contractAddress, project.chainId, project.chainType, hasWallet);
+    if (!strategy) {
+      strategy = AirdropStrategyFactory.createStrategy({
+        chainType: project.chainType,
+        contractAddress: project.contractAddress,
+        chainId: project.chainId,
+        projectId: project.id,
+        walletClient,
+        tonClient: this.getTonClient(),
+        version,
+        chainRpc: this.chainRpc
+      });
+      await strategy.initialize(walletClient);
+      strategyCache.setStrategy(project.contractAddress, project.chainId, project.chainType, strategy, hasWallet);
+    } else if (hasWallet) {
+      await strategy.initialize(walletClient);
+    }
+    return strategy;
+  }
+  getClaimDataById(claimId) {
+    const claimData = this.claims?.find((it) => it.claimId === claimId);
+    if (!claimData) throw new Error("Claim data not found");
+    return claimData;
+  }
+  setClaimHook(fn) {
+    this.claimHook = fn;
+  }
+  getDefaultExtraData() {
+    return {
+      isLegacy: true,
+      attestationId: BigInt(1)
+    };
+  }
+  async calculateClaimFee(project, claimAmount) {
+    if (project.chainType === import_tokentable_core5.ChainType.Evm) {
+      const version = await this.getVersion();
+      const isNativeFreeVersion = project.tokenType === import_tokentable_core5.ETokenType.Native && [import_tokentable_core5.EvmAirdropVersionEnum.V3, import_tokentable_core5.EvmAirdropVersionEnum.V4].includes(version);
+      return isNativeFreeVersion ? void 0 : await this.getClaimFee(BigInt(claimAmount));
+    }
+    if (project.chainType === import_tokentable_core5.ChainType.Ton) {
+      return await this.getClaimFee(BigInt(claimAmount));
+    }
+    return void 0;
+  }
+  async claimAirdrop({ claimId, walletClient }, options) {
+    const claimData = this.getClaimDataById(claimId);
+    const strategy = await this.getStrategy(walletClient);
+    const project = await this.getProjectInfo();
+    const extraData = project.chainType === import_tokentable_core5.ChainType.Ton ? void 0 : this.claimHook ? this.claimHook(claimData) : this.getDefaultExtraData();
+    const value = await this.calculateClaimFee(project, claimData.amount);
+    return strategy.claim(
+      {
+        ...claimData,
+        extraData,
+        value
+      },
+      options
+    );
+  }
+  async checkClaimed(claimId) {
+    const claimData = this.getClaimDataById(claimId);
+    const strategy = await this.getStrategy();
+    return strategy.checkClaimed(claimData);
+  }
+  async getContractConfig() {
+    try {
+      const project = await this.getProjectInfo();
+      if (!this.contractConfig && [import_tokentable_core5.ChainType.Evm, import_tokentable_core5.ChainType.Ton].includes(project.chainType)) {
+        this.contractConfig = await (0, import_tokentable_core5.getAirdropContractConfig)(
+          {
+            chainId: project.chainId,
+            chainType: project.chainType,
+            contractAddress: project.contractAddress
+          },
+          this.endpoint
+        );
+      }
+      return this.contractConfig;
+    } catch (error) {
+      console.error("Error fetching contract config:", error);
+      return null;
+    }
+  }
+  async getVersion() {
+    const config = await this.getContractConfig();
+    if (config?.version) {
+      return config.version;
+    }
+    const strategy = await this.getStrategy();
+    return strategy.getVersion();
+  }
+  async getPaused() {
+    const config = await this.getContractConfig();
+    if (config && config?.paused !== null) {
+      return config.paused;
+    }
+    const strategy = await this.getStrategy();
+    if (!strategy.getPaused) {
+      throw new Error("getPaused is not supported for this chain");
+    }
+    return strategy.getPaused();
+  }
+  async getClaimFee(amount, walletClient) {
+    const config = await this.getContractConfig();
+    if (config?.claimFee) {
+      return config.claimFee;
+    }
+    const strategy = await this.getStrategy(walletClient);
+    if (!strategy.getClaimFee) {
+      throw new Error("getClaimFee is not supported for this chain");
+    }
+    return strategy.getClaimFee(this.project?.contractAddress || "", amount || BigInt(0));
+  }
+  // params claimId[]
+  async batchCheckClaimed() {
+    const strategy = await this.getStrategy();
+    if (!strategy.batchCheckClaimed) {
+      throw new Error("batchCheckClaimed is not supported for this chain");
+    }
+    const leafs = this.claims?.map((it) => it.leaf);
+    if (!leafs) return [];
+    return strategy.batchCheckClaimed(leafs);
+  }
+  async getNFT() {
+    const strategy = await this.getStrategy();
+    if (!strategy.getNFT) {
+      throw new Error("getNFT is not supported for this chain");
+    }
+    return strategy.getNFT();
+  }
+  async getKycThreshold() {
+    const strategy = await this.getStrategy();
+    if (!strategy.getKycThreshold) {
+      throw new Error("getKycThreshold is not supported for this chain");
+    }
+    return strategy.getKycThreshold();
+  }
+};
+
+// src/SignatureAirdropClient.ts
+var import_tokentable_wallets = require("@sign-global/tokentable-wallets");
+var import_tokentable_core6 = require("@sign-global/tokentable-core");
+var SignatureAirdropClient = class {
+  projectId;
+  endpoint;
+  project;
+  chainRpc;
+  claims;
+  identities;
+  projectPromise;
+  authPromise;
+  strategyCache = /* @__PURE__ */ new Map();
+  constructor(params) {
+    this.projectId = params.projectId;
+    this.endpoint = params.endpoint;
+    this.chainRpc = params.chainRpc;
+    if (this.project) {
+      this.project = params.project;
+    } else {
+      this.projectPromise = this.initializeProjects();
+    }
+    if ((0, import_tokentable_core6.isMobile)()) {
+      this.authPromise = this.checkAndHandleTwitterCode();
+    }
+  }
+  LOCAL_STORAGE_SID_PREFIX = "sid_";
+  async checkAndHandleTwitterCode() {
+    try {
+      const urlParams = new URLSearchParams(window.location.search);
+      const code = urlParams.get("code");
+      const type = urlParams.get("type");
+      if (code && this.projectId) {
+        let res;
+        if (type === "twitter") {
+          res = await (0, import_tokentable_core6.connectTwitter)({ code, projectId: this.projectId }, this.endpoint);
+        } else if (type === "google") {
+          res = await (0, import_tokentable_core6.connectGoogleApi)({ code, projectId: this.projectId }, this.endpoint);
+        }
+        if (res?.sid) {
+          this.setSid(this.projectId, res.sid);
+        } else {
+          throw new Error("Failed to connect");
+        }
+        (0, import_tokentable_core6.cleanUrlParams)(["code", "type"]);
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  setSid(projectId, sid) {
+    window.localStorage.setItem(`${this.LOCAL_STORAGE_SID_PREFIX}${projectId}`, sid);
+  }
+  async fetchProjectDetails(projectId) {
+    const project = await (0, import_tokentable_core6.getAirdropProject)(projectId, this.endpoint);
+    this.project = project;
+    if (this.chainRpc) return;
+    const chainId = project.chainType === import_tokentable_core6.ChainType.Evm ? Number(project.chainId) : project.chainId;
+    this.chainRpc = (0, import_tokentable_core6.getChainRpc)(chainId);
+  }
+  async initializeProjects() {
+    try {
+      let projectId = this.projectId;
+      if (!projectId) {
+        return;
+      }
+      await this.fetchProjectDetails(projectId);
+    } catch (error) {
+      throw new Error(`Failed to initialize project: ${error.message}`);
+    }
+  }
+  async getProjectInfo() {
+    if (this.projectPromise) {
+      await this.projectPromise;
+    }
+    if (!this.project) throw new Error("Project not found");
+    return this.project;
+  }
+  async connectOAuth({
+    onSuccess,
+    onError,
+    type
+  }) {
+    const project = await this.getProjectInfo();
+    const authorizeUrl = project.identities.find((item) => item.identityType === type)?.authorizeUrl;
+    if (!authorizeUrl) {
+      onError(new Error("Authorize URL not found"));
+      return;
+    }
+    if ((0, import_tokentable_core6.isMobile)()) {
+      const state = encodeURIComponent(window.location.href);
+      window.location.href = `${authorizeUrl}&state=${state}`;
+      return;
+    }
+    const onWindowMessage = async (message) => {
+      const name = message.data?.name;
+      if (name && [import_tokentable_core6.CONST.TWITTER_AUTH_SUCCESS, import_tokentable_core6.CONST.GOOGLE_AUTH_SUCCESS].includes(name)) {
+        const { code } = message.data.data || {};
+        try {
+          let res;
+          if (name === import_tokentable_core6.CONST.GOOGLE_AUTH_SUCCESS) {
+            res = await (0, import_tokentable_core6.connectGoogleApi)({ code, projectId: project.id }, this.endpoint);
+          } else if (name === import_tokentable_core6.CONST.TWITTER_AUTH_SUCCESS) {
+            res = await (0, import_tokentable_core6.connectTwitter)({ code, projectId: project.id }, this.endpoint);
+          }
+          if (res?.sid) {
+            this.setSid(project.id, res?.sid);
+            onSuccess();
+          } else {
+            onError(new Error("Failed to connect"));
+          }
+        } catch (error) {
+          onError(error);
+        } finally {
+          window.removeEventListener("message", onWindowMessage);
+        }
+      }
+    };
+    window.addEventListener("message", onWindowMessage);
+    window.open(`${authorizeUrl}&state=state`, `twitter_auth_${project.id}`, "width=600,height=800");
+  }
+  async connectX({ onSuccess, onError }) {
+    await this.connectOAuth({
+      onSuccess,
+      onError,
+      type: import_tokentable_core6.AirdropSigIdentityTypeEnum.Twitter
+    });
+  }
+  async connectGoogle({ onSuccess, onError }) {
+    await this.connectOAuth({
+      onSuccess,
+      onError,
+      type: import_tokentable_core6.AirdropSigIdentityTypeEnum.Google
+    });
+  }
+  async connectWallet({
+    chainType,
+    onSuccess,
+    onError
+  }) {
+    try {
+      const project = await this.getProjectInfo();
+      const wallet = import_tokentable_wallets.WalletFactory.getWallet(chainType);
+      const timestamp = Date.now();
+      const recipientTypeMap = {
+        [import_tokentable_core6.ChainType.Evm]: import_tokentable_core6.AirdropSigIdentityTypeEnum.EVMWallet,
+        [import_tokentable_core6.ChainType.Solana]: import_tokentable_core6.AirdropSigIdentityTypeEnum.SolanaWallet,
+        [import_tokentable_core6.ChainType.Ton]: import_tokentable_core6.AirdropSigIdentityTypeEnum.TONWallet
+      };
+      const msg = [project.id, recipientTypeMap[chainType], timestamp].join(",");
+      const signResult = await wallet.signin(msg, false);
+      await wallet.disconnect();
+      const { message, signature } = signResult || {};
+      if (this.identities?.find((it) => it.value?.toLowerCase() === wallet.address?.toLowerCase())) {
+        onError?.(import_tokentable_core6.ErrorCode.WALLET_ALREADY_CONNECTED);
+        return;
+      }
+      const payload = {
+        signature,
+        message,
+        key: wallet.publicKey || wallet.address,
+        address: wallet.address,
+        projectId: project.id,
+        timestamp,
+        recipientType: recipientTypeMap[chainType]
+      };
+      const res = await (0, import_tokentable_core6.bindWallet)(payload, this.endpoint);
+      if (res?.sid) {
+        this.setSid(project.id, res?.sid);
+      }
+      onSuccess?.(wallet.address);
+    } catch (error) {
+      onError?.(error);
+    }
+  }
+  async getClaims() {
+    const project = await this.getProjectInfo();
+    if (this.authPromise) {
+      await this.authPromise;
+    }
+    const res = await (0, import_tokentable_core6.checkEligibility)(
+      {
+        projectId: project.id
+      },
+      this.endpoint
+    );
+    this.claims = res.claims;
+    this.identities = res.identities;
+    return res;
+  }
+  async disconnectIdentity({
+    recipientType,
+    recipient
+  }) {
+    const project = await this.getProjectInfo();
+    return await (0, import_tokentable_core6.disconnectRecipient)(
+      {
+        projectId: project.id,
+        recipientType,
+        recipient
+      },
+      this.endpoint
+    );
+  }
+  async getStrategy(walletClient) {
+    const project = await this.getProjectInfo();
+    const cacheKey = walletClient ? project.chainType === import_tokentable_core6.ChainType.Evm ? walletClient.account?.address : project.chainType === import_tokentable_core6.ChainType.Solana ? walletClient.publicKey.toString() : "walletClient" : "default";
+    if (this.strategyCache.has(cacheKey)) {
+      return this.strategyCache.get(cacheKey);
+    }
+    const strategy = project.chainType === import_tokentable_core6.ChainType.Solana ? new import_tokentable_core6.SolanaSignatureAirdropService({
+      chainId: project.chainId,
+      projectId: project.id,
+      token: project.tokenAddress,
+      walletClient,
+      chainRpc: this.chainRpc
+    }) : new import_tokentable_core6.EvmSignatureAirdropService({
+      chainId: Number(project.chainId),
+      contractAddress: project.contractAddress,
+      walletClient,
+      chainRpc: this.chainRpc
+    });
+    this.strategyCache.set(cacheKey, strategy);
+    return strategy;
+  }
+  async getVersion() {
+    const strategy = await this.getStrategy();
+    return strategy.getVersion();
+  }
+  // solana prams need to wallet
+  async getClaimFee(amount, walletClient) {
+    const strategy = await this.getStrategy(walletClient);
+    if (!strategy.getClaimFee) {
+      throw new Error("getClaimFee is not supported for this chain");
+    }
+    return await strategy.getClaimFee(this.project?.contractAddress || "", amount || BigInt(1));
+  }
+  async claimAirdrop({
+    claimIds,
+    walletClient,
+    recipient
+  }) {
+    if (!claimIds.length) {
+      throw new Error("Claim IDs cannot be empty");
+    }
+    if (!walletClient) {
+      throw new Error("Wallet client is required");
+    }
+    if (!this.claims?.length) {
+      throw new Error("No claims available");
+    }
+    const service = await this.getStrategy(walletClient);
+    const project = await this.getProjectInfo();
+    const res = await (0, import_tokentable_core6.checkGetSignatures)(
+      {
+        claimIds,
+        projectId: this.projectId,
+        recipient
+      },
+      this.endpoint
+    );
+    if (!res?.signatures?.length) {
+      throw new Error("Failed to get signatures");
+    }
+    const signatureMap = res?.signatures?.reduce(
+      (map, item) => {
+        map[item.claimId] = item;
+        return map;
+      },
+      {}
+    );
+    const filteredClaims = this.claims.filter((it) => claimIds.includes(it.claimId));
+    if (!filteredClaims.length) {
+      throw new Error("No matching claims found");
+    }
+    const defaultRecipient = project.chainType === import_tokentable_core6.ChainType.Evm ? walletClient.account?.address : "";
+    const claimData = filteredClaims.map((it) => {
+      const signature = signatureMap[it.claimId];
+      if (!signature) {
+        throw new Error(`Signature not found for claim ID: ${it.claimId}`);
+      }
+      return {
+        ...it,
+        recipient: recipient ? recipient : defaultRecipient,
+        ...signature
+      };
+    });
+    const hash = await service.claim(claimData, recipient);
+    return hash;
+  }
+  async batchCheckClaimed() {
+    if (!this.claims?.length) return [];
+    const strategy = await this.getStrategy();
+    if (!strategy.batchFetchClaimed) {
+      throw new Error("batchCheckClaimed is not supported for this chain");
+    }
+    const claimIds = this.claims?.map((it) => it.claimId);
+    return strategy.batchFetchClaimed(claimIds);
+  }
+  async getPaused() {
+    const strategy = await this.getStrategy();
+    if (!strategy.getPaused) {
+      throw new Error("getPaused is not supported for this chain");
+    }
+    return strategy.getPaused();
+  }
+};
+
+// src/index.ts
+__reExport(index_exports, require("@sign-global/tokentable-core"), module.exports);
+__reExport(index_exports, require("@sign-global/tokentable-wallets"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AirdropClient,
+  SignatureAirdropClient,
+  ...require("@sign-global/tokentable-core"),
+  ...require("@sign-global/tokentable-wallets")
+});
+//# sourceMappingURL=index.js.map