@w3lib/solana-batch-call 0.4.0 → 0.6.0

package/src/swap/common.ts

@@ -0,0 +1,113 @@
+import { TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from '../constants.js'
+import { findExtension, parseMint, parseTransferFeeConfig, type AccountInfo } from '../layout.js'
+import { Bytes } from '../lp.js'
+import type { Instruction } from '../write/transaction.js'
+
+export type SolanaSwapProtocol = 'raydium-clmm' | 'orca-whirlpool' | 'raydium-cpmm' | 'raydium-amm'
+
+/** 报价时的链上环境：Clock sysvar 的时间（秒）和 epoch（Token-2022 转账手续费按 epoch 选配置；动态费率按时间衰减） */
+export interface SwapEnv {
+  timestamp: bigint
+  epoch: bigint
+}
+
+export const CLOCK_SYSVAR_ID = 'SysvarC1ock11111111111111111111111111111111'
+
+/** Clock：slot u64、epoch_start_timestamp i64、epoch u64、leader_schedule_epoch u64、unix_timestamp i64 */
+export function parseClock(data: Uint8Array): SwapEnv {
+  if (data.length < 40) throw new Error('Unexpected Clock sysvar data')
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength)
+  return { epoch: view.getBigUint64(16, true), timestamp: view.getBigInt64(32, true) }
+}
+
+/** 读到的账户：address → 账户（不存在为 null）；没读的为 undefined */
+export type AccountGetter = (address: string) => AccountInfo | null | undefined
+
+/** 池子不支持本地报价 / 兑换（跳过这个池子，原因在 plan 里能看到） */
+export class UnsupportedPool extends Error {}
+
+/** 报价还需要读这些账户（如兑换走得比预读的 tick 数组更远）：读完后重新报价 */
+export class NeedAccounts extends Error {
+  constructor(readonly addresses: string[]) {
+    super(`Need ${addresses.length} more accounts`)
+  }
+}
+
+export const U64_MAX = (1n << 64n) - 1n
+export const mulDivFloor = (a: bigint, b: bigint, d: bigint) => (a * b) / d
+export const mulDivCeil = (a: bigint, b: bigint, d: bigint) => (a * b + d - 1n) / d
+
+export function need(get: AccountGetter, address: string, what: string): AccountInfo {
+  const account = get(address)
+  if (account === undefined) throw new Error(`${what} was not loaded: ${address}`)
+  if (account === null) throw new UnsupportedPool(`${what} not found: ${address}`)
+  return account
+}
+
+/** 交易里要用的代币信息 */
+export interface SwapMint {
+  mint: string
+  program: string
+  decimals: number
+  /** 原始 mint 账户（算 Token-2022 转账手续费） */
+  account: AccountInfo
+}
+
+const EXTENSION_TRANSFER_HOOK = 14
+
+/**
+ * 解析池子里一种代币的 mint：SPL Token / Token-2022；带转账 hook（需要额外账户）的不支持。
+ * 带转账手续费的支持（按当前 epoch 的费率算）
+ */
+export function swapMint(mint: string, account: AccountInfo): SwapMint {
+  if (account.owner !== TOKEN_PROGRAM_ID && account.owner !== TOKEN_2022_PROGRAM_ID) {
+    throw new UnsupportedPool(`${mint} is not a token mint`)
+  }
+  if (account.owner === TOKEN_2022_PROGRAM_ID) {
+    const hook = findExtension(account.data, EXTENSION_TRANSFER_HOOK)
+    if (hook && hook.length >= 64 && hook.subarray(32, 64).some((b) => b !== 0)) {
+      throw new UnsupportedPool(`${mint} has a transfer hook, which is not supported`)
+    }
+  }
+  return { mint, program: account.owner, decimals: parseMint(account.data).decimals, account }
+}
+
+/** Token-2022 转账手续费：ceil(amount × 费率 / 10000)，不超过单笔上限；SPL Token 为 0（与 Token-2022 的 calculate_epoch_fee 一致） */
+export function transferFee(mint: SwapMint, amount: bigint, epoch: bigint): bigint {
+  if (mint.program !== TOKEN_2022_PROGRAM_ID || amount === 0n) return 0n
+  const config = parseTransferFeeConfig(mint.account.data)
+  if (!config) return 0n
+  const fee = epoch >= config.newer.epoch ? config.newer : config.older
+  if (fee.basisPoints === 0) return 0n
+  const raw = (amount * BigInt(fee.basisPoints) + 9999n) / 10000n
+  return raw < fee.maximumFee ? raw : fee.maximumFee
+}
+
+/** 一跳的报价：用户付出 amountIn（含输入代币的转账手续费），实际收到 amountOut（已扣输出代币的转账手续费） */
+export interface HopQuote {
+  amountIn: bigint
+  amountOut: bigint
+  /** 交易里要传的额外账户（tick 数组等），由各协议的 instruction 使用 */
+  accounts: string[]
+  /** 集中流动性：穿过的已初始化 tick 数、成交的限价单 tick 数（Raydium） */
+  crossed?: number
+  orders?: number
+}
+
+/** 一个可以兑换的池子（已解析） */
+export interface SwapPool {
+  protocol: SolanaSwapProtocol
+  address: string
+  mint0: string
+  mint1: string
+  /** 报价要读的账户（池子账户之外）：按方向（zeroForOne：卖出 mint0） */
+  accounts(zeroForOne: boolean): string[]
+  /** 本地报价（只用读到的账户，纯计算）；池子不支持时抛 UnsupportedPool */
+  quote(get: AccountGetter, amountIn: bigint, zeroForOne: boolean, env: SwapEnv): HopQuote
+  /** 兑换指令：从 input 代币账户卖出 amountIn，output 代币账户至少收到 minOut */
+  instruction(get: AccountGetter, owner: string, input: string, output: string, zeroForOne: boolean, quote: HopQuote, minOut: bigint): Instruction
+  /** 两种代币的 mint 信息（报价后可用） */
+  mints(get: AccountGetter): [SwapMint, SwapMint]
+}
+
+export { Bytes }

package/src/swap/cpmm.ts

@@ -0,0 +1,132 @@
+/**
+ * Raydium CPMM 的兑换：swap_base_input。报价照搬程序（raydium-cp-swap curve/calculator.rs）：
+ * 交易费（含创建者手续费，从输入或输出扣）向上取整，恒定乘积向下取整，储备 = 金库余额 − 协议 / 基金 / 创建者手续费；输入输出的 Token-2022 转账手续费都算
+ */
+import { parseTokenAccount, type AccountInfo } from '../layout.js'
+import { RAYDIUM_CPMM_AUTHORITY, RAYDIUM_CPMM_PROGRAM_ID } from '../lp.js'
+import { Writer, anchorIx, r, w } from '../liquidity/common.js'
+import type { Instruction } from '../write/transaction.js'
+import { Bytes, UnsupportedPool, mulDivCeil, mulDivFloor, need, swapMint, transferFee, type AccountGetter, type HopQuote, type SwapEnv, type SwapMint, type SwapPool } from './common.js'
+
+const FEE_DENOMINATOR = 1_000_000n
+const POOL_SIZE = 637
+
+interface CpmmState {
+  address: string
+  config: string
+  vault0: string
+  vault1: string
+  mint0: string
+  mint1: string
+  observation: string
+  status: number
+  openTime: bigint
+  reserved0: bigint
+  reserved1: bigint
+  creatorFeeOn: number
+  creatorFeeEnabled: boolean
+}
+
+/** PoolState：amm_config 8、vault 72 / 104、mint 168 / 200、observation 296、status 329、协议 / 基金手续费 341…、open_time 373、creator_fee_on 389、enable_creator_fee 390、创建者手续费 397 / 405 */
+export function parseCpmmPool(account: AccountInfo): CpmmState | null {
+  if (account.owner !== RAYDIUM_CPMM_PROGRAM_ID || account.data.length !== POOL_SIZE) return null
+  const b = new Bytes(account.data)
+  return {
+    address: account.address,
+    config: b.key(8),
+    vault0: b.key(72),
+    vault1: b.key(104),
+    mint0: b.key(168),
+    mint1: b.key(200),
+    observation: b.key(296),
+    status: b.u8(329),
+    openTime: b.u64(373),
+    reserved0: b.u64(341) + b.u64(357) + b.u64(397),
+    reserved1: b.u64(349) + b.u64(365) + b.u64(405),
+    creatorFeeOn: b.u8(389),
+    creatorFeeEnabled: b.u8(390) !== 0,
+  }
+}
+
+/** 恒定乘积的兑换（与程序 CurveCalculator::swap_base_input 一致），返回给用户的输出（未扣转账手续费） */
+export function cpmmSwapBaseInput(
+  amountIn: bigint,
+  reserveIn: bigint,
+  reserveOut: bigint,
+  tradeFeeRate: bigint,
+  creatorFeeRate: bigint,
+  creatorFeeOnInput: boolean,
+): bigint {
+  let afterFee: bigint
+  if (creatorFeeOnInput) {
+    afterFee = amountIn - mulDivCeil(amountIn, tradeFeeRate + creatorFeeRate, FEE_DENOMINATOR)
+  } else {
+    afterFee = amountIn - mulDivCeil(amountIn, tradeFeeRate, FEE_DENOMINATOR)
+  }
+  if (afterFee < 0n) return 0n
+  const swapped = mulDivFloor(afterFee, reserveOut, reserveIn + afterFee)
+  return creatorFeeOnInput ? swapped : swapped - mulDivCeil(swapped, creatorFeeRate, FEE_DENOMINATOR)
+}
+
+export function cpmmPool(state: CpmmState): SwapPool {
+  const mints = (get: AccountGetter): [SwapMint, SwapMint] => [
+    swapMint(state.mint0, need(get, state.mint0, 'Token mint')),
+    swapMint(state.mint1, need(get, state.mint1, 'Token mint')),
+  ]
+  return {
+    protocol: 'raydium-cpmm',
+    address: state.address,
+    mint0: state.mint0,
+    mint1: state.mint1,
+    mints,
+    accounts: () => [state.config, state.vault0, state.vault1, state.mint0, state.mint1],
+    quote(get, amountIn, zeroForOne, env: SwapEnv): HopQuote {
+      // status 第 2 位（Swap）为 1 表示禁止兑换
+      if (state.status & 4) throw new UnsupportedPool('Swap is disabled on this pool')
+      if (env.timestamp < state.openTime) throw new UnsupportedPool('Pool is not open yet')
+      const [m0, m1] = mints(get)
+      const config = need(get, state.config, 'AMM config').data
+      if (config.length < 124) throw new UnsupportedPool('Unexpected AMM config')
+      const c = new Bytes(config)
+      // AmmConfig：trade_fee_rate 12、creator_fee_rate 108
+      const tradeFeeRate = c.u64(12)
+      const creatorFeeRate = state.creatorFeeEnabled ? c.u64(108) : 0n
+      const v0 = parseTokenAccount(need(get, state.vault0, 'Pool vault').data).amount
+      const v1 = parseTokenAccount(need(get, state.vault1, 'Pool vault').data).amount
+      if (v0 < state.reserved0 || v1 < state.reserved1) throw new UnsupportedPool('Pool vault is below the owed fees')
+      const [reserveIn, reserveOut] = zeroForOne ? [v0 - state.reserved0, v1 - state.reserved1] : [v1 - state.reserved1, v0 - state.reserved0]
+      const [mintIn, mintOut] = zeroForOne ? [m0, m1] : [m1, m0]
+      // 创建者手续费：0 两边都从输入扣；1 只收 token0；2 只收 token1（收哪种代币，卖出它时从输入扣，买入它时从输出扣）
+      const creatorOnInput = state.creatorFeeOn === 0 || (state.creatorFeeOn === 1 && zeroForOne) || (state.creatorFeeOn === 2 && !zeroForOne)
+      const actualIn = amountIn - transferFee(mintIn, amountIn, env.epoch)
+      if (actualIn <= 0n) return { amountIn, amountOut: 0n, accounts: [] }
+      const out = cpmmSwapBaseInput(actualIn, reserveIn, reserveOut, tradeFeeRate, creatorFeeRate, creatorOnInput)
+      const received = out - transferFee(mintOut, out, env.epoch)
+      return { amountIn, amountOut: received > 0n ? received : 0n, accounts: [] }
+    },
+    instruction(get, owner, input, output, zeroForOne, quote, minOut): Instruction {
+      const [m0, m1] = mints(get)
+      const [mintIn, mintOut] = zeroForOne ? [m0, m1] : [m1, m0]
+      const [vaultIn, vaultOut] = zeroForOne ? [state.vault0, state.vault1] : [state.vault1, state.vault0]
+      return {
+        programId: RAYDIUM_CPMM_PROGRAM_ID,
+        keys: [
+          r(owner, true),
+          r(RAYDIUM_CPMM_AUTHORITY),
+          r(state.config),
+          w(state.address),
+          w(input),
+          w(output),
+          w(vaultIn),
+          w(vaultOut),
+          r(mintIn.program),
+          r(mintOut.program),
+          r(mintIn.mint),
+          r(mintOut.mint),
+          w(state.observation),
+        ],
+        data: new Writer().bytes(anchorIx('swap_base_input')).u64(quote.amountIn).u64(minOut).build(),
+      }
+    },
+  }
+}