@sign-global/tokentable 0.0.1

package/dist/esm/airdrop/types/index.d.ts

@@ -0,0 +1,105 @@
+import { TonConnectUI } from '@tonconnect/ui-react';
+import { AirdropService as TonAirdropService } from '../core/ton/AirdropService';
+import { AirdropService as EvmAirdropService } from '../core/evm/AirdropService';
+import { TonClient } from '@ton/ton';
+import { ChainConfig } from '../constants';
+import { WalletClient as ViemWalletClient } from 'viem';
+export type ChainId = keyof typeof ChainConfig;
+export interface EvmContractClientOption {
+    chainId: ChainId;
+    walletClient?: ViemWalletClient;
+    contractAddress: string;
+    abi?: any;
+}
+export declare enum ChainType {
+    Evm = "evm",
+    Ton = "ton"
+}
+export interface IProject {
+    id: string;
+    name: string;
+    chainId: string;
+    chainType: ChainType;
+    tokenAddress: string;
+    tokenType: string;
+    startTime: number;
+    endTime: number;
+    contractAddress: string;
+    recipientType: string;
+    merkleRoot: string;
+    ownerAddress: string;
+    blockCountries: Record<string, string>;
+    themeConf: Record<string, any>;
+    version: string;
+    extra?: {
+        kyc: boolean;
+        tag: string;
+    };
+}
+export type IAirdropClaim = {
+    index: number;
+    recipient: string;
+    proof: string[];
+    amount: string;
+    unlockingAt: number;
+    group: string;
+    data: string;
+    leaf: string;
+    claimed?: boolean;
+    claimId?: string;
+    claimable?: boolean;
+    proofHash: string;
+    ownerAddress: string;
+    proofBoc: string;
+    expiryTimestamp: number;
+    expired?: boolean;
+    project: IProject;
+};
+export interface IAirdropData {
+    claims: IAirdropClaim[];
+}
+export declare enum TonAirdropVersionEnum {
+    V1 = "1.0.0",
+    V2 = "2.0.0",
+    LiteV1 = "11.0.0"
+}
+export declare enum EvmAirdropVersionEnum {
+    V0 = "0.0.2",// 兼容btc减半 airdrop
+    V3 = "0.3.0",// zeta 收费
+    V4 = "0.4.0"
+}
+export type IWalletClient = TonConnectUI | ViemWalletClient;
+export type IAirdropService = TonAirdropService | EvmAirdropService;
+export type BaseAirdropOptions = {
+    endpoint?: string;
+    projectId?: string;
+};
+type BaseTonConfig = {
+    endpoint?: string;
+    tonClient?: TonClient;
+};
+type TonProjectIdConfig = BaseTonConfig & {
+    projectId: string;
+    slug?: never;
+};
+type TonSlugConfig = BaseTonConfig & {
+    slug: string;
+    projectId?: never;
+};
+export type TonAirdropOptions = TonProjectIdConfig | TonSlugConfig;
+export interface EvmAirdropOptions extends BaseAirdropOptions {
+    projectId: string;
+}
+export interface TonContractWrapperOptions {
+    chainId: ChainId;
+    contractAddress: string;
+    walletClient?: TonConnectUI;
+    tonClient?: TonClient;
+}
+export interface EvmContractWrapperOptions {
+    chainId: ChainId;
+    contractAddress: string;
+    walletClient?: ViemWalletClient;
+}
+export type ContractWrapperOptions = TonContractWrapperOptions | EvmContractWrapperOptions;
+export {};

package/dist/esm/airdrop/types/index.js

@@ -0,0 +1,18 @@
+export var ChainType;
+(function (ChainType) {
+    ChainType["Evm"] = "evm";
+    ChainType["Ton"] = "ton";
+})(ChainType || (ChainType = {}));
+export var TonAirdropVersionEnum;
+(function (TonAirdropVersionEnum) {
+    TonAirdropVersionEnum["V1"] = "1.0.0";
+    TonAirdropVersionEnum["V2"] = "2.0.0";
+    TonAirdropVersionEnum["LiteV1"] = "11.0.0";
+})(TonAirdropVersionEnum || (TonAirdropVersionEnum = {}));
+export var EvmAirdropVersionEnum;
+(function (EvmAirdropVersionEnum) {
+    EvmAirdropVersionEnum["V0"] = "0.0.2";
+    EvmAirdropVersionEnum["V3"] = "0.3.0";
+    EvmAirdropVersionEnum["V4"] = "0.4.0"; // zeta kyc、kyc threshold
+})(EvmAirdropVersionEnum || (EvmAirdropVersionEnum = {}));
+//# sourceMappingURL=index.js.map

package/dist/esm/airdrop/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/airdrop/types/index.ts"],"names":[],"mappings":"AAgBA,MAAM,CAAN,IAAY,SAGX;AAHD,WAAY,SAAS;IACnB,wBAAW,CAAA;IACX,wBAAW,CAAA;AACb,CAAC,EAHW,SAAS,KAAT,SAAS,QAGpB;AAmDD,MAAM,CAAN,IAAY,qBAIX;AAJD,WAAY,qBAAqB;IAC/B,qCAAY,CAAA;IACZ,qCAAY,CAAA;IACZ,0CAAiB,CAAA;AACnB,CAAC,EAJW,qBAAqB,KAArB,qBAAqB,QAIhC;AAED,MAAM,CAAN,IAAY,qBAIX;AAJD,WAAY,qBAAqB;IAC/B,qCAAY,CAAA;IACZ,qCAAY,CAAA;IACZ,qCAAY,CAAA,CAAC,yBAAyB;AACxC,CAAC,EAJW,qBAAqB,KAArB,qBAAqB,QAIhC"}

package/dist/esm/index.d.ts

@@ -0,0 +1 @@
+export { EvmAirdropClient, TonAirdropClient } from './airdrop';

package/dist/esm/index.js

@@ -0,0 +1,2 @@
+export { EvmAirdropClient, TonAirdropClient } from './airdrop';
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC"}

package/dist/esm/utils/api-client.d.ts

@@ -0,0 +1,18 @@
+export type ApiClientOptions = {
+    baseURL?: string;
+};
+export type ApiRequestOptions = {
+    params?: Record<string, string | number>;
+    skipHandleError?: boolean;
+};
+export declare class ApiClient {
+    private options?;
+    constructor(options?: ApiClientOptions | undefined);
+    extend(options: ApiClientOptions): ApiClient;
+    get<TRes>(url: string, options?: ApiRequestOptions): Promise<TRes>;
+    post<TRes, TReq = unknown>(url: string, data?: TReq, options?: ApiRequestOptions): Promise<TRes>;
+    put<TRes, TReq = unknown>(url: string, data?: TReq, options?: ApiRequestOptions): Promise<TRes>;
+    delete<TRes>(url: string, options?: ApiRequestOptions): Promise<TRes>;
+    private request;
+}
+export declare const apiClient: ApiClient;

package/dist/esm/utils/api-client.js

@@ -0,0 +1,43 @@
+export class ApiClient {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    extend(options) {
+        return new ApiClient({
+            ...this.options,
+            ...options
+        });
+    }
+    async get(url, options) {
+        return this.request('GET', url, null, options);
+    }
+    async post(url, data, options) {
+        return this.request('POST', url, data, options);
+    }
+    async put(url, data, options) {
+        return this.request('PUT', url, data, options);
+    }
+    async delete(url, options) {
+        return this.request('DELETE', url, null, options);
+    }
+    async request(method, url, data, options) {
+        const finalUrl = (this.options?.baseURL || '') + url;
+        const init = { method };
+        if (data instanceof FormData) {
+            init.body = data;
+        }
+        else {
+            init.headers = { 'content-type': 'application/json' };
+            init.body = data ? JSON.stringify(data) : void 0;
+        }
+        const res = await fetch(finalUrl, init);
+        const [status, resData] = await Promise.all([res.status, res.json()]);
+        if ((status < 200 && status >= 300) || resData?.success !== true) {
+            return Promise.reject(resData);
+        }
+        return resData.data;
+    }
+}
+export const apiClient = new ApiClient({ baseURL: 'https://claim.tokentable.xyz/api' });
+//# sourceMappingURL=api-client.js.map

package/dist/esm/utils/api-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-client.js","sourceRoot":"","sources":["../../../src/utils/api-client.ts"],"names":[],"mappings":"AAgBA,MAAM,OAAO,SAAS;IACA;IAApB,YAAoB,OAA0B;QAA1B,YAAO,GAAP,OAAO,CAAmB;IAAG,CAAC;IAElD,MAAM,CAAC,OAAyB;QAC9B,OAAO,IAAI,SAAS,CAAC;YACnB,GAAG,IAAI,CAAC,OAAO;YACf,GAAG,OAAO;SACX,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,GAAG,CAAO,GAAW,EAAE,OAA2B;QACtD,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,CAAS,CAAC;IACzD,CAAC;IAED,KAAK,CAAC,IAAI,CAAuB,GAAW,EAAE,IAAW,EAAE,OAA2B;QACpF,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,CAAS,CAAC;IAC1D,CAAC;IAED,KAAK,CAAC,GAAG,CAAuB,GAAW,EAAE,IAAW,EAAE,OAA2B;QACnF,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,CAAS,CAAC;IACzD,CAAC;IAED,KAAK,CAAC,MAAM,CAAO,GAAW,EAAE,OAA2B;QACzD,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,CAAS,CAAC;IAC5D,CAAC;IAEO,KAAK,CAAC,OAAO,CACnB,MAAyC,EACzC,GAAW,EACX,IAAa,EACb,OAA2B;QAE3B,MAAM,QAAQ,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,IAAI,EAAE,CAAC,GAAG,GAAG,CAAC;QAErD,MAAM,IAAI,GAAgB,EAAE,MAAM,EAAE,CAAC;QACrC,IAAI,IAAI,YAAY,QAAQ,EAAE,CAAC;YAC7B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACnB,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,OAAO,GAAG,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC;YACtD,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QACnD,CAAC;QAED,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QACxC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAA0B,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAS,CAAC,CAAC,CAAC;QACpG,IAAI,CAAC,MAAM,GAAG,GAAG,IAAI,MAAM,IAAI,GAAG,CAAC,IAAI,OAAO,EAAE,OAAO,KAAK,IAAI,EAAE,CAAC;YACjE,OAAO,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACjC,CAAC;QACD,OAAO,OAAO,CAAC,IAAI,CAAC;IACtB,CAAC;CACF;AAED,MAAM,CAAC,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,EAAE,OAAO,EAAE,kCAAkC,EAAE,CAAC,CAAC"}

package/dist/esm/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './web3';
+export * from './utils';
+export * from './api-client';

package/dist/esm/utils/index.js

@@ -0,0 +1,4 @@
+export * from './web3';
+export * from './utils';
+export * from './api-client';
+//# sourceMappingURL=index.js.map

package/dist/esm/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC"}

package/dist/esm/utils/utils.d.ts

@@ -0,0 +1,7 @@
+export declare const safeParseJSON: (str: string) => any;
+export declare const isBeforeByUnix: (unix: number) => boolean;
+export declare const delay: (ms: number) => Promise<unknown>;
+export declare function retry<T>(fn: () => Promise<T>, options: {
+    retries: number;
+    delay: number;
+}): Promise<T>;

package/dist/esm/utils/utils.js

@@ -0,0 +1,29 @@
+import dayjs from 'dayjs';
+export const safeParseJSON = (str) => {
+    try {
+        return JSON.parse(str);
+    }
+    catch (error) {
+        return {};
+    }
+};
+export const isBeforeByUnix = (unix) => {
+    return dayjs(new Date()).isBefore(dayjs.unix(unix), 'millisecond');
+};
+export const delay = (ms) => new Promise((res) => setTimeout(res, ms));
+export async function retry(fn, options) {
+    let lastError;
+    for (let i = 0; i < options.retries; i++) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                lastError = e;
+            }
+            await new Promise((resolve) => setTimeout(resolve, options.delay));
+        }
+    }
+    throw lastError;
+}
+//# sourceMappingURL=utils.js.map

package/dist/esm/utils/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/utils/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,GAAW,EAAO,EAAE;IAChD,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,EAAE,CAAC;IACZ,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,IAAY,EAAE,EAAE;IAC7C,OAAO,KAAK,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,CAAC;AACrE,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,EAAU,EAAoB,EAAE,CAAC,IAAI,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;AAEjG,MAAM,CAAC,KAAK,UAAU,KAAK,CAAI,EAAoB,EAAE,OAA2C;IAC9F,IAAI,SAA4B,CAAC;IACjC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,EAAE,EAAE,CAAC;QACzC,IAAI,CAAC;YACH,OAAO,MAAM,EAAE,EAAE,CAAC;QACpB,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,IAAI,CAAC,YAAY,KAAK,EAAE,CAAC;gBACvB,SAAS,GAAG,CAAC,CAAC;YAChB,CAAC;YACD,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;QACrE,CAAC;IACH,CAAC;IACD,MAAM,SAAS,CAAC;AAClB,CAAC"}

package/dist/esm/utils/web3.d.ts

@@ -0,0 +1 @@
+export declare function flipAddressType(address: string): string;

package/dist/esm/utils/web3.js

@@ -0,0 +1,9 @@
+import TonWeb from 'tonweb';
+export function flipAddressType(address) {
+    if (!address)
+        return '';
+    return address.includes(':')
+        ? new TonWeb.utils.Address(address).toString(true, true, true)
+        : new TonWeb.utils.Address(address).toString(false, false, true);
+}
+//# sourceMappingURL=web3.js.map

package/dist/esm/utils/web3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"web3.js","sourceRoot":"","sources":["../../../src/utils/web3.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAE5B,MAAM,UAAU,eAAe,CAAC,OAAe;IAC7C,IAAI,CAAC,OAAO;QAAE,OAAO,EAAE,CAAC;IACxB,OAAO,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC;QAC1B,CAAC,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;QAC9D,CAAC,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;AACrE,CAAC"}

package/index.ts

@@ -0,0 +1,34 @@
+import { TonWalletService } from './src/airdrop/services/wallet-service/ton/WalletService';
+import { AirdropClient } from './src/airdrop';
+import { ChainType } from './src/airdrop/types';
+import { CHAIN } from '@tonconnect/ui-react';
+
+console.log('Hello via Bun!');
+
+const airdropClient = new AirdropClient({
+  //   baseURL: 'http://ec2-3-89-178-45.compute-1.amazonaws.com:3030/api',
+  projectId: 'AD_pxPH2LcgWXgz',
+  chainType: ChainType.Ton
+});
+
+const claims = await airdropClient.fetchAirdropClaims({
+  address: 'UQB3bCGYQxF7-7u728yKQgMepCftbw4pirZoh0vjzHdELAHA'
+});
+
+console.log(claims);
+
+const projects = airdropClient.getProjectList();
+
+console.log(projects);
+
+// const isClaimed = await airdropClient.checkClaimed('AD_6oYIAQzOCWaK-75');
+
+// console.log(isClaimed);
+
+const balance = await TonWalletService.fetchBalance({
+  chainId: CHAIN.TESTNET,
+  address: '0QANAsrLyyHoq8N4EZ-QfADXhtoSUybdSKXOknMLWLbA7gDx',
+  token: 'kQDg-lZ_gEZUb1MCjOpgemMSnLRZMVIUVMJxpoev7rmv1UKy'
+});
+
+console.log(balance);

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@sign-global/tokentable",
+  "version": "0.0.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "tokentable sdk",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "type": "module",
+  "scripts": {
+    "build-cjs": "tsc -m commonjs --outDir dist/cjs",
+    "build-esm": "tsc -m esnext --outDir dist/esm",
+    "build": "pnpm run build-cjs && pnpm run build-esm"
+  },
+  "author": "Evan",
+  "license": "ISC",
+  "dependencies": {
+    "@orbs-network/ton-access": "^2.3.3",
+    "@ton/core": "^0.59.0",
+    "@ton/ton": "^15.1.0",
+    "@tonconnect/ui-react": "^2.0.9",
+    "bignumber.js": "^9.1.2",
+    "dayjs": "^1.11.13",
+    "tonapi-sdk-js": "^2.0.3",
+    "tonweb": "^0.0.66",
+    "viem": "^2.21.49",
+    "wagmi": "^2.13.0"
+  },
+  "devDependencies": {
+    "bun-types": "latest",
+    "typescript": "^5.6.3"
+  }
+}

package/src/airdrop/BaseAirdropClient.ts

@@ -0,0 +1,75 @@
+import { getAirdropProject, getAirdropProjectId, getAirdropQuery } from './services';
+import {
+  BaseAirdropOptions,
+  ChainType,
+  ContractWrapperOptions,
+  IAirdropClaim,
+  IAirdropService,
+  IProject,
+  IWalletClient
+} from './types';
+
+export abstract class BaseAirdropClient {
+  protected endpoint?: string;
+  protected projectId?: string;
+  protected claims?: IAirdropClaim[];
+  protected projects?: IProject[];
+
+  constructor(params: BaseAirdropOptions) {
+    this.endpoint = params.endpoint;
+    this.projectId = params.projectId;
+  }
+
+  abstract getAirdropContractWrapper(options: ContractWrapperOptions): IAirdropService | undefined;
+
+  async fetchAirdropProjectIds(data: { recipient: string; slug: string }) {
+    const res = await getAirdropProjectId(data, this.endpoint);
+    return res;
+  }
+
+  protected async initializeProjects(address: string) {
+    const projectIds: string[] = this.projectId ? [this.projectId] : [];
+    this.projects = await Promise.all(projectIds.map(async (projectId) => getAirdropProject(projectId, this.endpoint)));
+  }
+
+  async fetchAirdropClaims(data: { address: string }) {
+    if (!this.projects) {
+      await this.initializeProjects(data.address);
+    }
+
+    if (!this.projects?.length) {
+      return [];
+    }
+
+    const claimsRes = await Promise.all(
+      this.projects.map(async (project) => {
+        const res = await getAirdropQuery(
+          {
+            recipient: data.address,
+            projectId: project.id,
+            recipientType: project.recipientType
+          },
+          this.endpoint
+        );
+        return res.claims?.map((it) => ({
+          ...it,
+          project: project,
+          claimId: project.chainType === ChainType.Evm ? `${project.id}:${it.leaf}` : `${project.id}:${it.index}`
+        }));
+      })
+    );
+    this.claims = claimsRes.flat();
+    return this.claims;
+  }
+
+  getProjectList() {
+    return this.projects;
+  }
+
+  abstract claimAirdrop(
+    params: { claimId: string; walletClient: IWalletClient },
+    options: { onLoading?: () => void }
+  ): Promise<unknown>;
+
+  abstract checkClaimed(claimId: string): Promise<boolean>;
+}

package/src/airdrop/EvmAirdropClient.ts

@@ -0,0 +1,74 @@
+import { BaseAirdropClient } from './BaseAirdropClient';
+import { ChainId, EvmContractWrapperOptions } from './types';
+import { AirdropService as EvmAirdropService } from './core/evm/AirdropService';
+import { WalletClient as ViemWalletClient } from 'viem';
+
+export class EvmAirdropClient extends BaseAirdropClient {
+  private contractInstances = new Map<string, EvmAirdropService>();
+  getAirdropContractWrapper(options: EvmContractWrapperOptions): EvmAirdropService {
+    const instanceKey = `${options.chainId}:${options.contractAddress}`;
+    if (!this.contractInstances.has(instanceKey)) {
+      const instance = new EvmAirdropService({
+        contractAddress: options.contractAddress,
+        chainId: Number(options.chainId) as ChainId,
+        walletClient: options.walletClient as ViemWalletClient
+      });
+      this.contractInstances.set(instanceKey, instance);
+    }
+
+    return this.contractInstances.get(instanceKey)!;
+  }
+
+  private getClaimDataById(claimId: string) {
+    const claimData = this.claims?.find((it) => it.claimId === claimId);
+    if (!claimData) throw new Error('Claim data not found');
+    return claimData;
+  }
+
+  async claimAirdrop({ claimId, walletClient }: { claimId: string; walletClient: ViemWalletClient }) {
+    const claimData = this.getClaimDataById(claimId);
+
+    const contractWrapper = this.getAirdropContractWrapper({
+      chainId: claimData.project.chainId as ChainId,
+      contractAddress: claimData.project.contractAddress,
+      walletClient
+    });
+
+    return contractWrapper.claim(claimData);
+  }
+
+  async checkClaimed(claimId: string): Promise<boolean> {
+    const claimData = this.getClaimDataById(claimId);
+
+    const contractWrapper = this.getAirdropContractWrapper({
+      chainId: Number(claimData.project.chainId) as ChainId,
+      contractAddress: claimData.project.contractAddress
+    });
+
+    return contractWrapper.isLeafUsed(claimData.leaf);
+  }
+
+  async batchFetchClaimed(leafs: string[]) {
+    const claimData = this.claims?.[0];
+    if (!claimData) throw new Error('Claim data not found');
+
+    const contractWrapper = this.getAirdropContractWrapper({
+      chainId: Number(claimData.project.chainId) as ChainId,
+      contractAddress: claimData.project.contractAddress
+    });
+
+    return contractWrapper.batchFetchClaimed(leafs);
+  }
+
+  async getClaimFee(amount: bigint) {
+    const claimData = this.claims?.[0];
+    if (!claimData) throw new Error('Claim data not found');
+
+    const contractWrapper = this.getAirdropContractWrapper({
+      chainId: Number(claimData.project.chainId) as ChainId,
+      contractAddress: claimData.project.contractAddress
+    });
+
+    return contractWrapper.getClaimFee(claimData.project.contractAddress, amount);
+  }
+}

package/src/airdrop/TonAirdropClient.ts

@@ -0,0 +1,93 @@
+import { TonClient } from '@ton/ton';
+import { BaseAirdropClient } from './BaseAirdropClient';
+import { TonConnectUI } from '@tonconnect/ui-react';
+import { AirdropService as TonAirdropService } from './core/ton/AirdropService';
+import { getAirdropPro, getAirdropProject } from './services';
+import { ChainId, TonAirdropOptions, TonContractWrapperOptions } from './types';
+import { getTonProjectIdByAddress } from './common';
+
+export class TonAirdropClient extends BaseAirdropClient {
+  private tonClient?: TonClient;
+  private slug?: string;
+  private contractInstances = new Map<string, TonAirdropService>();
+
+  constructor(params: TonAirdropOptions) {
+    super(params);
+    if ('slug' in params) {
+      this.slug = params.slug;
+    }
+    this.tonClient = params.tonClient;
+  }
+
+  protected async initializeProjects(address: string) {
+    let projectIds: string[] = this.projectId ? [this.projectId] : [];
+    if (this.slug) {
+      const res = await getAirdropPro(this.slug, this.endpoint);
+      const projectMap = res?.childProjectMapping;
+      const legacyProjectId = getTonProjectIdByAddress({ address, slug: this.slug, data: projectMap });
+
+      if (legacyProjectId) {
+        projectIds = [...projectIds, legacyProjectId];
+      }
+    }
+    this.projects = await Promise.all(projectIds.map(async (projectId) => getAirdropProject(projectId, this.endpoint)));
+  }
+
+  getAirdropContractWrapper(options: TonContractWrapperOptions): TonAirdropService {
+    const instanceKey = `${options.chainId}:${options.contractAddress}`;
+
+    if (!this.contractInstances.has(instanceKey)) {
+      const instance = new TonAirdropService({
+        chainId: options.chainId.toString(),
+        address: options.contractAddress,
+        walletClient: options.walletClient as TonConnectUI,
+        tonClient: this.tonClient
+      });
+      this.contractInstances.set(instanceKey, instance);
+    }
+
+    return this.contractInstances.get(instanceKey)!;
+  }
+
+  private getClaimDataById(claimId: string) {
+    const claimData = this.claims?.find((it) => it.claimId === claimId);
+    if (!claimData) throw new Error('Claim data not found');
+    return claimData;
+  }
+
+  async claimAirdrop(
+    { claimId, walletClient }: { claimId: string; walletClient: TonConnectUI },
+    options: { onLoading?: () => void }
+  ) {
+    const claimData = this.getClaimDataById(claimId);
+
+    const contractWrapper = this.getAirdropContractWrapper({
+      chainId: claimData.project.chainId as ChainId,
+      contractAddress: claimData.project.contractAddress,
+      walletClient
+    });
+
+    return contractWrapper.claim(claimData, options);
+  }
+
+  async checkClaimed(claimId: string): Promise<boolean> {
+    const claimData = this.getClaimDataById(claimId);
+
+    const contractWrapper = this.getAirdropContractWrapper({
+      chainId: claimData.project.chainId as ChainId,
+      contractAddress: claimData.project.contractAddress,
+      tonClient: this.tonClient
+    });
+
+    return contractWrapper.checkClaimed(claimData);
+  }
+
+  async getPaused({ contractAddress, chainId }: { contractAddress: string; chainId: string }) {
+    const contractWrapper = this.getAirdropContractWrapper({
+      chainId: chainId as ChainId,
+      contractAddress,
+      tonClient: this.tonClient
+    });
+    return contractWrapper.getPaused();
+  }
+}

package/src/airdrop/common/index.ts

@@ -0,0 +1,49 @@
+import { ChainConfig, SupportedChains } from '../constants';
+import { ChainId } from '../types';
+import { projectDataForTon } from './projectDataForTon';
+
+export function getChainById(chainId: ChainId) {
+  const chain = SupportedChains.find((chain) => chain.id === chainId);
+
+  if (!chain) {
+    throw new Error(`ChainId ${chainId} not supported.`);
+  }
+
+  return chain;
+}
+
+export function getChainConfig(chainId: ChainId) {
+  return ChainConfig[chainId];
+}
+
+export function getChainRpc(chainId: ChainId): string {
+  const config = getChainConfig(chainId as any);
+
+  if (!config) {
+    throw new Error(`ChainId ${chainId} not supported.`);
+  }
+
+  return config?.rpcUrl;
+}
+
+export const getTonProjectIdByAddress = ({
+  address,
+  slug,
+  data
+}: {
+  address: string;
+  slug: string;
+  data: Record<string, string>;
+}): string | undefined => {
+  let project: Record<string, string> = projectDataForTon[slug as keyof typeof projectDataForTon];
+  if (!project) {
+    project = data;
+  }
+  const lastText = address[address.length - 1];
+
+  const group = Object.keys(project || {}).find((key) => key.includes(lastText));
+
+  const projectId = group ? project[group as keyof typeof project] : undefined;
+
+  return projectId;
+};