@sign-global/tokentable 0.0.1

package/src/airdrop/core/ton/v3/wrappers/MerkleTokenDistributor.ts

@@ -0,0 +1,316 @@
+import {
+  Address,
+  beginCell,
+  Builder,
+  Cell,
+  Contract,
+  contractAddress,
+  ContractProvider,
+  Dictionary,
+  Sender,
+  SendMode,
+  Slice,
+  toNano,
+  TupleItem
+} from '@ton/core';
+import { CodeType, dateToUnixTimestamp, intToString, OpCode, stringToInt, unixTimestampToDate } from '../utils';
+
+export type MerkleTokenDistributorConfig = {
+  version: string;
+  adminAddress: Address;
+  root: bigint;
+  deployer: Address;
+  token?: Address;
+  startTime: Date;
+  endTime: Date;
+  leafCode: Cell;
+  claimFee: bigint;
+  claimFeeAddress: Address;
+  paused?: boolean;
+  feelessThreshold?: bigint;
+};
+
+export function tokenDistributorConfigToCell(config: MerkleTokenDistributorConfig): Cell {
+  const {
+    version,
+    adminAddress,
+    deployer,
+    endTime,
+    leafCode,
+    root,
+    startTime,
+    token,
+    claimFee,
+    claimFeeAddress,
+    paused = false,
+    feelessThreshold = 0
+  } = config;
+  const c2 = beginCell()
+    .storeCoins(claimFee)
+    .storeAddress(claimFeeAddress)
+    .storeUint(paused ? 1 : 0, 1)
+    .storeCoins(feelessThreshold)
+    .endCell();
+
+  const c1 = beginCell()
+    .storeAddress(deployer)
+    .storeAddress(token)
+    .storeUint(dateToUnixTimestamp(startTime), 32)
+    .storeUint(dateToUnixTimestamp(endTime), 32)
+    .storeRef(leafCode)
+    .endCell();
+
+  return beginCell()
+    .storeUint(stringToInt(version), 64)
+    .storeAddress(adminAddress)
+    .storeUint(root, 256)
+    .storeRef(c1)
+    .storeRef(c2)
+    .endCell();
+}
+
+export type TokenDistributorEntry = {
+  address: Address;
+  claimableAmount: bigint;
+  claimableTimestamp: number;
+};
+
+export const tokenDistributorEntryValue = {
+  serialize: (src: TokenDistributorEntry, buidler: Builder) => {
+    buidler.storeAddress(src.address).storeCoins(src.claimableAmount).storeUint(src.claimableTimestamp, 32);
+  },
+  parse: (src: Slice) => {
+    return {
+      address: src.loadAddress(),
+      claimableAmount: src.loadCoins(),
+      claimableTimestamp: src.loadUint(32)
+    };
+  }
+};
+
+export function generateEntriesDictionary(entries: TokenDistributorEntry[]): Dictionary<bigint, TokenDistributorEntry> {
+  const dict: Dictionary<bigint, TokenDistributorEntry> = Dictionary.empty(
+    Dictionary.Keys.BigUint(64),
+    tokenDistributorEntryValue
+  );
+
+  for (let i = 0; i < entries.length; i++) {
+    dict.set(BigInt(i), entries[i]);
+  }
+
+  return dict;
+}
+
+export class MerkleTokenDistributor implements Contract {
+  constructor(readonly address: Address, readonly init?: { code: Cell; data: Cell }) {}
+
+  static createFromAddress(address: Address) {
+    return new MerkleTokenDistributor(address);
+  }
+
+  static createFromConfig(config: MerkleTokenDistributorConfig, code: Cell, workchain = 0) {
+    const data = tokenDistributorConfigToCell(config);
+    const init = { code, data };
+    return new MerkleTokenDistributor(contractAddress(workchain, init), init);
+  }
+
+  async sendDeploy(provider: ContractProvider, via: Sender, value: bigint) {
+    await provider.internal(via, {
+      value,
+      sendMode: SendMode.PAY_GAS_SEPARATELY,
+      body: beginCell().endCell()
+    });
+  }
+
+  async getVersion(provider: ContractProvider): Promise<string> {
+    const result = await provider.get('get_version', []);
+
+    return intToString(Number(result.stack.readBigNumber()));
+  }
+
+  async getLeafAddress(provider: ContractProvider, index: bigint): Promise<Address> {
+    const arg: TupleItem = {
+      value: index,
+      type: 'int'
+    };
+    const result = await provider.get('get_leaf_address', [arg]);
+
+    return result.stack.readAddress();
+  }
+
+  async getRoot(provider: ContractProvider): Promise<bigint> {
+    const result = await provider.get('get_root', []);
+
+    return result.stack.readBigNumber();
+  }
+
+  async getTime(provider: ContractProvider): Promise<[Date, Date] | [null, null]> {
+    const result = await provider.get('get_time', []);
+    const stack = result.stack;
+
+    try {
+      return [unixTimestampToDate(stack.readNumber()), unixTimestampToDate(stack.readNumber())];
+    } catch (e) {
+      return [null, null];
+    }
+  }
+
+  async getToken(provider: ContractProvider): Promise<Address | null> {
+    const result = await provider.get('get_token', []);
+
+    try {
+      return result.stack.readAddress();
+    } catch (e) {
+      return null;
+    }
+  }
+
+  async getAdminAddress(provider: ContractProvider): Promise<Address> {
+    const result = await provider.get('get_admin_address', []);
+
+    return result.stack.readAddress();
+  }
+
+  async getClaimFee(provider: ContractProvider): Promise<bigint> {
+    const result = await provider.get('get_claim_fee', []);
+
+    return result.stack.readBigNumber();
+  }
+
+  async getClaimFeeAddress(provider: ContractProvider): Promise<Address> {
+    const result = await provider.get('get_claim_fee_address', []);
+
+    return result.stack.readAddress();
+  }
+
+  async getPaused(provider: ContractProvider): Promise<boolean> {
+    const result = await provider.get('get_paused', []);
+
+    return result.stack.readNumber() === 1;
+  }
+
+  async getFeelessThreshold(provider: ContractProvider): Promise<bigint> {
+    const result = await provider.get('get_feeless_threshold', []);
+
+    return result.stack.readBigNumber();
+  }
+
+  async sendChangeAdmin(provider: ContractProvider, via: Sender, newAdmin: Address) {
+    const messageBody = beginCell().storeUint(OpCode.ChangeAdmin, 32).storeUint(0, 64).storeAddress(newAdmin).endCell();
+    const result = await provider.internal(via, {
+      value: '0.01',
+      body: messageBody
+    });
+
+    return result;
+  }
+
+  async sendChangeCode(provider: ContractProvider, via: Sender, codeType: CodeType, newCode: Cell) {
+    const messageBody = beginCell()
+      .storeUint(OpCode.ChangeCode, 32)
+      .storeUint(0, 64)
+      .storeUint(codeType, 32)
+      .storeRef(newCode)
+      .endCell();
+    const result = await provider.internal(via, {
+      value: '0.01',
+      body: messageBody
+    });
+
+    return result;
+  }
+
+  async sendChangeVersion(provider: ContractProvider, via: Sender, version: string) {
+    const messageBody = beginCell()
+      .storeUint(OpCode.ChangeVersion, 32)
+      .storeUint(0, 64)
+      .storeUint(stringToInt(version), 64)
+      .endCell();
+    const result = await provider.internal(via, {
+      value: '0.01',
+      body: messageBody
+    });
+
+    return result;
+  }
+
+  async sendWithdraw(provider: ContractProvider, via: Sender, amount: string) {
+    const messageBody = beginCell()
+      .storeUint(OpCode.Withdraw, 32)
+      .storeUint(0, 64)
+      .storeCoins(toNano(amount))
+      .endCell();
+    const result = await provider.internal(via, {
+      value: '0.01',
+      body: messageBody
+    });
+
+    return result;
+  }
+
+  async sendWithdrawTokens(provider: ContractProvider, via: Sender, amount: string) {
+    const messageBody = beginCell()
+      .storeUint(OpCode.WithdrawTokens, 32)
+      .storeUint(0, 64)
+      .storeCoins(toNano(amount))
+      .endCell();
+    const result = await provider.internal(via, {
+      value: '0.1',
+      body: messageBody
+    });
+
+    return result;
+  }
+
+  async sendSetBaseParams(
+    provider: ContractProvider,
+    via: Sender,
+    startTime: Date,
+    endTime: Date,
+    root: bigint,
+    token: Address
+  ) {
+    const messageBody = beginCell()
+      .storeUint(OpCode.SetBaseParams, 32)
+      .storeUint(0, 64)
+      .storeAddress(token)
+      .storeUint(dateToUnixTimestamp(startTime), 32)
+      .storeUint(dateToUnixTimestamp(endTime), 32)
+      .storeUint(root, 256)
+      .endCell();
+    const result = await provider.internal(via, {
+      value: '0.01',
+      body: messageBody
+    });
+
+    return result;
+  }
+
+  async sendSetPaused(provider: ContractProvider, via: Sender, paused: boolean) {
+    const messageBody = beginCell()
+      .storeUint(OpCode.SetPaused, 32)
+      .storeUint(0, 64)
+      .storeUint(paused ? 1 : 0, 1)
+      .endCell();
+    const result = await provider.internal(via, {
+      value: '0.01',
+      body: messageBody
+    });
+
+    return result;
+  }
+
+  async sendSetFeelessThreshold(provider: ContractProvider, via: Sender, feelessThreshold: bigint) {
+    const messageBody = beginCell()
+      .storeUint(OpCode.SetFeelessThreshold, 32)
+      .storeUint(0, 64)
+      .storeCoins(feelessThreshold)
+      .endCell();
+    const result = await provider.internal(via, {
+      value: '0.01',
+      body: messageBody
+    });
+
+    return result;
+  }
+}

package/src/airdrop/core/ton/v3/wrappers/index.ts

@@ -0,0 +1,2 @@
+export * from './Leaf';
+export * from './MerkleTokenDistributor';

package/src/airdrop/index.ts

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

package/src/airdrop/services/index.ts

@@ -0,0 +1,63 @@
+import { apiClient } from '../../utils/api-client';
+import { safeParseJSON } from '../../utils/utils';
+import { IAirdropData, IProject } from '../types';
+
+export { TonWalletService } from './wallet-service/ton';
+
+const createApiClient = (baseURL?: string) => {
+  return baseURL ? apiClient.extend({ baseURL }) : apiClient;
+};
+
+export const getAirdropProject = async (projectId: string, baseURL?: string): Promise<IProject> => {
+  const client = createApiClient(baseURL);
+  const res = await client.get<any>(`/airdrop-open/projects/${projectId}`);
+  if (!res) return res; // res为null
+  const projectConfig = res?.themeConf;
+  const blockCountries = safeParseJSON(projectConfig?.blockCountries);
+  return {
+    ...res,
+    blockCountries
+  };
+};
+
+export const getAirdropProjectId = async (
+  data: {
+    recipient: string;
+    slug: string;
+  },
+  baseURL?: string
+): Promise<{ recipient: string; projectIds: string[] }> => {
+  const client = createApiClient(baseURL);
+  return client.post(`/airdrop-open/query-pid`, data);
+};
+
+export const getAirdropPro = async (
+  slug: string,
+  baseURL?: string
+): Promise<{
+  slug: string;
+  childProjectMapping: Record<string, string>;
+}> => {
+  const client = createApiClient(baseURL);
+  return client.get(`/airdrop-open/airdrop-pro/${slug}`);
+};
+
+export const getAirdropQuery = async (
+  data: {
+    recipient: string;
+    projectId: string;
+    recipientType: string;
+  },
+  baseURL?: string
+): Promise<IAirdropData> => {
+  const client = createApiClient(baseURL);
+  return client.post(`/airdrop-open/query`, data);
+};
+
+export const getJettonInfo = async (
+  data: { address: string; isTestnet: 'true' | 'false' },
+  baseURL?: string
+): Promise<any> => {
+  const client = createApiClient(baseURL);
+  return client.get(`/airdrop-open/jetton/${data.address}?isTestnet=${data.isTestnet}`);
+};

package/src/airdrop/services/wallet-service/ton/WalletService.ts

@@ -0,0 +1,226 @@
+import TonWeb from 'tonweb';
+import { Address } from '@ton/core';
+import { JettonMaster, TonClient } from '@ton/ton';
+import { delay, flipAddressType } from '../../../../utils';
+
+import { Api, HttpClient, Event } from 'tonapi-sdk-js';
+import { ChainConfig } from '../../../constants';
+import { getJettonInfo } from '../../index';
+import { CHAIN } from '@tonconnect/ui-react';
+// import { getHttpEndpoint } from '@orbs-network/ton-access';
+// import { CHAIN } from '@tonconnect/ui-react';
+
+interface WaitForTransactionOptions {
+  address: string;
+  hash: string;
+  refetchInterval?: number;
+  refetchLimit?: number;
+  chainId: string;
+  contractAddress?: string;
+}
+
+export abstract class TonWalletService {
+  // static walletClient = tonStore.walletClient;
+
+  static disconnect() {
+    //
+  }
+
+  static async getTonClient(chainId: string) {
+    const endpoint = ChainConfig[chainId as keyof typeof ChainConfig].rpcUrl;
+    // const endpoint = await getHttpEndpoint({ network: chainId === CHAIN.TESTNET ? 'testnet' : 'mainnet' });
+    return new TonClient({
+      endpoint: endpoint
+    });
+  }
+
+  static getTonApiClient(chainId: string) {
+    const { tonApiPrefix } = ChainConfig[chainId as keyof typeof ChainConfig] as any;
+
+    const httpClient = new HttpClient({
+      baseUrl: tonApiPrefix
+      // baseApiParams: {
+      //   headers: {
+      //     Authorization: `Bearer ${tonApiKey}`,
+      //     'Content-type': 'application/json'
+      //   }
+      // }
+    });
+
+    const client = new Api(httpClient);
+    return client;
+  }
+
+  static waitForTransactionByClient = async (options: WaitForTransactionOptions): Promise<Event | null> => {
+    const { hash, refetchInterval = 3000, refetchLimit, chainId } = options;
+
+    return new Promise((resolve) => {
+      let refetches = 0;
+      const interval = setInterval(async () => {
+        refetches += 1;
+
+        console.log(hash, 'waiting transaction...');
+        const tonApi = this.getTonApiClient(chainId);
+        const events = await tonApi.events.getEvent(hash);
+        console.log(events, 'traceData');
+        if (!events.in_progress) {
+          await delay(3000);
+          clearInterval(interval);
+          resolve(events);
+        }
+        if (refetchLimit && refetches >= refetchLimit) {
+          clearInterval(interval);
+          resolve(null);
+        }
+      }, refetchInterval);
+    });
+  };
+
+  static waitForTransactionLegacy = async (options: WaitForTransactionOptions): Promise<Event | null> => {
+    const { refetchInterval = 3000, refetchLimit, chainId, address, contractAddress } = options;
+
+    const tonApi = this.getTonApiClient(chainId);
+    const tonClient = await this.getTonClient(chainId);
+    const walletAddress = Address.parse(address);
+
+    return new Promise((resolve) => {
+      let refetches = 0;
+      const interval = setInterval(async () => {
+        refetches += 1;
+
+        console.log('waiting transaction...');
+
+        let hash;
+
+        if (contractAddress) {
+          const res = await tonApi.accounts.getAccountEvents(address, {
+            limit: 5
+          });
+          const targetTransaction = res.events.find((it) => {
+            return (
+              it.actions.length &&
+              it.actions.find((action) => {
+                return action.simple_preview.accounts.find((ac) => {
+                  return Address.parse(ac.address).toRawString() === Address.parse(contractAddress).toRawString();
+                });
+              })
+            );
+          });
+          console.log(targetTransaction, 'res');
+          if (targetTransaction) {
+            hash = targetTransaction.event_id;
+          }
+        } else {
+          const state = await tonClient.getContractState(walletAddress);
+          console.log(state, 'state');
+          hash = state.lastTransaction?.hash;
+        }
+        if (hash) {
+          const events = await tonApi.events.getEvent(hash);
+          console.log(events, 'events');
+          if (!events.in_progress) {
+            clearInterval(interval);
+            resolve(events);
+          }
+        }
+        if (refetchLimit && refetches >= refetchLimit) {
+          clearInterval(interval);
+          resolve(null);
+        }
+      }, refetchInterval);
+    });
+  };
+
+  static async waitForTransaction({
+    hash,
+    chainId,
+    address,
+    contractAddress
+  }: {
+    hash: string;
+    chainId: string;
+    address: string;
+    contractAddress?: string;
+  }) {
+    return this.waitForTransactionByClient({ hash, address, chainId, contractAddress });
+  }
+
+  static async fetchBalance(args: { chainId: string; address: string; token?: string }) {
+    try {
+      const config = ChainConfig[args.chainId as keyof typeof ChainConfig] as any;
+      const options = { method: 'GET' };
+      const rawAddress = flipAddressType(args.address);
+
+      const url = args.token
+        ? `${config.tonApiPrefix}/v2/accounts/${rawAddress}/jettons?currencies=usd`
+        : `${config.tonApiPrefix}/v2/blockchain/accounts/${rawAddress}`;
+
+      const response = await fetch(url, options);
+      const responseJSON: any = await response.json();
+      const current = args.token
+        ? responseJSON.balances.find((it: any) => it.jetton.address === flipAddressType(args.token!))
+        : { balance: responseJSON.balance / 1000000000 };
+
+      return {
+        value: current?.balance || 0
+      };
+    } catch {
+      return {
+        value: 0
+      };
+    }
+  }
+
+  static async fetchToken(args: { chainId: string; address: string }) {
+    return getJettonInfo({
+      address: args.address,
+      isTestnet: args.chainId === CHAIN.TESTNET ? 'true' : 'false'
+    });
+    // const client = this.getTonApiClient(args.chainId as string);
+    // const data: any = await client.jettons.getJettonInfo(args.address);
+    // const { metadata, total_supply } = data;
+    // return {
+    //   ...metadata,
+    //   totalSupply: {
+    //     value: total_supply,
+    //     formatted: fromNano(total_supply)
+    //   }
+    // };
+  }
+
+  static async signMessage() {}
+
+  static async addChain() {}
+
+  static async fetchEnsAddress() {
+    return '';
+  }
+
+  static validateAddress(address: string) {
+    try {
+      Address.parse(address);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  static isSameAddress(address1: string, address2: string) {
+    return Address.parse(address1).toRawString() === Address.parse(address2).toRawString();
+  }
+
+  static getJettonAddress = async ({
+    chainId,
+    address,
+    token
+  }: {
+    chainId: string;
+    address: string;
+    token: string;
+  }) => {
+    const client = await this.getTonClient(chainId);
+    const jettonWallet = client.open(JettonMaster.create(Address.parse(token)));
+
+    return jettonWallet.getWalletAddress(Address.parse(address));
+  };
+}

package/src/airdrop/services/wallet-service/ton/index.ts

@@ -0,0 +1 @@
+export { TonWalletService } from './WalletService';