@sign-global/tokentable 0.0.1

package/src/airdrop/core/ton/AirdropClientV1.ts

@@ -0,0 +1,122 @@
+import { IAirdropOption, TonContractBaseClient } from './TonContractBaseClient';
+import { Address, Cell } from '@ton/core';
+import { Leaf, leafConfigToCell, MerkleTokenDistributor } from './v1/wrappers';
+import LeafCode from './v1/build/Leaf.compiled.json';
+import { IAirdropClaim } from '../../types';
+import { TonWalletService } from '../../services';
+
+export class TonAirdropClientV1 extends TonContractBaseClient {
+  version = '1.0.0';
+
+  constructor(option: IAirdropOption) {
+    super(option);
+  }
+
+  async getVersion() {
+    const airDropContract = await this.getAirdropContract();
+    const version = await airDropContract.getVersion();
+    this.version = version;
+    return version;
+  }
+
+  getAirdropContract = async () => {
+    const provider = await this.getTonClient();
+    const contract = new MerkleTokenDistributor(Address.parse(this.address));
+    return provider.open(contract);
+  };
+
+  async getBaseParams() {
+    const airDropContract = await this.getAirdropContract();
+    const [startTime, endTime] = await airDropContract!.getTime();
+    const token = await airDropContract?.getToken();
+    const root = await airDropContract?.getRoot();
+    const deployer = await airDropContract.getDeployer();
+
+    const owner = Address.parse(deployer?.toString()).toString({ bounceable: false });
+
+    const version = this.version || (await airDropContract.getVersion());
+    return {
+      startTime: startTime ? String(startTime?.valueOf() / 1000) : '',
+      endTime: endTime ? String(endTime?.valueOf() / 1000) : '',
+      token: token?.toString(),
+      root: root?.toString(),
+      owner: owner,
+      version
+    };
+  }
+
+  async getFeeInfo() {
+    const airDropContract = await this.getAirdropContract();
+    const claimFee = await airDropContract.getClaimFee();
+    const claimFeeReceiver = await airDropContract.getClaimFeeAddress();
+    return {
+      claimFee,
+      claimFeeReceiver
+    };
+  }
+
+  claim = async (claimData: any) => {
+    const provider = await this.getTonClient();
+    const airdropContract = await this.getAirdropContract();
+    const proof = Cell.fromBase64(claimData.proofBoc);
+
+    const index = BigInt(claimData.index);
+    const leafAddress = await airdropContract!.getLeafAddress(index);
+    const leaf = provider.open(Leaf.createFromAddress(leafAddress));
+    const leafCode = Cell.fromBoc(Buffer.from(LeafCode.hex, 'hex'))[0];
+
+    const isDeployed = await provider.isContractDeployed(leafAddress);
+
+    let leafBalanceValue = 1;
+
+    if (isDeployed) {
+      const leafBalance = await TonWalletService.fetchBalance({
+        address: leafAddress.toString(),
+        chainId: this.chainId
+      });
+      leafBalanceValue = Number(leafBalance?.value) || 0;
+    }
+
+    if (!isDeployed || leafBalanceValue <= 0) {
+      const claimFee = await airdropContract!.getClaimFee();
+      leaf.sendLeafFees(
+        this.connection.senderDeploy,
+        claimFee,
+        leafCode,
+        leafConfigToCell({
+          distributor: airdropContract!.address,
+          index
+        })
+      );
+      await this.waitForTransaction();
+      await this.waitForContractDeployment(provider, leafAddress);
+    }
+
+    const queryId = await leaf.getSeqno();
+    await leaf.sendClaim(proof, index, queryId);
+    return null;
+  };
+
+  checkClaimed = async (claimData: IAirdropClaim) => {
+    try {
+      const provider = await this.getTonClient();
+      const airdropContract = await this.getAirdropContract();
+
+      const index = BigInt(claimData.index);
+
+      const leafAddress = await airdropContract.getLeafAddress(index);
+
+      const isDeployed = await provider.isContractDeployed(leafAddress);
+
+      if (!isDeployed) return false;
+
+      const leaf = new Leaf(leafAddress);
+      const leafContract = provider.open(leaf);
+      const isUsed = await leafContract?.getIsUsed();
+
+      return isUsed;
+    } catch (e: any) {
+      return false;
+    }
+  };
+}

package/src/airdrop/core/ton/AirdropClientV2.ts

@@ -0,0 +1,118 @@
+import { TonContractBaseClient, IAirdropOption } from './TonContractBaseClient';
+import { Leaf, MerkleTokenDistributor } from './v2/wrappers';
+import { Address, Cell } from '@ton/core';
+import { IAirdropClaim } from '../../types';
+import LeafCode from './v2/build/Leaf.compiled.json';
+import { isBeforeByUnix } from '../../../utils';
+
+export class TonAirdropClientV2 extends TonContractBaseClient {
+  version = '2.0.0';
+
+  constructor(option: IAirdropOption) {
+    super(option);
+  }
+
+  async getVersion() {
+    const airDropContract = await this.getAirdropContract();
+    const version = await airDropContract.getVersion();
+    this.version = version;
+    return version;
+  }
+
+  getAirdropContract = async () => {
+    const provider = await this.getTonClient();
+    const contract = new MerkleTokenDistributor(Address.parse(this.address));
+    return provider.open(contract);
+  };
+
+  getPaused = async () => {
+    const airDropContract = await this.getAirdropContract();
+    return airDropContract?.getPaused();
+  };
+
+  getFeelessThreshold = async () => {
+    const airDropContract = await this.getAirdropContract();
+    return airDropContract?.getFeelessThreshold();
+  };
+
+  async getBaseParams() {
+    const airDropContract = await this.getAirdropContract();
+    const [startTime, endTime] = await airDropContract!.getTime();
+    const token = await airDropContract?.getToken();
+    const root = await airDropContract?.getRoot();
+    const version = this.version || (await airDropContract.getVersion());
+
+    const paused = await airDropContract?.getPaused();
+
+    return {
+      startTime: startTime ? String(startTime?.valueOf() / 1000) : '',
+      endTime: endTime ? String(endTime?.valueOf() / 1000) : '',
+      token: token?.toString(),
+      root: root?.toString(),
+      version,
+      paused
+    };
+  }
+
+  async getFeeInfo() {
+    const airDropContract = await this.getAirdropContract();
+    const claimFee = await airDropContract.getClaimFee();
+    const claimFeeReceiver = await airDropContract.getClaimFeeAddress();
+    return {
+      claimFee,
+      claimFeeReceiver
+    };
+  }
+
+  claim = async (claimData: IAirdropClaim, options: { onLoading?: () => void }) => {
+    const provider = await this.getTonClient();
+    const airdropContract = await this.getAirdropContract();
+    const index = BigInt(claimData.index);
+    const claimFee = await airdropContract!.getClaimFee();
+    const proof = Cell.fromBase64(claimData.proofBoc);
+
+    const leafCode = Cell.fromBoc(Buffer.from(LeafCode.hex, 'hex'))[0];
+
+    const leaf = provider.open(
+      Leaf.createFromConfig(
+        {
+          distributor: airdropContract.address,
+          index
+        },
+        leafCode
+      )
+    );
+
+    leaf.sendClaim(this.connection.senderDeploy, proof, index, claimFee);
+    const res = await this.waitForTransaction(options.onLoading);
+    if (res) {
+      console.log(res, res.event_id, 'res');
+    }
+    return res;
+  };
+
+  checkClaimed = async (claimData: IAirdropClaim) => {
+    try {
+      if (isBeforeByUnix(claimData.unlockingAt)) return false;
+      const provider = await this.getTonClient();
+      const airdropContract = await this.getAirdropContract();
+
+      const index = BigInt(claimData.index);
+
+      const leafAddress = await airdropContract.getLeafAddress(index);
+
+      const isDeployed = await provider.isContractDeployed(leafAddress);
+
+      if (!isDeployed) return false;
+
+      const leaf = new Leaf(leafAddress);
+      const leafContract = provider.open(leaf);
+      const isUsed = await leafContract?.getIsUsed();
+
+      return isUsed;
+    } catch (e: any) {
+      console.log(e, 'check claim err');
+      return false;
+    }
+  };
+}

package/src/airdrop/core/ton/AirdropClientV3.ts

@@ -0,0 +1,127 @@
+import { TonContractBaseClient, IAirdropOption } from './TonContractBaseClient';
+import { Leaf, MerkleTokenDistributor } from './v3/wrappers';
+import { Address, Cell } from '@ton/core';
+import { IAirdropClaim } from '../../types';
+import LeafCode from './v3/build/Leaf.compiled.json';
+import { isBeforeByUnix } from '../../../utils';
+
+export class TonAirdropClientV3 extends TonContractBaseClient {
+  version = '11.0.0';
+
+  constructor(option: IAirdropOption) {
+    super(option);
+  }
+
+  async getVersion() {
+    const airDropContract = await this.getAirdropContract();
+    const version = await airDropContract.getVersion();
+    this.version = version;
+    return version;
+  }
+
+  getAirdropContract = async () => {
+    const provider = await this.getTonClient();
+    const contract = new MerkleTokenDistributor(Address.parse(this.address));
+    return provider.open(contract);
+  };
+
+  getPaused = async () => {
+    const airDropContract = await this.getAirdropContract();
+    return airDropContract?.getPaused();
+  };
+
+  getFeelessThreshold = async () => {
+    const airDropContract = await this.getAirdropContract();
+    return airDropContract?.getFeelessThreshold();
+  };
+
+  async getBaseParams() {
+    const airDropContract = await this.getAirdropContract();
+    const [startTime, endTime] = await airDropContract!.getTime();
+    const token = await airDropContract?.getToken();
+    const root = await airDropContract?.getRoot();
+
+    const version = this.version || (await airDropContract.getVersion());
+
+    const paused = await airDropContract?.getPaused();
+
+    return {
+      startTime: startTime ? String(startTime?.valueOf() / 1000) : '',
+      endTime: endTime ? String(endTime?.valueOf() / 1000) : '',
+      token: token?.toString(),
+      root: root?.toString(),
+      version,
+      paused
+    };
+  }
+
+  async getFeeInfo() {
+    const airDropContract = await this.getAirdropContract();
+    const claimFee = await airDropContract.getClaimFee();
+    const claimFeeReceiver = await airDropContract.getClaimFeeAddress();
+    return {
+      claimFee,
+      claimFeeReceiver
+    };
+  }
+
+  claim = async (claimData: IAirdropClaim, options: { onLoading?: () => void }) => {
+    // const { provider, airdropContract, claimFee, leafAddress } = prepreData;
+    const provider = await this.getTonClient();
+    const airdropContract = await this.getAirdropContract();
+    const index = BigInt(claimData.index);
+    // const leafAddress = await airdropContract!.getLeafAddress(index);
+    const claimFee = await airdropContract!.getClaimFee();
+    const proof = Cell.fromBase64(claimData.proofBoc);
+
+    const leafCode = Cell.fromBoc(Buffer.from(LeafCode.hex, 'hex'))[0];
+
+    const leaf = provider.open(
+      Leaf.createFromConfig(
+        {
+          distributor: airdropContract.address,
+          index
+        },
+        leafCode
+      )
+    );
+
+    leaf.sendClaim(this.connection.senderDeploy, proof, index, claimFee);
+    const res = await this.waitForTransaction(options.onLoading);
+
+    // while (!(await provider.isContractDeployed(leafAddress))) {
+    //   console.log('waiting for leaf to deploy');
+    //   await new Promise((resolve) => setTimeout(resolve, 1000));
+    // }
+    // // const res = await this.waitForTransactionForLegacy();
+    if (res) {
+      console.log(res, res.event_id, 'res');
+    }
+    return res;
+  };
+
+  checkClaimed = async (claimData: IAirdropClaim) => {
+    try {
+      if (isBeforeByUnix(claimData.unlockingAt)) return false;
+      const provider = await this.getTonClient();
+      const airdropContract = await this.getAirdropContract();
+
+      const index = BigInt(claimData.index);
+
+      const leafAddress = await airdropContract.getLeafAddress(index);
+
+      const isDeployed = await provider.isContractDeployed(leafAddress);
+
+      if (!isDeployed) return false;
+
+      const leaf = new Leaf(leafAddress);
+      const leafContract = provider.open(leaf);
+      const isUsed = await leafContract?.getIsUsed();
+
+      return isUsed;
+    } catch (e: any) {
+      console.log(e.toString(), 'check claim err');
+      return false;
+    }
+  };
+}

package/src/airdrop/core/ton/AirdropService.ts

@@ -0,0 +1,121 @@
+import { TonAirdropClientV1 } from './AirdropClientV1';
+import { TonConnectUI } from '@tonconnect/ui-react';
+import { TonAirdropClientV2 } from './AirdropClientV2';
+import { IAirdropClaim, TonAirdropVersionEnum } from '../../types';
+import { IAirdropOption } from './TonContractBaseClient';
+import { TonAirdropClientV3 } from './AirdropClientV3';
+import { fromNano } from '@ton/core';
+import { TonClient } from '@ton/ton';
+
+export class AirdropService {
+  private address: string;
+
+  private walletClient?: TonConnectUI;
+
+  private chainId: string;
+
+  private cachedVersion: string | null = null;
+
+  private tonClient?: TonClient;
+
+  constructor(options: IAirdropOption) {
+    const { chainId, address, walletClient, tonClient } = options;
+    this.address = address;
+    this.walletClient = walletClient;
+    this.chainId = chainId;
+    this.tonClient = tonClient;
+  }
+
+  private get airdropClientV1(): TonAirdropClientV1 {
+    if (!this?.address) {
+      throw new Error('Contract address is empty');
+    }
+
+    return new TonAirdropClientV1({
+      chainId: this.chainId,
+      address: this.address,
+      walletClient: this.walletClient,
+      tonClient: this.tonClient
+    });
+  }
+
+  private get airdropClientV2(): TonAirdropClientV2 {
+    if (!this?.address) {
+      throw new Error('Contract address is empty');
+    }
+
+    return new TonAirdropClientV2({
+      chainId: this.chainId,
+      address: this.address,
+      walletClient: this.walletClient
+    });
+  }
+
+  private get airdropClientV3(): TonAirdropClientV3 {
+    if (!this?.address) {
+      throw new Error('Contract address is empty');
+    }
+
+    return new TonAirdropClientV3({
+      chainId: this.chainId,
+      address: this.address,
+      walletClient: this.walletClient
+    });
+  }
+
+  async getVersion() {
+    if (this.cachedVersion !== null) {
+      return this.cachedVersion;
+    }
+
+    this.cachedVersion = await this.airdropClientV2.getVersion();
+    return this.cachedVersion;
+  }
+
+  private async getClient() {
+    const version = await this.getVersion();
+
+    if (version === TonAirdropVersionEnum.LiteV1) {
+      return this.airdropClientV3;
+    }
+    return version === TonAirdropVersionEnum.V2 ? this.airdropClientV2 : this.airdropClientV1;
+  }
+
+  async getAirdropContract() {
+    const client = await this.getClient();
+    return client.getAirdropContract();
+  }
+
+  async claim(claimData: IAirdropClaim, options: { onLoading?: () => void }) {
+    const client = await this.getClient();
+    return client.claim(claimData, options);
+  }
+
+  async checkClaimed(claimData: IAirdropClaim) {
+    const client = await this.getClient();
+    return client.checkClaimed(claimData);
+  }
+
+  async getContractInfo() {
+    const client = await this.getClient();
+    return client.getBaseParams();
+  }
+
+  async getPaused() {
+    const client = await this.getClient();
+    if (!(client instanceof TonAirdropClientV1)) {
+      return client.getPaused();
+    } else {
+      return false;
+    }
+  }
+
+  async getClaimFeeInfo() {
+    const client = await this.getClient();
+    const feeInfo = await client.getFeeInfo();
+    return {
+      claimFee: fromNano(feeInfo.claimFee),
+      claimFeeReceiver: feeInfo.claimFeeReceiver.toString({ bounceable: false })
+    };
+  }
+}