@sign-global/tokentable 0.4.2-beta.2 → 0.4.2-beta.4

package/src/airdrop/contracts/solana/AirdropSignatureClient.ts

@@ -1,242 +0,0 @@
-import { PublicKey } from '@solana/web3.js';
-import { SolanaContractClientBase, SolanaContractInfo } from './SolanaContractClient';
-import IDL from './fungible_token_distributor_solana.json';
-import * as anchor from '@coral-xyz/anchor';
-import { FungibleTokenDistributorSolana } from './fungible_token_distributor_solana';
-import { TOKEN_2022_PROGRAM_ID } from '@solana/spl-token';
-import { FeeCollectorClient } from './FeeCollectorClient';
-import { fetchTokenVersion, getOrCreateAssociatedTokenAccount, hexStrToU8Array } from '../../../utils';
-
-export class AirdropSignatureClient extends SolanaContractClientBase<FungibleTokenDistributorSolana> {
-  projectId: string;
-  constructor(options: SolanaContractInfo) {
-    super({
-      ...options,
-      idl: IDL
-    });
-    this.projectId = options.projectId;
-  }
-
-  async getVersionPDA(): Promise<PublicKey> {
-    const [versionPDA] = await this.findProgramAddress([anchor.utils.bytes.utf8.encode('version')]);
-
-    return versionPDA;
-  }
-
-  async getVersion() {
-    const versionPDA = await this.getVersionPDA();
-    const versionData = await this.fetchAccountData('version', versionPDA);
-    return versionData.version;
-  }
-
-  get FeeCollector() {
-    return new FeeCollectorClient({
-      projectId: this.projectId,
-      walletClient: this.wallet,
-      chainId: this.chainId
-    });
-  }
-
-  async getClaimFee(amount: bigint) {
-    return this.FeeCollector.getClaimFee(amount.toString());
-  }
-
-  async getStoragePDA(): Promise<PublicKey> {
-    const [storagePDA] = await this.findProgramAddress([
-      anchor.utils.bytes.utf8.encode('storage'),
-      anchor.utils.bytes.utf8.encode(this.projectId)
-    ]);
-
-    return storagePDA;
-  }
-
-  async getAirdropPDA(): Promise<PublicKey> {
-    const [airdropPDA] = await this.findProgramAddress([
-      anchor.utils.bytes.utf8.encode('airdrop'),
-      anchor.utils.bytes.utf8.encode(this.projectId)
-    ]);
-
-    return airdropPDA;
-  }
-
-  async getVaultPDA(): Promise<PublicKey> {
-    const airdropPDA = await this.getAirdropPDA();
-    const [vaultPDA] = await this.findProgramAddress([anchor.utils.bytes.utf8.encode('vault'), airdropPDA.toBuffer()]);
-
-    return vaultPDA;
-  }
-
-  async getClaimPDA(claimId: string): Promise<PublicKey> {
-    const airdropPDA = await this.getAirdropPDA();
-    const [claimPDA] = await this.findProgramAddress([
-      anchor.utils.bytes.utf8.encode('claim'),
-      airdropPDA.toBuffer(),
-      new Uint8Array(hexStrToU8Array(claimId))
-    ]);
-    return claimPDA;
-  }
-
-  async getContractInfo() {
-    const airdropPDA = await this.getAirdropPDA();
-    const config: any = await this.fetchAccountData('airdrop', airdropPDA);
-
-    const version = await this.getVersion();
-    return {
-      version: version,
-      token: config.token.toString() as string,
-      startTime: Number(config.startTime),
-      endTime: Number(config.endTime),
-      paused: config.paused as boolean,
-      signer: config.authorizedSigner.toString() as string,
-      owner: config.owner.toString() as string
-    };
-  }
-
-  async getPaused() {
-    const config = await this.getContractInfo();
-    return config.paused;
-  }
-
-  async checkClaim(id: string) {
-    const claimPDA = await this.getClaimPDA(id);
-    try {
-      const claimData = await this.fetchAccountData('claim', claimPDA);
-      return claimData?.used;
-    } catch (error) {
-      return false;
-    }
-  }
-
-  async batchFetchClaimed(userClaimIds: string[]): Promise<boolean[]> {
-    const res = await Promise.all(userClaimIds.map((id) => this.checkClaim(id)));
-    return res;
-  }
-
-  async initialize(projectId: string, feeCollector?: PublicKey): Promise<string> {
-    try {
-      const airdropPDA = await this.getAirdropPDA();
-      console.log(airdropPDA);
-      const config = await this.getContractInfo();
-      console.log(config);
-      return airdropPDA.toString();
-    } catch (error) {
-      const owner = this.wallet.publicKey;
-      const res = await this.invokeInstruction(
-        'initialize',
-        {
-          // storage: storagePDA,
-          // authority: this.wallet.publicKey
-        },
-        [projectId, owner, feeCollector || PublicKey.default]
-      );
-      console.log(res);
-      const airdropPDA = await this.getAirdropPDA();
-      return airdropPDA.toString();
-    }
-  }
-
-  async setBaseParams(tokenAddress: string, startTime: number, endTime: number, signer: string) {
-    const start = new anchor.BN(startTime),
-      end = new anchor.BN(endTime);
-    console.log(start, end, tokenAddress, signer);
-    await this.invokeInstruction('setBaseParams', {}, [new PublicKey(tokenAddress), start, end, new PublicKey(signer)]);
-  }
-
-  async togglePause() {
-    await this.invokeInstruction('togglePause', {}, [this.projectId]);
-  }
-
-  async getFeeInfo() {
-    const airdropPDA = await this.getAirdropPDA();
-    const config = await this.fetchAccountData('airdrop', airdropPDA);
-    return {
-      feeToken: config.feeToken.toString(),
-      feeCollector: config.feeCollector.toString()
-    };
-  }
-
-  async claim(
-    data: {
-      recipient: string;
-      data: string;
-      claimId: string;
-      signature: string;
-      extraData?: string;
-      unlockingAt: number;
-      value: string;
-      hash: string;
-    }[]
-  ) {
-    const config = await this.getContractInfo();
-
-    const feeCollectorStoragePDA = await this.FeeCollector.getStoragePDA();
-    const feePDA = await this.FeeCollector.getProjectFeePDA();
-    const airdropPDA = await this.getAirdropPDA();
-    const tokenVersion = await fetchTokenVersion(config.token, {
-      clusterOrEndpoint: this.chainId
-    });
-
-    const authorityATA = await getOrCreateAssociatedTokenAccount({
-      connection: this.connection,
-      payer: this.wallet.publicKey,
-      mint: new PublicKey(config.token),
-      owner: new PublicKey(this.wallet.publicKey),
-      signTransaction: (this.wallet as any).signTransaction,
-      programId: tokenVersion?.programId || TOKEN_2022_PROGRAM_ID
-    });
-
-    let lastHash = '';
-    // solana max transaction size of 1232
-    for (const claim of data) {
-      const tx = new anchor.web3.Transaction();
-      tx.add(
-        anchor.web3.Ed25519Program.createInstructionWithPublicKey({
-          publicKey: new PublicKey(config.signer).toBytes(),
-          message: Uint8Array.from(hexStrToU8Array(claim.hash)),
-          signature: new Uint8Array(hexStrToU8Array(claim.signature))
-        })
-      );
-
-      const claimPDA = await this.getClaimPDA(claim.claimId);
-
-      const decodedData = {
-        claimableTimestamp: new anchor.BN(claim.unlockingAt),
-        claimableAmount: new anchor.BN(claim.value)
-      };
-
-      tx.add(
-        await this.program.methods
-          .claim(
-            this.projectId,
-            new Uint8Array(hexStrToU8Array(claim.claimId)),
-            [],
-            decodedData,
-            Buffer.from(hexStrToU8Array(claim.signature))
-          )
-          .accountsPartial({
-            authority: this.wallet.publicKey,
-            airdrop: airdropPDA,
-            claim: claimPDA,
-            authorityAta: authorityATA.address,
-            tokenMint: new PublicKey(config.token),
-            feeCollectorStorage: feeCollectorStoragePDA,
-            feeCollectorVault: null,
-            fee: feePDA,
-            authorityFeeAta: null,
-            tokenProgram: tokenVersion?.programId || TOKEN_2022_PROGRAM_ID,
-            feeTokenProgram: null,
-            feeTokenMint: null
-          })
-          .transaction()
-      );
-
-      const hash = await this.program.provider.sendAndConfirm?.(tx, [], {
-        commitment: 'finalized'
-      });
-
-      lastHash = hash!;
-    }
-
-    return lastHash;
-  }
-}

package/src/airdrop/contracts/solana/FeeCollectorClient.ts

@@ -1,43 +0,0 @@
-import { FeeCollector } from './fee_collector';
-import { SolanaContractClientBase, SolanaContractInfo } from './SolanaContractClient';
-import IDL from './fee_collector.json';
-import { PublicKey } from '@solana/web3.js';
-import * as anchor from '@coral-xyz/anchor';
-
-export class FeeCollectorClient extends SolanaContractClientBase<FeeCollector> {
-  projectId: string;
-  constructor(options: SolanaContractInfo) {
-    super({
-      ...options,
-      idl: IDL
-    });
-    this.projectId = options.projectId;
-  }
-
-  async getStoragePDA(): Promise<PublicKey> {
-    const [storagePDA] = await this.findProgramAddress([anchor.utils.bytes.utf8.encode('storage')]);
-
-    return storagePDA;
-  }
-
-  async getProjectFeePDA(): Promise<PublicKey> {
-    const [projectFeePDA] = await this.findProgramAddress([
-      anchor.utils.bytes.utf8.encode('fee'),
-      anchor.utils.bytes.utf8.encode(this.projectId)
-    ]);
-    return projectFeePDA;
-  }
-
-  async setDefaultFee(fee: string) {
-    return this.invokeInstruction('setDefaultFee', {}, [new anchor.BN(fee)]);
-  }
-
-  async getClaimFee(tokenAmount: string): Promise<bigint> {
-    try {
-      const fee = await this.invokeView('getFee', [this.projectId, new anchor.BN(tokenAmount)]);
-      return BigInt(fee);
-    } catch (error) {
-      return BigInt(0);
-    }
-  }
-}

package/src/airdrop/contracts/solana/SignatureAirdropService.ts

@@ -1,51 +0,0 @@
-import { AirdropSignatureClient } from './AirdropSignatureClient';
-import { SolanaContractInfo } from './SolanaContractClient';
-
-export class SignatureAirdropService {
-  options: SolanaContractInfo;
-  constructor(options: SolanaContractInfo) {
-    this.options = options;
-  }
-
-  private get airdropClient(): AirdropSignatureClient {
-    if (!this.options) {
-      throw new Error('options is empty');
-    }
-
-    return new AirdropSignatureClient(this.options);
-  }
-
-  async getVersion() {
-    return this.airdropClient.getVersion();
-  }
-
-  async getClaimFee(address: string, amount: bigint): Promise<bigint> {
-    const fee = await this.airdropClient.getClaimFee(amount);
-    return fee;
-  }
-
-  async batchFetchClaimed(userClaimIds: string[]): Promise<boolean[]> {
-    const res = await this.airdropClient.batchFetchClaimed(userClaimIds);
-    return res;
-  }
-
-  async getPaused() {
-    return this.airdropClient.getPaused();
-  }
-
-  async claim(
-    data: {
-      recipient: string;
-      claimId: string;
-      data: string;
-      signature: string;
-      extraData?: string;
-      unlockingAt: number;
-      value: string;
-      hash: string;
-    }[],
-    recipient?: string
-  ) {
-    return this.airdropClient.claim(data);
-  }
-}

package/src/airdrop/contracts/solana/SolanaContractClient.ts

@@ -1,126 +0,0 @@
-import { Program, AnchorProvider, setProvider, Wallet, Idl } from '@coral-xyz/anchor';
-import {
-  AllAccountsMap,
-  AllInstructions,
-  IdlAccounts,
-  MakeMethodsNamespace
-} from '@coral-xyz/anchor/dist/cjs/program/namespace/types';
-import { Cluster, clusterApiUrl, Commitment, Connection, PublicKey, Signer } from '@solana/web3.js';
-
-export interface SolanaContractInfo {
-  projectId: string;
-  chainId?: string;
-  idl?: any;
-  token?: string;
-  walletClient: Wallet;
-}
-
-export abstract class SolanaContractClientBase<T extends Idl = Idl> {
-  protected program: Program<T>;
-  protected connection: Connection;
-  protected wallet: Wallet;
-  protected chainId: string;
-
-  constructor(contractInfo: SolanaContractInfo) {
-    console.log(contractInfo);
-    const { idl, walletClient, chainId } = contractInfo;
-    this.chainId = chainId || 'mainnet-beta';
-
-    this.connection = this.getConnection(chainId);
-    this.wallet = walletClient;
-
-    const provider = new AnchorProvider(this.connection, this.wallet, { commitment: 'confirmed' });
-    setProvider(provider);
-
-    this.program = new Program(idl, provider);
-  }
-
-  getConnection(endpoint?: string) {
-    const apiUrl = clusterApiUrl((endpoint as Cluster) ?? 'mainnet-beta');
-
-    const conn = new Connection(apiUrl);
-    return conn;
-  }
-
-  protected async findProgramAddress(
-    seeds: Array<Buffer | Uint8Array>,
-    programId?: PublicKey
-  ): Promise<[PublicKey, number]> {
-    return await PublicKey.findProgramAddressSync(seeds, programId || new PublicKey(this.program.idl.address));
-  }
-
-  async fetchAccountData<A extends keyof AllAccountsMap<T>>(
-    accountName: A,
-    address: PublicKey | string,
-    commitment?: Commitment
-  ): Promise<IdlAccounts<T>[A]> {
-    try {
-      if (!this.program.account[accountName]) {
-        throw new Error(`Account ${String(accountName)} not found in program`);
-      }
-
-      const account = await this.program.account[accountName].fetch(address, commitment);
-      return account as IdlAccounts<T>[A];
-    } catch (error) {
-      console.error(`Error fetching account ${String(accountName)}:`, error);
-      throw error;
-    }
-  }
-
-  async invokeView<M extends keyof MakeMethodsNamespace<T, AllInstructions<T>>>(
-    methodName: M,
-    args: Parameters<MakeMethodsNamespace<T, AllInstructions<T>>[M]>
-  ): Promise<any> {
-    try {
-      if (!this.program.methods[methodName]) {
-        throw new Error(`Method ${methodName} not found in program`);
-      }
-
-      const result = await this.program.methods[methodName](...args).view();
-
-      return result;
-    } catch (error) {
-      console.error(`Error invoking view method ${methodName}:`, error);
-      throw error;
-    }
-  }
-
-  async invokeInstruction<M extends keyof MakeMethodsNamespace<T, AllInstructions<T>>>(
-    methodName: M,
-    accounts: any,
-    args: any,
-    options?: { signers?: Signer[] }
-  ): Promise<string> {
-    if (!this.program.methods[methodName]) {
-      throw new Error(`Method ${methodName} not found in program`);
-    }
-    let instruction = this.program.methods[methodName](...args).accounts(accounts);
-
-    if (options?.signers?.length) {
-      instruction = instruction.signers(options.signers);
-    }
-
-    const tx = await instruction.rpc();
-
-    await this.confirmTransaction(tx);
-    console.log(tx);
-
-    return tx;
-  }
-
-  async confirmTransaction(tx: string): Promise<string> {
-    const latestBlockhash = await this.connection.getLatestBlockhash();
-    await this.connection.confirmTransaction(
-      {
-        signature: tx,
-        blockhash: latestBlockhash.blockhash,
-        lastValidBlockHeight: latestBlockhash.lastValidBlockHeight
-      },
-      'finalized'
-    );
-    return tx;
-  }
-  // protected abstract getProgramAccount(accountName: string, address: PublicKey): Promise<any>;
-
-  // protected abstract getEventLogs(signature: string, eventName: string): Promise<any[]>;
-}