@jpool/bond-sdk 0.1.0-next.1 → 0.1.0-next.3

package/src/client.ts

@@ -1,568 +0,0 @@
-import type { Wallet } from '@coral-xyz/anchor'
-import type {
-  Keypair,
-  ParsedTransactionWithMeta,
-  TransactionInstruction } from '@solana/web3.js'
-import type { Config, EpochHistoryItem, InitializeProps, RegisterValidatorProps, TopUpCollateralProps, TransactionHistoryItem, ValidatorBondAccount, WithdrawCollateralProps, WithdrawCompensationProps } from './types'
-import type { Jbond } from './types/jbond'
-import { AnchorProvider, BN, Program } from '@coral-xyz/anchor'
-import {
-  Connection,
-  LAMPORTS_PER_SOL,
-  PublicKey,
-  SystemProgram,
-  Transaction,
-} from '@solana/web3.js'
-import bs58 from 'bs58'
-import { slotToEpoch } from './helpers'
-import IDL from './idl/jbond.json'
-import { BondTransactionType } from './types'
-import { NodeWallet } from './utils/wallet'
-
-export class JBondClient {
-  connection: Connection
-  program: Program<Jbond>
-  provider: AnchorProvider
-  config: Config
-
-  constructor(config: Config, wallet?: Wallet) {
-    this.config = config
-    this.connection = new Connection(config.rpcUrl, 'confirmed')
-
-    // If keypair is provided, use it. Otherwise, create a dummy keypair
-    // since we're only building instructions
-    this.provider = new AnchorProvider(
-      this.connection,
-      // @ts-expect-error support anonymous
-      wallet ?? { publicKey: PublicKey.default },
-      AnchorProvider.defaultOptions())
-
-    this.program = new Program(IDL as any, this.provider)
-  }
-
-  /**
-   * Creates an instance of `JBondClient` using a provided connection and wallet.
-   */
-  static fromWallet(config: Config, wallet?: Wallet): JBondClient {
-    return new this(config, wallet)
-  }
-
-  /**
-   * Creates an instance of `JBondClient` using the provided connection and keypair.
-   */
-  static fromKeypair(config: Config, keypair: Keypair): JBondClient {
-    return JBondClient.fromWallet(config, new NodeWallet(keypair))
-  }
-
-  // Get PDA for global state
-  getGlobalStatePDA(): [PublicKey, number] {
-    return PublicKey.findProgramAddressSync(
-      [Buffer.from('global_state')],
-      this.program.programId,
-    )
-  }
-
-  // Get PDA for validator bond account
-  getValidatorBondPDA(
-    voteAccount: PublicKey,
-  ): [PublicKey, number] {
-    return PublicKey.findProgramAddressSync(
-      [
-        Buffer.from('validator_bond'),
-        voteAccount.toBuffer(),
-      ],
-      this.program.programId,
-    )
-  }
-
-  // Build initialize instruction
-  async buildInitializeInstruction(props: InitializeProps): Promise<TransactionInstruction> {
-    const [globalState] = this.getGlobalStatePDA()
-    return this.program.methods
-      .initialize()
-      .accountsStrict({
-        globalState,
-        authority: props.authority,
-        reserve: this.config.reserveAddress,
-        systemProgram: SystemProgram.programId,
-      })
-      .instruction()
-  }
-
-  // Build register validator instruction
-  async buildRegisterValidatorInstruction(
-    props: RegisterValidatorProps,
-  ): Promise<TransactionInstruction> {
-    const { creator, identity, voteAccount, initialCollateral, withdrawalAuthority } = props
-    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount)
-
-    const accountInfo = await this.connection.getAccountInfo(validatorBondAccountAddress)
-    if (accountInfo) {
-      throw new Error('Validator bond account already exists')
-    }
-    const [globalState] = this.getGlobalStatePDA()
-
-    const collateralLamports = new BN(initialCollateral * LAMPORTS_PER_SOL)
-
-    return this.program.methods
-      .bondInit(collateralLamports, withdrawalAuthority ?? null)
-      .accountsStrict({
-        creator,
-        globalState,
-        validatorBondAccount: validatorBondAccountAddress,
-        identity,
-        voteAccount,
-        systemProgram: SystemProgram.programId,
-      })
-      .instruction()
-  }
-
-  // Build top up collateral instruction
-  buildTopUpCollateralInstruction(
-    props: TopUpCollateralProps,
-  ): Promise<TransactionInstruction> {
-    const { user, voteAccount, amount } = props
-    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount)
-    const amountLamports = new BN(amount * LAMPORTS_PER_SOL)
-
-    return this.program.methods
-      .bondTopUp(amountLamports)
-      .accountsStrict({
-        validatorBondAccount: validatorBondAccountAddress,
-        depositor: user,
-        systemProgram: SystemProgram.programId,
-      })
-      .instruction()
-  }
-
-  async buildWithdrawCollateralInstruction(
-    props: WithdrawCollateralProps,
-  ): Promise<TransactionInstruction> {
-    const { withdrawalAuthority: user, voteAccount, destination, amount } = props
-    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount)
-    const amountLamports = new BN(amount * LAMPORTS_PER_SOL)
-
-    return this.program.methods
-      .bondWithdraw(amountLamports)
-      .accountsStrict({
-        validatorBondAccount: validatorBondAccountAddress,
-        withdrawalAuthority: user,
-        destination,
-        systemProgram: SystemProgram.programId,
-      })
-      .instruction()
-  }
-
-  // Build withdraw compensation instruction
-  buildWithdrawCompensationInstruction(
-    props: WithdrawCompensationProps,
-  ): Promise<TransactionInstruction> {
-    const { authority, voteAccount, amount } = props
-    const [globalState] = this.getGlobalStatePDA()
-    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount)
-    const amountLamports = new BN(amount * LAMPORTS_PER_SOL)
-
-    return this.program.methods
-      .withdrawCompensation(amountLamports)
-      .accountsStrict({
-        globalState,
-        validatorBondAccount: validatorBondAccountAddress,
-        reserve: this.config.reserveAddress,
-        authority,
-        systemProgram: SystemProgram.programId,
-      })
-      .instruction()
-  }
-
-  // Build multiple withdraw compensation instructions
-  buildWithdrawCompensationsInstructions(
-    authority: PublicKey,
-    withdrawals: Array<{ voteAccount: PublicKey, amount: number }>,
-  ): Promise<TransactionInstruction[]> {
-    return Promise.all(
-      withdrawals.map(({ voteAccount, amount }) =>
-        this.buildWithdrawCompensationInstruction({ authority, voteAccount, amount }),
-      ),
-    )
-  }
-
-  // Get validator bond account state
-  async getValidatorBondAccount(
-    voteAccount: PublicKey,
-  ): Promise<ValidatorBondAccount | null> {
-    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount)
-
-    try {
-      const account = await (
-        this.program.account as any
-      ).validatorBondAccount.fetch(validatorBondAccountAddress)
-
-      return {
-        identity: account.identity.toString(),
-        voteAccount: account.voteAccount.toString(),
-        withdrawalAuthority: account.withdrawalAuthority ? account.withdrawalAuthority.toString() : null,
-        totalWithdrawn: account.totalWithdrawn.toNumber() / LAMPORTS_PER_SOL,
-        lastWithdrawalEpoch: account.lastWithdrawalEpoch.toNumber(),
-        isActive: account.isActive,
-        createdAt: account.createdAt.toNumber() * 1000, // TODO
-        bump: account.bump,
-      }
-    } catch {
-      return null
-    }
-  }
-
-  /**
-   * Get the collateral balance of a validator bond account
-   * @param voteAccount - The vote account public key
-   * @returns The available collateral balance in SOL (excluding rent-exempt amount)
-   */
-  async getValidatorCollateralBalance(voteAccount: PublicKey): Promise<number> {
-    const [validatorBondAccountAddress] = this.getValidatorBondPDA(voteAccount)
-
-    const accountInfo = await this.connection.getAccountInfo(validatorBondAccountAddress)
-    if (!accountInfo) {
-      return 0
-    }
-
-    const rentExempt = await this.connection.getMinimumBalanceForRentExemption(
-      accountInfo.data.length,
-    )
-
-    const availableBalance = Math.max(0, accountInfo.lamports - rentExempt)
-    return availableBalance / LAMPORTS_PER_SOL
-  }
-
-  // Get global state state
-  async getGlobalState(): Promise<{
-    authority: string
-    totalValidators: number
-    totalWithdrawn: number
-  } | null> {
-    const [globalState] = this.getGlobalStatePDA()
-
-    try {
-      const account = await (
-        this.program.account as any
-      ).globalState.fetch(globalState)
-
-      return {
-        authority: account.authority.toString(),
-        totalValidators: account.totalValidators,
-        totalWithdrawn: account.totalWithdrawn.toNumber() / LAMPORTS_PER_SOL,
-      }
-    } catch {
-      return null
-    }
-  }
-
-  // Get current epoch
-  async getCurrentEpoch(): Promise<number> {
-    const epochInfo = await this.connection.getEpochInfo()
-    return epochInfo.epoch
-  }
-
-  // Helper methods for backward compatibility (can be removed if not needed)
-  async initialize(authority?: PublicKey): Promise<string> {
-    const authorityPubkey = authority || this.provider.wallet.publicKey
-    const ix = await this.buildInitializeInstruction({ authority: authorityPubkey })
-    const tx = await this.provider.sendAndConfirm(
-      new Transaction().add(ix),
-      [],
-    )
-    return tx
-  }
-
-  // Note: this method will be removed or changed in the future (CLI only)
-  async registerValidator(
-    voteAccount: PublicKey,
-    initialCollateral: number,
-    withdrawalAuthority?: PublicKey,
-    identity?: PublicKey,
-  ): Promise<string> {
-    const identityPubkey = identity ?? this.provider.wallet.publicKey
-    const ix = await this.buildRegisterValidatorInstruction(
-      { creator: identityPubkey, identity: identityPubkey, voteAccount, initialCollateral, withdrawalAuthority },
-    )
-    const tx = await this.provider.sendAndConfirm(
-      new Transaction().add(ix),
-      [],
-    )
-    return tx
-  }
-
-  async topUpCollateral(
-    voteAccount: PublicKey,
-    amount: number,
-    validator?: PublicKey,
-  ): Promise<string> {
-    const userPubkey = validator ?? this.provider.wallet.publicKey
-    const ix = await this.buildTopUpCollateralInstruction(
-      { user: userPubkey, voteAccount, amount },
-    )
-    const tx = await this.provider.sendAndConfirm(
-      new Transaction().add(ix),
-      [],
-    )
-    return tx
-  }
-
-  async withdrawCollateral(
-    voteAccount: PublicKey,
-    destination: PublicKey,
-    amount: number,
-    withdrawalAuthority?: PublicKey,
-  ): Promise<string> {
-    const authorityPubkey = withdrawalAuthority ?? this.provider.wallet.publicKey
-    const ix = await this.buildWithdrawCollateralInstruction(
-      { withdrawalAuthority: authorityPubkey, voteAccount, destination, amount },
-    )
-    const tx = await this.provider.sendAndConfirm(
-      new Transaction().add(ix),
-      [],
-    )
-    return tx
-  }
-
-  async claimCompensation(
-    voteAccount: PublicKey,
-    amount: number,
-    authority?: PublicKey,
-  ): Promise<string> {
-    const authorityPubkey = authority ?? this.provider.wallet.publicKey
-    const ix = await this.buildWithdrawCompensationInstruction(
-      { authority: authorityPubkey, voteAccount, amount },
-    )
-    const tx = await this.provider.sendAndConfirm(
-      new Transaction().add(ix),
-      [],
-    )
-    return tx
-  }
-
-  /**
-   * Get transaction history grouped by epochs
-   * @param voteAccount - The vote account to get history for
-   * @param epochsCount - Number of recent epochs to return (default: 10)
-   * @returns Array of epoch history items sorted by epoch (descending)
-   */
-  async getHistoryGroupedByEpochs(
-    voteAccount: PublicKey,
-    epochsCount: number = 10,
-  ): Promise<EpochHistoryItem[]> {
-    const currentEpoch = await this.getCurrentEpoch()
-    const fullHistory = await this.getFullHistory(voteAccount)
-
-    const epochMap = new Map<number, EpochHistoryItem>()
-
-    for (const item of fullHistory) {
-      if (item.epoch < currentEpoch - epochsCount + 1) {
-        continue
-      }
-      if (!epochMap.has(item.epoch)) {
-        epochMap.set(item.epoch, {
-          epoch: item.epoch,
-          deposits: 0,
-          withdrawals: 0,
-          balanceChange: 0,
-          signatures: [],
-        })
-      }
-
-      const epochData = epochMap.get(item.epoch)!
-
-      if (item.type === 'deposit') {
-        epochData.deposits += item.amount
-      } else if (item.type === 'withdrawal') {
-        epochData.withdrawals += item.amount
-      }
-
-      if (!epochData.signatures.includes(item.signature)) {
-        epochData.signatures.push(item.signature)
-      }
-    }
-
-    for (const epochData of epochMap.values()) {
-      epochData.balanceChange = epochData.deposits - epochData.withdrawals
-    }
-
-    const result = [...epochMap.values()].toSorted((a, b) => b.epoch - a.epoch)
-
-    return result
-  }
-
-  async getHistory(
-    voteAccount: PublicKey,
-    options?: {
-      cluster?: 'mainnet-beta' | 'testnet' | 'devnet'
-      limit?: number
-      before?: string
-      until?: string
-    },
-  ): Promise<TransactionHistoryItem[]> {
-    const [ValidatorBondAccount] = this.getValidatorBondPDA(voteAccount)
-
-    const signatures = await this.connection.getSignaturesForAddress(
-      ValidatorBondAccount,
-      {
-        limit: options?.limit || 1000,
-        before: options?.before,
-        until: options?.until,
-      },
-    )
-
-    const signatureStrings = signatures.map(sig => sig.signature)
-
-    const BATCH_SIZE = 100
-    const allTransactions: (ParsedTransactionWithMeta | null)[] = []
-
-    for (let i = 0; i < signatureStrings.length; i += BATCH_SIZE) {
-      const batch = signatureStrings.slice(i, i + BATCH_SIZE)
-      const transactions = await this.connection.getParsedTransactions(
-        batch,
-        {
-          maxSupportedTransactionVersion: 0,
-        },
-      )
-      allTransactions.push(...transactions)
-    }
-
-    const cluster = options?.cluster || 'mainnet-beta'
-
-    const history: TransactionHistoryItem[] = []
-
-    for (const [idx, tx] of allTransactions.entries()) {
-      const sigInfo = signatures[idx]
-
-      if (!tx || !tx.meta) {
-        continue
-      }
-
-      try {
-        const slot = (tx.slot || 0)
-        const instructions = tx.transaction.message.instructions
-
-        for (const instruction of instructions) {
-          if ('programId' in instruction && instruction.programId.equals(this.program.programId)) {
-            const ixData = instruction as any
-
-            if ('parsed' in ixData && ixData.parsed) {
-              continue
-            }
-
-            const data = ixData.data
-            if (!data) {
-              continue
-            }
-
-            let type: BondTransactionType | null = null
-            let amount = 0
-
-            try {
-              const dataBuffer = bs58.decode(data)
-
-              if (dataBuffer.length >= 16) {
-                const discriminator = dataBuffer.slice(0, 8)
-
-                const bondInitDiscriminator = this.getInstructionDiscriminator('bondInit')
-                const bondTopUpDiscriminator = this.getInstructionDiscriminator('bondTopUp')
-                const withdrawCompensationDiscriminator = this.getInstructionDiscriminator('withdrawCompensation')
-                const bondWithdrawDiscriminator = this.getInstructionDiscriminator('bondWithdraw')
-
-                const amountBytes = dataBuffer.slice(8, 16)
-                const amountBN = new BN(amountBytes, 'le')
-                amount = amountBN.toNumber() / LAMPORTS_PER_SOL
-
-                if (Buffer.from(discriminator).equals(Buffer.from(bondInitDiscriminator))) {
-                  type = BondTransactionType.Deposit
-                } else if (Buffer.from(discriminator).equals(Buffer.from(bondTopUpDiscriminator))) {
-                  type = BondTransactionType.Deposit
-                } else if (Buffer.from(discriminator).equals(Buffer.from(withdrawCompensationDiscriminator))) {
-                  type = BondTransactionType.Compensation
-                } else if (Buffer.from(discriminator).equals(Buffer.from(bondWithdrawDiscriminator))) {
-                  type = BondTransactionType.Withdrawal
-                }
-              }
-            } catch {
-              console.warn('Failed to decode instruction data')
-            }
-
-            if (type && amount > 0) {
-              let beforeBalance: number | undefined
-              let afterBalance: number | undefined
-
-              // Find the validator bond account in the account keys
-              const accountIndex = tx.transaction.message.accountKeys.findIndex(
-                key => key.pubkey.equals(ValidatorBondAccount),
-              )
-
-              if (accountIndex !== -1 && tx.meta.preBalances && tx.meta.postBalances) {
-                beforeBalance = Number(tx.meta.preBalances[accountIndex] || 0) / LAMPORTS_PER_SOL
-                afterBalance = Number(tx.meta.postBalances[accountIndex] || 0) / LAMPORTS_PER_SOL
-              }
-
-              history.push({
-                signature: sigInfo!.signature,
-                slot,
-                epoch: slotToEpoch(slot, cluster),
-                type,
-                amount,
-                beforeBalance,
-                afterBalance,
-              })
-            }
-          }
-        }
-      } catch (error) {
-        console.error(`Error processing transaction ${sigInfo!.signature}:`, error)
-      }
-    }
-
-    return history.toSorted((a, b) => b.slot - a.slot)
-  }
-
-  // Helper method to get paginated history
-  async getFullHistory(
-    voteAccount: PublicKey,
-    pageSize: number = 100,
-  ): Promise<TransactionHistoryItem[]> {
-    const allHistory: TransactionHistoryItem[] = []
-    let before: string | undefined
-
-    while (true) {
-      const batch = await this.getHistory(voteAccount, {
-        limit: pageSize,
-        before,
-      })
-
-      if (batch.length === 0) {
-        break
-      }
-
-      allHistory.push(...batch)
-
-      // Get the signature of the last transaction for pagination
-      before = batch.at(-1)?.signature
-
-      // If we got less than the page size, we've reached the end
-      if (batch.length < pageSize) {
-        break
-      }
-    }
-
-    return allHistory
-  }
-
-  private getInstructionDiscriminator(instructionName: string): Uint8Array {
-    const instruction = this.program.idl.instructions.find(ix => ix.name === instructionName)
-    if (!instruction) {
-      throw new Error(`Instruction ${instructionName} not found in IDL`)
-    }
-
-    if (!instruction.discriminator || !Array.isArray(instruction.discriminator)) {
-      throw new Error(`Discriminator not found for instruction ${instructionName}`)
-    }
-
-    return new Uint8Array(instruction.discriminator)
-  }
-}

package/src/common.ts

@@ -1,2 +0,0 @@
-export const PROGRAM_ID = '4a3YovKEfm4jWhczCzJciHXL1xVkXWfGQjRCaMft7M4G'
-export const RESERVE_ADDRESS = '61mS9nEir6jx6cvte6NzQpyrFk3Fj4krMNLuHhi4tjJz'

package/src/config.ts

@@ -1,31 +0,0 @@
-import type { Config } from './types'
-import { readFileSync } from 'node:fs'
-import { Keypair, PublicKey } from '@solana/web3.js'
-import { PROGRAM_ID, RESERVE_ADDRESS } from './common'
-
-export function loadConfig(): Config {
-  const rpcUrl = process.env.SOLANA_RPC_URL || 'https://api.devnet.solana.com'
-  const programId = new PublicKey(
-    PROGRAM_ID || '4a3YovKEfm4jWhczCzJciHXL1xVkXWfGQjRCaMft7M4G',
-  )
-  const reserveAddress = new PublicKey(
-    RESERVE_ADDRESS
-    || '61mS9nEir6jx6cvte6NzQpyrFk3Fj4krMNLuHhi4tjJz',
-  )
-
-  return {
-    rpcUrl,
-    programId,
-    reserveAddress,
-  }
-}
-
-export function loadKeypair(keypairPath: string): Keypair {
-  try {
-    const keypairString = readFileSync(keypairPath, 'utf8')
-    const keypairData = JSON.parse(keypairString)
-    return Keypair.fromSecretKey(new Uint8Array(keypairData))
-  } catch (error) {
-    throw new Error(`Failed to load keypair from ${keypairPath}: ${error}`)
-  }
-}

package/src/helpers.ts

@@ -1,7 +0,0 @@
-const SLOTS_PER_EPOCH_MAINNET = 432_000
-const SLOTS_PER_EPOCH_DEVNET = 400_000
-
-export function slotToEpoch(slot: number, cluster: 'mainnet-beta' | 'testnet' | 'devnet'): number {
-  const slotsPerEpoch = cluster === 'mainnet-beta' ? SLOTS_PER_EPOCH_MAINNET : SLOTS_PER_EPOCH_DEVNET
-  return Math.floor(slot / slotsPerEpoch)
-}