@sign-global/tokentable 0.0.1

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

@@ -0,0 +1,235 @@
+import { TonClient } from '@ton/ton';
+import { Sender, SenderArguments, beginCell, storeStateInit, Address, Cell, storeMessage } from '@ton/core';
+import { CHAIN, TonConnectUI } from '@tonconnect/ui-react';
+import { EventEmitter } from 'events';
+import { TonWalletService } from '../../services';
+import { retry } from '../../../utils';
+import { Event } from 'tonapi-sdk-js';
+import { getHttpEndpoint } from '@orbs-network/ton-access';
+
+export interface IAirdropOption {
+  chainId: string;
+  address: string;
+  walletClient?: TonConnectUI;
+  tonClient?: TonClient;
+}
+
+let cachedTonClient: TonClient | null = null;
+
+export class TonContractBaseClient {
+  chainId: string;
+  address: string;
+  walletClient?: TonConnectUI;
+  private eventBus: EventEmitter;
+  private counter: number = 0;
+  tonClient?: TonClient;
+
+  constructor({ chainId, address, walletClient, tonClient }: IAirdropOption) {
+    this.chainId = chainId;
+    this.address = address;
+    this.walletClient = walletClient;
+    this.eventBus = new EventEmitter();
+    this.tonClient = tonClient;
+  }
+
+  waitForContractDeployment = async (provider: TonClient, contractAddress: Address): Promise<Address> => {
+    return new Promise((resolve, reject) => {
+      const checkDeployment = async () => {
+        try {
+          const isDeployed = await provider.isContractDeployed(contractAddress);
+          if (isDeployed) {
+            resolve(contractAddress);
+          } else {
+            // 每3秒检查一次
+            setTimeout(checkDeployment, 3000);
+          }
+        } catch (error) {
+          reject(error);
+        }
+      };
+
+      checkDeployment();
+    });
+  };
+
+  async getTonClient() {
+    if (cachedTonClient) {
+      return cachedTonClient;
+    }
+    const endpoint = await getHttpEndpoint({ network: this.chainId === CHAIN.TESTNET ? 'testnet' : 'mainnet' });
+    cachedTonClient =
+      this.tonClient ||
+      new TonClient({
+        endpoint: endpoint
+      });
+    return cachedTonClient;
+  }
+
+  getTxByBOC = ({ boc: exBoc, userAddress }: { boc: string; userAddress: string }): Promise<string> => {
+    const myAddress = Address.parse(userAddress);
+
+    return retry(
+      async () => {
+        const client = await this.getTonClient();
+        const transactions = await client.getTransactions(myAddress, {
+          limit: 5
+        });
+        for (const tx of transactions) {
+          const inMsg = tx.inMessage;
+          if (inMsg?.info.type === 'external-in') {
+            const inBOC = inMsg?.body;
+            if (typeof inBOC === 'undefined') {
+              throw new Error('Invalid external');
+              continue;
+            }
+            const extHash = Cell.fromBase64(exBoc).hash().toString('hex');
+            const inHash = beginCell().store(storeMessage(inMsg)).endCell().hash().toString('hex');
+
+            console.log(' hash BOC', extHash);
+            console.log('inMsg hash', inHash);
+            console.log('checking the tx', tx, tx.hash().toString('hex'));
+
+            // Assuming `inBOC.hash()` is synchronous and returns a hash object with a `toString` method
+            if (extHash === inHash) {
+              console.log('Tx match');
+              const txHash = tx.hash().toString('hex');
+              console.log(`Transaction Hash: ${txHash}`);
+              console.log(`Transaction LT: ${tx.lt}`);
+              return txHash;
+            }
+          }
+        }
+        throw new Error('Transaction not found');
+      },
+      { retries: 30, delay: 1000 }
+    );
+  };
+
+  waitForTransaction = async (onLoading?: () => void): Promise<Event | null> => {
+    const TonConnectUI = this.walletClient;
+    const boc = await this.onTransactionHash();
+    console.log(boc, 'boc');
+
+    if (!TonConnectUI) {
+      throw new Error('TonConnectUI is not initialized');
+    }
+
+    // 兼容bybit web3钱包，boc为对象
+    if (typeof boc !== 'string') {
+      return null;
+    }
+
+    onLoading?.();
+
+    let receipt: Event | null = null;
+    try {
+      const hash = await this.getTxByBOC({
+        boc,
+        userAddress: TonConnectUI.account!.address
+      });
+      console.log(hash, 'hash');
+      receipt = await TonWalletService?.waitForTransaction({
+        hash,
+        chainId: this.chainId,
+        address: TonConnectUI.account!.address
+      });
+    } catch (e) {
+      console.log(e, 'err');
+      const hash = Cell.fromBase64(boc).hash().toString('hex');
+      console.log(hash, 'hash');
+      receipt = await TonWalletService?.waitForTransactionLegacy({
+        hash,
+        chainId: this.chainId,
+        contractAddress: this!.address,
+        address: TonConnectUI.account!.address
+      });
+    }
+    console.log(receipt, 'tt');
+    return receipt;
+  };
+
+  waitForTransactionForLegacy = async (): Promise<Event | null> => {
+    // 兼容ios Transaction was not sent
+    const TonConnectUI = this.walletClient;
+    if (!TonConnectUI) {
+      throw new Error('TonConnectUI is not initialized');
+    }
+
+    const receipt = await TonWalletService?.waitForTransactionLegacy({
+      hash: '',
+      chainId: this.chainId,
+      // contractAddress: this!.address,
+      address: TonConnectUI.account!.address
+    });
+    console.log(receipt, 'tt');
+    return receipt;
+  };
+
+  onTransactionHash(): Promise<string> {
+    this.counter++;
+    return new Promise((resolve, reject) => {
+      console.log(this.counter, 'once counter');
+      this.eventBus.once(`transactionHash_${this.counter}`, (boc: string) => {
+        if (boc) {
+          resolve(boc);
+        } else {
+          reject('error');
+        }
+      });
+    });
+  }
+
+  get connection(): { sender: Sender; senderDeploy: Sender; connected: boolean } {
+    const TonConnectUI = this.walletClient;
+    if (!TonConnectUI) {
+      throw new Error('TonConnectUI is not initialized');
+    }
+    if (!TonConnectUI.connected) {
+      throw new Error('wallet is not connected, please logout and login again');
+    }
+    return {
+      senderDeploy: {
+        send: async (args: SenderArguments) => {
+          console.log(args, 'args');
+          const res = await TonConnectUI.sendTransaction({
+            messages: [
+              {
+                address: args.to.toString(),
+                amount: args.value.toString(),
+                payload: args.body?.toBoc().toString('base64') || '',
+                stateInit: args.init
+                  ? beginCell().storeWritable(storeStateInit(args.init)).endCell().toBoc().toString('base64')
+                  : undefined
+              }
+            ],
+            validUntil: Date.now() + 5 * 60 * 1000
+          });
+          console.log(res, this.counter, 'emit');
+          this.eventBus.emit(`transactionHash_${this.counter}`, res.boc);
+        }
+      },
+      sender: {
+        send: async (args: SenderArguments) => {
+          console.log(args, TonConnectUI, 'aa');
+          try {
+            const res = await TonConnectUI.sendTransaction({
+              messages: [
+                {
+                  address: args.to.toString(),
+                  amount: args.value.toString(),
+                  payload: args.body?.toBoc().toString('base64')
+                }
+              ],
+              validUntil: Date.now() + 6 * 60 * 1000 // 5 minutes
+            });
+            this.eventBus.emit(`transactionHash_${this.counter}`, res.boc);
+            console.log(res, 'transaction res');
+          } catch (e) {
+            console.log(e, 'err');
+          }
+        }
+      },
+      connected: TonConnectUI.connected
+    };
+  }
+}

package/src/airdrop/core/ton/v1/build/Leaf.compiled.json

@@ -0,0 +1 @@
+{"hex":"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"}

package/src/airdrop/core/ton/v1/build/MerkleTokenDistributor.compiled.json

@@ -0,0 +1 @@
+{"hex":"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"}

package/src/airdrop/core/ton/v1/utils/constants.ts

@@ -0,0 +1,42 @@
+export enum OpCode { // CRC32 hash
+  ChangeAdmin = 1178663965, // 0x4641444d
+  ChangeCode = 1476445391, // 0x57f8f8f
+  ChangePaused = 2809239666, // 0xa7a7a7a2
+  ChangeVersion = 1564829953, // 0x5d5d5d61
+  DeployLeaf = 2334832459, // 0x8b8b8b8b
+  Withdraw = 1944962002, // 0x73737372
+  WithdrawTokens = 2709472225, // 0xa1a1a1a1
+  Claim = 1346182295, // 0x50505057
+  ProcessClaim = 3503682565, // 0xd0d5f405
+  SetBaseParams = 3295019176, // 0xc4c4c4c8
+  SetClaimFee = 203956118, // 0xc2c2c2c6
+  SetClaimFeeAddress = 271928301, // 0x103103d
+  SetPaused = 651583401 // 0x27272729
+}
+
+export enum CodeType { // CRC32 hash
+  Leaf = 4027247955, // 0xf0f0f0f3
+  TokenDistributor = 3451179831 // 0xcececece
+}
+
+export enum ErrorCode {
+  UnknownOP = 0xffff, // 65535
+  ExpiredMessage = 0x20, // 32
+  RepeatedMessage = 0x21, // 33
+  InvalidSignature = 0x22, // 34
+  Unauthorized = 0x23, // 35
+  InvalidMessageParams = 0x24, // 36
+  UnsupportedOperation = 0x25, // 37
+  TimeInactive = 0x26, // 38
+  InvalidProof = 0x27, // 39
+  LeafUsed = 0x28, // 40
+  IncorrectFees = 0x29, // 41
+  IsProofExotic = 0x2a, // 42
+  TreeExceeded = 0x2b, // 43
+  InvalidTree = 0x2c, // 44
+  NotFound = 0x2d, // 45
+  WrongSender = 0x2e, // 46
+  InvalidIndex = 0x2f, // 47
+  NotEnoughTokens = 0x30, // 48
+  ContractPaused = 0x31 // 49
+}

package/src/airdrop/core/ton/v1/utils/date.utils.ts

@@ -0,0 +1,11 @@
+export function dateToUnixTimestamp(date: Date): number {
+  return Math.floor(date.getTime() / 1000);
+}
+
+export function unixTimestampToDate(timestamp: number): Date {
+  return new Date(timestamp * 1000);
+}
+
+export function addOneHour(date: Date): Date {
+  return new Date(date.getTime() + 60 * 60 * 1000);
+}

package/src/airdrop/core/ton/v1/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './constants';
+export * from './date.utils';
+export * from './ton.utils';

package/src/airdrop/core/ton/v1/utils/ton.utils.ts

@@ -0,0 +1,84 @@
+import { Address, BitString, Cell, Slice, beginCell, contractAddress, crc32c, toNano } from '@ton/core';
+
+export function stringToSlice(str: string): Slice {
+  return beginCell().storeStringTail(str).endCell().asSlice();
+}
+
+export function sliceToString(slice: Slice): string {
+  const cell = beginCell().storeSlice(slice).endCell();
+  return cell.beginParse().loadStringTail();
+}
+
+export function stringToInt(str: string): number {
+  return str ? parseInt(Buffer.from(str).toString('hex'), 16) : 0;
+}
+
+export function intToString(int: number): string {
+  return Buffer.from(int.toString(16), 'hex').toString('utf-8');
+}
+
+export function bufferToInt(buf: Buffer): number {
+  return buf.readUInt32BE(0);
+}
+
+export function intToBuffer(int: number): Buffer {
+  return Buffer.from(int.toString(16), 'hex');
+}
+
+export function sliceToAddress(slice: Slice): Address {
+  const cell = beginCell().storeSlice(slice).endCell();
+  return cell.beginParse().loadAddress();
+}
+
+export function addressToSlice(address: Address): Slice {
+  return beginCell().storeAddress(address).endCell().asSlice();
+}
+
+export function stringToBitString(str: string): BitString {
+  return new BitString(Buffer.from(str), 0, str.length * 8);
+}
+
+export function bitStringToString(bits: BitString, len: number): string {
+  const decoder = new TextDecoder();
+  const subBuffer = bits.subbuffer(0, len);
+
+  return subBuffer ? decoder.decode(subBuffer) : '';
+}
+
+export function stringToCell(str: string): Cell {
+  return beginCell().storeStringTail(str).endCell();
+}
+
+export function cellToString(cell: Cell): string {
+  return cell.beginParse().loadStringTail();
+}
+
+export function stringToCrc32(str: string): number {
+  return crc32c(Buffer.from(str)).readUint32BE();
+}
+
+export function getContractAddress(code: Cell, data: Cell): Address {
+  return contractAddress(0, { code, data });
+}
+
+export function arraysToCell(arrays: (Slice | Cell | Address | number)[], bits = 32): Cell {
+  const cell = beginCell();
+
+  arrays.forEach((item) => {
+    if (item instanceof Slice) {
+      cell.storeSlice(item);
+    } else if (item instanceof Cell) {
+      cell.storeRef(item);
+    } else if (item instanceof Address) {
+      cell.storeAddress(item);
+    } else if (typeof item === 'number') {
+      cell.storeUint(item, bits);
+    }
+  });
+
+  return cell.endCell();
+}
+
+export function coinsToSlice(coins: string): Slice {
+  return beginCell().storeCoins(toNano(coins)).endCell().asSlice();
+}

package/src/airdrop/core/ton/v1/wrappers/JettonMinter.ts

@@ -0,0 +1,81 @@
+import { Address, beginCell, Cell, Contract, contractAddress, ContractProvider, Sender, SendMode } from '@ton/core';
+
+export type JettonMinterConfig = {
+  admin: Address;
+  content: Cell;
+  walletCode: Cell;
+};
+
+export function jettonMinterConfigToCell(config: JettonMinterConfig): Cell {
+  return beginCell()
+    .storeCoins(0)
+    .storeAddress(config.admin)
+    .storeRef(config.content)
+    .storeRef(config.walletCode)
+    .endCell();
+}
+
+export class JettonMinter implements Contract {
+  constructor(readonly address: Address, readonly init?: { code: Cell; data: Cell }) {}
+
+  static createFromAddress(address: Address) {
+    return new JettonMinter(address);
+  }
+
+  static createFromConfig(config: JettonMinterConfig, code: Cell, workchain = 0) {
+    const data = jettonMinterConfigToCell(config);
+    const init = { code, data };
+    return new JettonMinter(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 sendMint(
+    provider: ContractProvider,
+    via: Sender,
+    value: bigint,
+    forwardValue: bigint,
+    recipient: Address,
+    amount: bigint
+  ) {
+    await provider.internal(via, {
+      sendMode: SendMode.PAY_GAS_SEPARATELY,
+      body: beginCell()
+        .storeUint(21, 32)
+        .storeUint(0, 64)
+        .storeAddress(recipient)
+        .storeCoins(forwardValue)
+        .storeRef(
+          beginCell()
+            .storeUint(0x178d4519, 32)
+            .storeUint(0, 64)
+            .storeCoins(amount)
+            .storeAddress(this.address)
+            .storeAddress(this.address)
+            .storeCoins(0)
+            .storeUint(0, 1)
+            .endCell()
+        )
+        .endCell(),
+      value: value + forwardValue
+    });
+  }
+
+  async getWalletAddressOf(provider: ContractProvider, address: Address) {
+    return (
+      await provider.get('get_wallet_address', [{ type: 'slice', cell: beginCell().storeAddress(address).endCell() }])
+    ).stack.readAddress();
+  }
+
+  async getWalletCode(provider: ContractProvider) {
+    const stack = (await provider.get('get_jetton_data', [])).stack;
+    stack.skip(4);
+    return stack.readCell();
+  }
+}

package/src/airdrop/core/ton/v1/wrappers/JettonWallet.ts

@@ -0,0 +1,73 @@
+import { Address, beginCell, Cell, Contract, contractAddress, ContractProvider, Sender, SendMode } from '@ton/core';
+
+export type JettonWalletConfig = {
+  owner: Address;
+  minter: Address;
+  walletCode: Cell;
+};
+
+export function jettonWalletConfigToCell(config: JettonWalletConfig): Cell {
+  return beginCell()
+    .storeCoins(0)
+    .storeAddress(config.owner)
+    .storeAddress(config.minter)
+    .storeRef(config.walletCode)
+    .endCell();
+}
+
+export class JettonWallet implements Contract {
+  constructor(readonly address: Address, readonly init?: { code: Cell; data: Cell }) {}
+
+  static createFromAddress(address: Address) {
+    return new JettonWallet(address);
+  }
+
+  static createFromConfig(config: JettonWalletConfig, code: Cell, workchain = 0) {
+    const data = jettonWalletConfigToCell(config);
+    const init = { code, data };
+    return new JettonWallet(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 sendTransfer(
+    provider: ContractProvider,
+    via: Sender,
+    value: bigint,
+    forwardValue: bigint,
+    recipient: Address,
+    amount: bigint,
+    forwardPayload: Cell
+  ) {
+    await provider.internal(via, {
+      sendMode: SendMode.PAY_GAS_SEPARATELY,
+      body: beginCell()
+        .storeUint(0x0f8a7ea5, 32)
+        .storeUint(0, 64)
+        .storeCoins(amount)
+        .storeAddress(recipient)
+        .storeAddress(via.address)
+        .storeUint(0, 1)
+        .storeCoins(forwardValue)
+        .storeUint(1, 1)
+        .storeRef(forwardPayload)
+        .endCell(),
+      value: value + forwardValue
+    });
+  }
+
+  async getJettonBalance(provider: ContractProvider) {
+    const state = await provider.getState();
+    if (state.state.type !== 'active') {
+      return 0n;
+    }
+    const res = await provider.get('get_wallet_data', []);
+    return res.stack.readBigNumber();
+  }
+}

package/src/airdrop/core/ton/v1/wrappers/Leaf.ts

@@ -0,0 +1,88 @@
+import { Address, beginCell, Cell, Contract, contractAddress, ContractProvider, Sender, toNano } from '@ton/core';
+import { OpCode } from '../utils';
+
+export type LeafConfig = {
+  used?: boolean;
+  distributor: Address;
+  index: bigint;
+};
+
+export const MIN_CLAIM_FEE = toNano('0.11');
+
+export function leafConfigToCell(config: LeafConfig): Cell {
+  const { distributor, index } = config;
+
+  const initState = beginCell()
+    .storeBit(false)
+    .storeAddress(distributor)
+    .storeUint(index, 256)
+    .storeUint(0, 64)
+    .endCell();
+
+  return initState;
+}
+
+export class Leaf implements Contract {
+  constructor(readonly address: Address, readonly init?: { code: Cell; data: Cell }) {}
+
+  static createFromAddress(address: Address) {
+    return new Leaf(address);
+  }
+
+  static createFromConfig(config: LeafConfig, code: Cell, workchain = 0) {
+    const data = leafConfigToCell(config);
+    const init = { code, data };
+    return new Leaf(contractAddress(workchain, init), init);
+  }
+
+  async getSeqno(provider: ContractProvider): Promise<number> {
+    const result = await provider.get('get_seqno', []);
+
+    return result.stack.readNumber();
+  }
+
+  async getIsUsed(provider: ContractProvider): Promise<boolean> {
+    const result = await provider.get('get_is_used', []);
+    const isUsed = result.stack.readNumber();
+
+    return !!isUsed;
+  }
+
+  async getLeafData(provider: ContractProvider): Promise<LeafConfig> {
+    const result = await provider.get('get_leaf_data', []);
+    const cellHash = result.stack.readCell().beginParse();
+
+    const isUsed = cellHash.loadUint(1);
+    const distributor = cellHash.loadAddress();
+    const index = cellHash.loadUint(256);
+
+    return {
+      used: !!isUsed,
+      index: BigInt(index),
+      distributor
+    };
+  }
+
+  async sendLeafFees(_provider: ContractProvider, via: Sender, claimFee: bigint, code: Cell, data: Cell) {
+    await via.send({
+      bounce: false,
+      to: this.address,
+      value: MIN_CLAIM_FEE + claimFee,
+      init: {
+        code,
+        data
+      },
+      body: beginCell().endCell()
+    });
+  }
+
+  async sendClaim(provider: ContractProvider, proof: Cell, index: bigint, queryId = 0) {
+    const messageBody = beginCell()
+      .storeUint(OpCode.Claim, 32)
+      .storeUint(queryId, 64)
+      .storeRef(proof)
+      .storeUint(index, 256)
+      .endCell();
+    await provider.external(messageBody);
+  }
+}