@w3lib/solana-batch-call 0.6.0 → 0.7.0

package/src/batchPlan.ts

@@ -3,13 +3,13 @@
  * 打包规则同 batchCall（相邻的调用放进同一笔交易，不超过 1232 字节和 64 个账户）
  */
 import type { SolanaClient } from './client.js'
-import { isAddress } from './address.js'
+import { InvalidAddressError, isAddress } from './address.js'
 import type { SimulationResult } from './simulate.js'
 import type { BatchCallOptions } from './write/batch.js'
-import { MAX_COMPUTE_UNITS, setComputeUnitLimit, setComputeUnitPrice } from './write/instructions.js'
+import { packUnits } from './write/pack.js'
 import type { WriteResult } from './write/send.js'
 import type { SignerInput } from './write/signer.js'
-import { MAX_ACCOUNT_LOCKS, PACKET_DATA_SIZE, compileMessage, transactionSize, type Instruction } from './write/transaction.js'
+import type { Instruction } from './write/transaction.js'
 
 /** 一个调用：要签名的地址（代币账户 / 仓位的 owner）和原子执行的指令 */
 export interface PlannedCall {
@@ -17,29 +17,9 @@ export interface PlannedCall {
   instructions: Instruction[]
 }
 
-/** 把调用按顺序打包成交易，返回每笔交易包含的调用下标。单个调用放不进一笔交易时自己成一笔（发送时会报“transaction too large”） */
+/** 把调用按顺序打包成交易，返回每笔交易包含的调用下标。单个调用放不进一笔交易时自己成一笔（发送时会报“transaction too large”）；规则同 batchCall（packUnits） */
 export function packCalls(payer: string, calls: readonly PlannedCall[], batchSize = Number.POSITIVE_INFINITY): number[][] {
-  const packs: number[][] = []
-  let current: number[] = []
-  let instructions: Instruction[] = []
-  const fits = (list: readonly Instruction[]) => {
-    const probe = compileMessage(payer, [setComputeUnitLimit(MAX_COMPUTE_UNITS), setComputeUnitPrice(1n), ...list], '11111111111111111111111111111111')
-    return transactionSize(probe) <= PACKET_DATA_SIZE && probe.accountKeys.length <= MAX_ACCOUNT_LOCKS
-  }
-  calls.forEach((call, i) => {
-    const next = [...instructions, ...call.instructions]
-    if (current.length && (current.length >= batchSize || !fits(next))) {
-      packs.push(current)
-      current = []
-      instructions = []
-    }
-    current.push(i)
-    instructions.push(...call.instructions)
-  })
-  if (current.length) {
-    packs.push(current)
-  }
-  return packs
+  return packUnits(payer, calls, { batchSize }).map((pack) => pack.indices)
 }
 
 export interface PlanSimulationOptions {
@@ -76,7 +56,7 @@ export async function simulatePlan(client: SolanaClient, calls: readonly Planned
   }
   const payer = options.feePayer ?? first.owner
   if (!isAddress(payer)) {
-    throw new Error(`Invalid fee payer: ${payer}`)
+    throw new InvalidAddressError(`Invalid fee payer: ${payer}`, payer)
   }
   const { simulate } = await import('./simulate.js')
   const run = (list: readonly PlannedCall[]) =>

package/src/bytes.ts

@@ -0,0 +1,89 @@
+import { encodeAddress } from './address.js'
+
+/**
+ * 小端读取二进制数据（账户数据、指令数据共用）。两种用法：
+ * - 传偏移量：按绝对位置读，不移动游标（如 `b.u64(333)`）
+ * - 不传：从游标处顺序读并前进（如 `r.u32(); r.pubkey()`）
+ * 越界时抛 RangeError
+ */
+export class Bytes {
+  readonly view: DataView
+  /** 顺序读取的游标 */
+  offset: number
+
+  constructor(
+    readonly data: Uint8Array,
+    offset = 0,
+  ) {
+    this.view = new DataView(data.buffer, data.byteOffset, data.byteLength)
+    this.offset = offset
+  }
+
+  get bytes(): Uint8Array {
+    return this.data
+  }
+
+  /** 要读的位置：传了 at 用它，否则用游标并前进 n 字节；检查越界 */
+  #pos(at: number | undefined, n: number): number {
+    const pos = at ?? this.offset
+    if (pos < 0 || pos + n > this.data.length) {
+      throw new RangeError('Account data is shorter than expected')
+    }
+    if (at === undefined) {
+      this.offset += n
+    }
+    return pos
+  }
+
+  skip(n: number): void {
+    this.#pos(undefined, n)
+  }
+
+  u8(at?: number): number {
+    return this.data[this.#pos(at, 1)] as number
+  }
+
+  u16(at?: number): number {
+    return this.view.getUint16(this.#pos(at, 2), true)
+  }
+
+  u32(at?: number): number {
+    return this.view.getUint32(this.#pos(at, 4), true)
+  }
+
+  i32(at?: number): number {
+    return this.view.getInt32(this.#pos(at, 4), true)
+  }
+
+  u64(at?: number): bigint {
+    return this.view.getBigUint64(this.#pos(at, 8), true)
+  }
+
+  u128(at?: number): bigint {
+    const pos = this.#pos(at, 16)
+    return (this.view.getBigUint64(pos + 8, true) << 64n) | this.view.getBigUint64(pos, true)
+  }
+
+  /** 32 字节地址（base58） */
+  key(at?: number): string {
+    const pos = this.#pos(at, 32)
+    return encodeAddress(this.data.subarray(pos, pos + 32))
+  }
+
+  /** 同 key（顺序读取时的习惯叫法） */
+  pubkey(at?: number): string {
+    return this.key(at)
+  }
+
+  /** borsh string：u32 长度 + UTF-8；去掉 Metaplex 用来补齐长度的 \0 */
+  string(): string {
+    const len = this.u32()
+    const pos = this.#pos(undefined, len)
+    return new TextDecoder().decode(this.data.subarray(pos, pos + len)).replace(/\0+$/, '').trim()
+  }
+
+  /** borsh Option：u8 标记（1 有）+ 值 */
+  option<T>(read: () => T): T | null {
+    return this.u8() === 1 ? read() : null
+  }
+}

package/src/claim.ts

@@ -4,7 +4,7 @@
  * 领取的指令就是 /liquidity 的 collectFees（手续费 + 全部奖励，SOL 自动解包、缺少的代币账户自动创建），这里只做批量和打包
  */
 import type { RequestOptions, SolanaClient } from './client.js'
-import { isAddress } from './address.js'
+import { InvalidAddressError, isAddress } from './address.js'
 import { buildCollectFees } from './liquidity/index.js'
 import type { SolanaLiquidityPlan } from './liquidity/types.js'
 import { lpPositions, type SolanaLpClmmPosition, type SolanaLpProtocol, type SolanaLpToken } from './lp.js'
@@ -13,7 +13,8 @@ import { simulatePlan, sendCalls, type PlanSimulation, type PlanSimulationOption
 import { formatUnits } from './layout.js'
 import type { SimulatedBalanceChange } from './simulate.js'
 import type { BatchCallOptions } from './write/batch.js'
-import { mapPool, type WriteResult } from './write/send.js'
+import { mapPool } from './util.js'
+import type { WriteResult } from './write/send.js'
 import type { SignerInput } from './write/signer.js'
 
 export type ClaimProtocol = Extract<SolanaLpProtocol, 'orca-whirlpool' | 'raydium-clmm'>
@@ -67,7 +68,7 @@ export interface Claimable {
   warnings: string[]
 }
 
-export interface ClaimQuery extends RequestOptions {
+export interface ClaimableOptions extends RequestOptions {
   /** 只看这些仓位 NFT 的 mint（读 ATA，免费公共节点也能用）；不传时列出全部代币账户（getTokenAccountsByOwner，需要支持它的节点） */
   mints?: readonly string[]
   /** 协议，默认两个都查 */
@@ -79,6 +80,9 @@ export interface ClaimQuery extends RequestOptions {
   fetch?: typeof fetch
 }
 
+/** @deprecated 改名为 ClaimableOptions（与其他查询的 options 命名统一），旧名保留 */
+export type ClaimQuery = ClaimableOptions
+
 const MAX_ERROR = 200
 
 /**
@@ -91,23 +95,23 @@ const MAX_ERROR = 200
  * c.positions[0].rewards              // [{ index: 0, symbol: 'RAY', formatted: '0.042698', usd: 0.083 }]
  * ```
  */
-export async function claimable(client: SolanaClient, owner: string, query: ClaimQuery = {}): Promise<Claimable> {
+export async function claimable(client: SolanaClient, owner: string, options: ClaimableOptions = {}): Promise<Claimable> {
   if (!isAddress(owner)) {
-    throw new Error(`Invalid owner address: ${owner}`)
+    throw new InvalidAddressError(`Invalid owner address: ${owner}`, owner)
   }
-  const { signal } = query
-  const protocols: ClaimProtocol[] = query.protocols ? [...query.protocols] : ['orca-whirlpool', 'raydium-clmm']
+  const { signal } = options
+  const protocols: ClaimProtocol[] = options.protocols ? [...options.protocols] : ['orca-whirlpool', 'raydium-clmm']
   const list = (
-    await lpPositions(client, owner, { protocols, mints: query.mints, rewards: true, now: query.now, signal })
+    await lpPositions(client, owner, { protocols, mints: options.mints, rewards: true, now: options.now, signal })
   ).filter((p): p is SolanaLpClmmPosition => p.type === 'clmm')
 
   const warnings: string[] = []
   const mints = [...new Set(list.flatMap((p) => [p.token0.mint, p.token1.mint, ...(p.rewards ?? []).map((r) => r.mint)]))]
-  const source = query.prices === false ? null : query.prices && query.prices !== true ? query.prices : defillamaPrices()
+  const source = options.prices === false ? null : options.prices && options.prices !== true ? options.prices : defillamaPrices()
   let priceMap = new Map<string, number>()
   if (source && mints.length) {
     try {
-      priceMap = await source.prices({ mints, fetch: query.fetch ?? ((...args: Parameters<typeof fetch>) => fetch(...args)), signal, client })
+      priceMap = await source.prices({ mints, fetch: options.fetch ?? ((...args: Parameters<typeof fetch>) => fetch(...args)), signal, client })
     } catch (err) {
       if (signal?.aborted) throw err
       warnings.push(`Price lookup failed (${(err instanceof Error ? err.message : String(err)).slice(0, MAX_ERROR)}): usd values are null`)
@@ -215,7 +219,7 @@ export interface ClaimPlan {
  */
 export async function buildClaimAll(client: SolanaClient, owner: string, positions: readonly ClaimTarget[], options: BuildClaimOptions = {}): Promise<ClaimPlan> {
   if (!isAddress(owner)) {
-    throw new Error(`Invalid owner address: ${owner}`)
+    throw new InvalidAddressError(`Invalid owner address: ${owner}`, owner)
   }
   const unique = [...new Map(positions.map((p) => [p.positionMint, p])).values()]
   const calls: ClaimCall[] = []