@sign-global/tokentable 0.4.3-beta.0 → 0.4.3-beta.2

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

@@ -1,316 +0,0 @@
-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/contracts/ton/v3/wrappers/index.ts

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

package/src/airdrop/index.ts

@@ -1,10 +0,0 @@
-export { AirdropClient } from './AirdropClient';
-export { SignatureAirdropClient } from './SignatureAirdropClient';
-export {
-  EvmSignatureAirdropService,
-  SolanaSignatureAirdropService,
-  EvmAirdropService,
-  TonAirdropService
-} from './contracts';
-
-export { CONST } from './constants';

package/src/airdrop/services/index.ts

@@ -1,159 +0,0 @@
-import { apiClient } from '../../utils/api-client';
-import { safeParseJSON } from '../../utils/utils';
-import {
-  AirdropSigIdentityTypeEnum,
-  IAirdropData,
-  IAirdropSignatureData,
-  IClaimSignature,
-  IContractConfig,
-  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 is 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 getAirdropContractConfig = async (
-  data: { chainId: string; chainType: string; contractAddress: string },
-  baseURL?: string
-): Promise<IContractConfig> => {
-  const client = createApiClient(baseURL);
-  return client.post(`/airdrop-open/contract/config`, 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}`);
-};
-
-interface SidResponse {
-  sid: string;
-}
-
-interface TwitterConnectParams {
-  code: string;
-  projectId: string;
-}
-
-interface WalletBindParams {
-  projectId: string;
-  key: string;
-  signature: string;
-  message: string;
-  timestamp: number;
-  recipientType: string;
-  address: string;
-}
-
-const getSidHeader = (projectId: string) => ({
-  sid: window.localStorage.getItem(`sid_${projectId}`) || ''
-});
-
-export const connectTwitter = async (data: TwitterConnectParams, baseURL?: string): Promise<SidResponse> => {
-  const client = createApiClient(baseURL);
-  return client.post('/airdrop-open/connect-twitter', data, {
-    headers: getSidHeader(data.projectId)
-  });
-};
-
-export const checkEligibility = async (
-  data: { projectId: string },
-  baseURL?: string
-): Promise<IAirdropSignatureData> => {
-  const headers = getSidHeader(data.projectId);
-  if (!headers.sid)
-    return {
-      claims: [],
-      identities: []
-    };
-  const client = createApiClient(baseURL);
-
-  return client.post('/airdrop-open/check-eligibility', data, {
-    headers: headers
-  });
-};
-
-export const bindWallet = async (data: WalletBindParams, baseURL?: string): Promise<SidResponse> => {
-  const client = createApiClient(baseURL);
-  return client.post('/airdrop-open/connect-wallet', data, {
-    headers: getSidHeader(data.projectId)
-  });
-};
-
-interface DisconnectParams {
-  projectId: string;
-  recipientType: AirdropSigIdentityTypeEnum;
-  recipient?: string;
-}
-
-export const disconnectRecipient = async (data: DisconnectParams, baseURL?: string): Promise<void> => {
-  const client = createApiClient(baseURL);
-  return client.post('/airdrop-open/disconnect', data, {
-    headers: getSidHeader(data.projectId)
-  });
-};
-
-export const checkGetSignatures = async (
-  data: {
-    projectId: string;
-    claimIds: string[];
-    recipient: string;
-  },
-  baseURL?: string
-): Promise<{ signatures: IClaimSignature[] }> => {
-  const client = createApiClient(baseURL);
-  return client.post('/airdrop-open/check-get-signatures', data, {
-    headers: getSidHeader(data.projectId)
-  });
-};

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

@@ -1,226 +0,0 @@
-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

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