@sign-global/tokentable 0.4.0 → 0.4.1-beta.0

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

@@ -0,0 +1,234 @@
+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 { getOrCreateAssociatedTokenAccount, hexStrToU8Array } from '../../../utils';
+
+export class AirdropSignatureClient extends SolanaContractClientBase<FungibleTokenDistributorSolana> {
+  projectId: string;
+  constructor(options: SolanaContractInfo) {
+    super({
+      ...options,
+      idl: IDL
+    });
+    this.projectId = options.projectId;
+  }
+
+  getVersion() {
+    return '1.0.0';
+  }
+
+  get FeeCollector() {
+    return new FeeCollectorClient({
+      projectId: this.projectId,
+      walletClient: this.wallet,
+      chainId: this.chainId
+    });
+  }
+
+  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();
+    console.log(airdropPDA);
+    const config: any = await this.fetchAccountData('airdrop', airdropPDA);
+    console.log(config);
+
+    return {
+      version: '1.0.0' as string,
+      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);
+      console.log(claimData, 'claimData');
+      return true;
+    } 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 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 userFeePDA = await this.FeeCollector.getUserFeePDA();
+    const airdropPDA = await this.getAirdropPDA();
+    const vaultPDA = await this.getVaultPDA();
+
+    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: TOKEN_2022_PROGRAM_ID
+    });
+
+    const tx = new anchor.web3.Transaction();
+
+    for (const claim of data) {
+      tx.add(
+        anchor.web3.Ed25519Program.createInstructionWithPublicKey({
+          publicKey: new PublicKey(config.signer).toBytes(),
+          message: Uint8Array.from(hexStrToU8Array(claim.hash)),
+          signature: new Uint8Array(hexStrToU8Array(claim.signature))
+        })
+      );
+
+      console.log(
+        anchor.web3.Ed25519Program.programId.toString(),
+        {
+          publicKey: new PublicKey(config.signer).toBytes(),
+          message: Uint8Array.from(hexStrToU8Array(claim.hash)),
+          signature: new Uint8Array(hexStrToU8Array(claim.signature))
+        },
+        'sign'
+      );
+
+      const claimPDA = await this.getClaimPDA(claim.claimId);
+
+      const decodedData = {
+        claimableTimestamp: new anchor.BN(claim.unlockingAt),
+        claimableAmount: new anchor.BN(claim.value)
+      };
+      console.log(
+        airdropPDA.toString(),
+        claimPDA,
+        this.projectId,
+        new Uint8Array(hexStrToU8Array(claim.claimId)),
+        [],
+        decodedData,
+        Buffer.from(hexStrToU8Array(claim.signature)),
+        'txdata'
+      );
+
+      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,
+            vault: vaultPDA,
+            authorityAta: authorityATA.address,
+            tokenMint: new PublicKey(config.token),
+            feeCollectorStorage: feeCollectorStoragePDA,
+            feeCollectorVault: null,
+            userFee: userFeePDA,
+            authorityFeeAta: null,
+            tokenProgram: TOKEN_2022_PROGRAM_ID
+          })
+          .transaction()
+      );
+      console.log(tx);
+    }
+
+    return await this.program.provider.sendAndConfirm?.(tx);
+  }
+}

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

@@ -0,0 +1,34 @@
+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 getUserFeePDA(): Promise<PublicKey> {
+    const [userFeePDA] = await this.findProgramAddress([
+      anchor.utils.bytes.utf8.encode('fee'),
+      anchor.utils.bytes.utf8.encode(this.projectId)
+    ]);
+    return userFeePDA;
+  }
+
+  async setDefaultFee(fee: string) {
+    return this.invokeInstruction('setDefaultFee', {}, [new anchor.BN(fee)]);
+  }
+}

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

@@ -0,0 +1,77 @@
+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();
+  }
+
+  feeCollectors = async (address: string) => {
+    // const deployerClient = await this.getDeployerClient();
+    // return await deployerClient.feeCollectors(address);
+    return '';
+  };
+
+  feeTokens = async (address: string) => {
+    // const deployerClient = await this.getDeployerClient();
+    // return await deployerClient.feeTokens(address);
+    return '';
+  };
+
+  async getFeelessThreshold() {
+    // return this.airdropClient.getFeelessThreshold();
+  }
+
+  async getDeployer() {
+    return '';
+  }
+
+  async getClaimFee(address: string, amount: bigint): Promise<bigint | undefined> {
+    // const feeCollector = await this.feeCollectors(this.options.contractAddress as string);
+    // if (!feeCollector || feeCollector === ZERO_ADDRESS) {
+    //   return undefined;
+    // }
+    // const feeClient = this.getFeeClient(feeCollector as string);
+    // const fee = (await feeClient.getFee(address, amount)) as bigint;
+    // return fee;
+    return 0n;
+  }
+
+  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;
+    }[],
+    value?: bigint
+  ) {
+    return this.airdropClient.claim(data);
+  }
+}

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

@@ -0,0 +1,113 @@
+import { Program, AnchorProvider, setProvider, Wallet, Idl, AccountNamespace } from '@coral-xyz/anchor';
+import {
+  AllAccountsMap,
+  AllInstructions,
+  MakeMethodsNamespace
+} from '@coral-xyz/anchor/dist/cjs/program/namespace/types';
+import { Cluster, clusterApiUrl, 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(accountName: keyof AllAccountsMap<T>, address: PublicKey): Promise<T> {
+    try {
+      if (!this.program.account[accountName]) {
+        throw new Error(`Account ${accountName} not found in program`);
+      }
+
+      const account = await this.program.account[accountName].fetch(address);
+      return account as T;
+    } catch (error) {
+      console.error(`Error fetching account ${accountName}:`, error);
+      throw error;
+    }
+  }
+
+  async invokeView<M extends keyof MakeMethodsNamespace<T, AllInstructions<T>>>(
+    methodName: M,
+    args: Parameters<MakeMethodsNamespace<T, AllInstructions<T>>[M]>
+  ): Promise<ReturnType<MakeMethodsNamespace<T, AllInstructions<T>>[M]>> {
+    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> {
+    const latestBlockhash = await this.connection.getLatestBlockhash();
+
+    let instruction = this.program.methods[methodName](...args).accounts(accounts);
+
+    if (options?.signers?.length) {
+      instruction = instruction.signers(options.signers);
+    }
+
+    console.log(instruction, 'in');
+
+    const tx = await instruction.rpc();
+
+    await this.connection.confirmTransaction({
+      signature: tx,
+      blockhash: latestBlockhash.blockhash,
+      lastValidBlockHeight: latestBlockhash.lastValidBlockHeight
+    });
+    console.log(tx);
+
+    return tx;
+  }
+  // protected abstract getProgramAccount(accountName: string, address: PublicKey): Promise<any>;
+
+  // protected abstract getEventLogs(signature: string, eventName: string): Promise<any[]>;
+}