sally-defi-ts-sdk 0.3.2

package/src/aio/client.ts

@@ -0,0 +1,329 @@
+/**
+ * Async entry point: {@link AsyncSallyClient}.
+ *
+ * Mirrors {@link SallyClient} on top of ethers' provider for non-blocking I/O.
+ * Shares all pure machinery (deployment, types, safety, errors, permit signing)
+ * with the sync client; only the network calls are awaited.
+ *
+ * In JS every network call is already async, so this client mainly differs from
+ * the main one in that its candidate quoting/simulation fans out concurrently
+ * (`Promise.all`), exactly like the Python `aio` client uses `asyncio.gather`.
+ *
+ * ```ts
+ * import { AsyncSallyClient } from "sally-defi-ts-sdk/aio";
+ * import { Base } from "sally-defi-ts-sdk";
+ *
+ * const sally = new AsyncSallyClient("base", RPC, { privateKey: "0x…" });
+ * console.log((await sally.prices.usd(Base.USDC)).asFloat);
+ * await sally.swap.execute(Base.WETH, Base.USDC, 10n ** 17n, { slippageBps: 50 });
+ * ```
+ */
+
+import {
+  Contract,
+  HDNodeWallet,
+  JsonRpcProvider,
+  Network,
+  Wallet,
+  getAddress,
+  type Signer,
+} from "ethers";
+
+import * as deployment from "../deployment.js";
+import { SallyConfigError, SallyError, SallyRevert, wrapWeb3Error } from "../errors.js";
+import { SafetyConfig } from "../safety.js";
+import { AsyncToken } from "./token.js";
+import { AsyncPrices } from "./modules/prices.js";
+import { AsyncSwap } from "./modules/swap.js";
+import { AsyncWallet } from "./modules/wallet.js";
+import { AsyncLiquidity } from "./modules/liquidity.js";
+import { AsyncFees } from "./modules/fees.js";
+
+/** Minimal async mutex: serialize an async critical section. */
+class AsyncMutex {
+  private _chain: Promise<void> = Promise.resolve();
+  async run<T>(fn: () => Promise<T>): Promise<T> {
+    const prev = this._chain;
+    let release!: () => void;
+    this._chain = new Promise<void>((res) => (release = res));
+    await prev;
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+}
+
+export interface AsyncSallyClientOptions {
+  privateKey?: string | null;
+  mnemonic?: string | null;
+  accountIndex?: number;
+  account?: Signer | null;
+  address?: string | null;
+  poa?: boolean | null;
+  safety?: SafetyConfig | null;
+  privateRpcUrl?: string | null;
+  gasMultiplier?: number;
+}
+
+type Fn = any;
+
+export class AsyncSallyClient {
+  readonly chainKey: string;
+  readonly chainId: number;
+  safety: SafetyConfig;
+  privateRpcUrl: string | null;
+  private _privateW3: JsonRpcProvider | null = null;
+  gasMultiplier: number;
+  w3: JsonRpcProvider;
+  account: Signer | null = null;
+  private _sender: string | null = null;
+  private _sendLock = new AsyncMutex();
+  addresses: Record<string, string>;
+  private _cache: Record<string, any> = {};
+
+  constructor(chain: string | number = "base", rpcUrl?: string | null, opts: AsyncSallyClientOptions = {}) {
+    this.chainKey = deployment.normalizeChain(chain);
+    this.chainId = deployment.chainId(this.chainKey);
+    this.safety = opts.safety ?? new SafetyConfig();
+    this.privateRpcUrl = opts.privateRpcUrl ?? process.env.SALLY_PRIVATE_RPC_URL ?? null;
+    this.gasMultiplier = opts.gasMultiplier ?? 1.25;
+
+    rpcUrl = rpcUrl ?? process.env.SALLY_RPC_URL ?? null;
+    if (!rpcUrl) {
+      throw new SallyConfigError("No rpcUrl given and SALLY_RPC_URL is unset.");
+    }
+    const network = Network.from(this.chainId);
+    this.w3 = new JsonRpcProvider(rpcUrl, network, { staticNetwork: network });
+
+    void (opts.poa ?? this.chainKey === "bsc");
+
+    const key = opts.privateKey ?? process.env.SALLY_PRIVATE_KEY ?? null;
+    const phrase = opts.mnemonic ?? process.env.SALLY_MNEMONIC ?? null;
+    if (opts.account != null) {
+      this.account = opts.account;
+    } else if (key) {
+      this.account = new Wallet(key);
+    } else if (phrase) {
+      const idx = opts.accountIndex ?? 0;
+      this.account = HDNodeWallet.fromPhrase(phrase, undefined, `m/44'/60'/0'/0/${idx}`);
+    }
+    this._sender = this.account
+      ? getAddress((this.account as any).address)
+      : opts.address
+        ? getAddress(opts.address)
+        : null;
+
+    this.addresses = Object.fromEntries(
+      Object.entries(deployment.addresses(this.chainKey)).map(([k, v]) => [
+        k,
+        v.startsWith("0x") ? getAddress(v) : v,
+      ]),
+    );
+  }
+
+  // -- identity ---------------------------------------------------------- //
+  async isConnected(): Promise<boolean> {
+    try {
+      await this.w3.getBlockNumber();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  get address(): string | null {
+    return this._sender;
+  }
+
+  get canSign(): boolean {
+    return this.account !== null;
+  }
+
+  requireAddress(): string {
+    if (!this._sender) {
+      throw new SallyConfigError("This action needs a sender (privateKey=…, mnemonic=…, or address='0x…').");
+    }
+    return this._sender;
+  }
+
+  requireSigner(): Signer {
+    if (this.account === null) {
+      throw new SallyConfigError("This action signs a tx and needs a key (privateKey=… or mnemonic=…).");
+    }
+    return this.account;
+  }
+
+  // -- contracts --------------------------------------------------------- //
+  private _contract(address: string, component: string): Contract {
+    return new Contract(getAddress(address), deployment.abi(this.chainKey, component) as any, this.w3);
+  }
+
+  private _cached<T>(key: string, make: () => T): T {
+    if (!(key in this._cache)) this._cache[key] = make();
+    return this._cache[key];
+  }
+
+  get swapContract(): Contract {
+    return this._cached("swapContract", () => this._contract(this.addresses["swap"], "swap"));
+  }
+  get liquidityContract(): Contract {
+    return this._cached("liquidityContract", () => this._contract(this.addresses["liquidity"], "liquidity"));
+  }
+  get lensContract(): Contract {
+    return this._cached("lensContract", () => this._contract(this.addresses["lens"], "lens"));
+  }
+  get sidecarContract(): Contract {
+    return this._cached("sidecarContract", () => this._contract(this.addresses["sidecar"], "sidecar"));
+  }
+
+  token(address: string): AsyncToken {
+    return new AsyncToken(this, address);
+  }
+
+  // -- call / send ------------------------------------------------------- //
+  async call(fn: Fn, args: any[] = [], opts: { value?: bigint; sender?: string | null } = {}): Promise<any> {
+    const overrides: Record<string, any> = {};
+    if (opts.value) overrides.value = opts.value;
+    const sender = opts.sender ?? this.address;
+    if (sender) overrides.from = sender;
+    try {
+      return await fn.staticCall(...args, overrides);
+    } catch (exc) {
+      throw wrapWeb3Error(this.chainKey, exc);
+    }
+  }
+
+  async buildTx(fn: Fn, args: any[] = [], opts: { value?: bigint; gas?: bigint | null } = {}): Promise<Record<string, any>> {
+    const sender = this.requireAddress();
+    const overrides: Record<string, any> = { from: sender };
+    if (opts.value) overrides.value = opts.value;
+    let tx: Record<string, any>;
+    try {
+      tx = { ...(await fn.populateTransaction(...args, overrides)) };
+    } catch (exc) {
+      throw wrapWeb3Error(this.chainKey, exc);
+    }
+    tx.nonce = await this.w3.getTransactionCount(sender, "pending");
+    tx.chainId = this.chainId;
+    if (opts.value) tx.value = opts.value;
+    const latest = await this.w3.getBlock("latest");
+    const feeData = await this.w3.getFeeData();
+    if (latest && latest.baseFeePerGas != null) {
+      let tip = feeData.maxPriorityFeePerGas;
+      if (tip == null) tip = 1_000_000_000n;
+      tx.maxPriorityFeePerGas = tip;
+      tx.maxFeePerGas = tip + 2n * latest.baseFeePerGas;
+      tx.type = 2;
+      delete tx.gasPrice;
+    } else {
+      tx.gasPrice = feeData.gasPrice ?? 0n;
+      tx.type = 0;
+    }
+    let gas = opts.gas ?? null;
+    if (gas !== null) {
+      tx.gasLimit = gas;
+    } else {
+      const overrides2: Record<string, any> = { from: sender };
+      if (opts.value) overrides2.value = opts.value;
+      let est = BigInt(await fn.estimateGas(...args, overrides2));
+      if (this.gasMultiplier && this.gasMultiplier !== 1.0) {
+        est = (est * BigInt(Math.round(this.gasMultiplier * 1000))) / 1000n;
+      }
+      tx.gasLimit = est;
+    }
+    delete tx.gas;
+    return tx;
+  }
+
+  async send(
+    fn: Fn,
+    args: any[] = [],
+    opts: {
+      value?: bigint;
+      gas?: bigint | null;
+      wait?: boolean;
+      simulate?: boolean;
+      private?: boolean | null;
+      timeout?: number;
+      buildOnly?: boolean;
+    } = {},
+  ): Promise<any> {
+    const value = opts.value ?? 0n;
+    const wait = opts.wait ?? true;
+    const simulate = opts.simulate ?? true;
+    const timeout = opts.timeout ?? 180;
+
+    if (simulate) {
+      await this.call(fn, args, { value, sender: this.address });
+    }
+    if (opts.buildOnly) {
+      return this.buildTx(fn, args, { value, gas: opts.gas ?? null });
+    }
+
+    const account = this.requireSigner();
+    const usePrivate = opts.private == null ? this.privateRpcUrl !== null : opts.private;
+    const txh: string = await this._sendLock.run(async () => {
+      const tx = await this.buildTx(fn, args, { value, gas: opts.gas ?? null });
+      const raw = await account.signTransaction(tx as any);
+      if (usePrivate) return this._broadcastPrivate(raw);
+      const resp = await this.w3.broadcastTransaction(raw);
+      return resp.hash;
+    });
+    if (!wait) return txh;
+
+    let receipt;
+    try {
+      receipt = await this.w3.waitForTransaction(txh, 1, timeout * 1000);
+    } catch {
+      receipt = null;
+    }
+    if (receipt === null) {
+      const where = usePrivate ? "private relay" : "public mempool";
+      throw new SallyError(
+        `tx ${txh} not mined within ${timeout}s via ${where}. It may have been ` +
+          `dropped/not included — check the hash before resubmitting.`,
+      );
+    }
+    if (receipt.status !== 1) {
+      throw new SallyRevert("Error", [], null, `tx ${txh} reverted on-chain`);
+    }
+    return receipt;
+  }
+
+  private async _broadcastPrivate(rawTx: string): Promise<string> {
+    if (!this.privateRpcUrl) {
+      throw new SallyConfigError("private=true but no privateRpcUrl configured.");
+    }
+    if (this._privateW3 === null) {
+      this._privateW3 = new JsonRpcProvider(this.privateRpcUrl, Network.from(this.chainId), {
+        staticNetwork: Network.from(this.chainId),
+      });
+    }
+    const resp = await this._privateW3.broadcastTransaction(rawTx);
+    return resp.hash;
+  }
+
+  // -- namespaces -------------------------------------------------------- //
+  get prices(): AsyncPrices {
+    return this._cached("prices", () => new AsyncPrices(this));
+  }
+  get swap(): AsyncSwap {
+    return this._cached("swap", () => new AsyncSwap(this));
+  }
+  get wallet(): AsyncWallet {
+    return this._cached("wallet", () => new AsyncWallet(this));
+  }
+  get liquidity(): AsyncLiquidity {
+    return this._cached("liquidity", () => new AsyncLiquidity(this));
+  }
+  get fees(): AsyncFees {
+    return this._cached("fees", () => new AsyncFees(this));
+  }
+
+  toString(): string {
+    const who = this.address ?? "read-only";
+    return `<AsyncSallyClient chain=${this.chainKey} id=${this.chainId} signer=${who}>`;
+  }
+}

package/src/aio/index.ts

@@ -0,0 +1,20 @@
+/**
+ * Async Sally SDK — {@link AsyncSallyClient}.
+ *
+ * ```ts
+ * import { AsyncSallyClient } from "sally-defi-ts-sdk/aio";
+ * import { Base } from "sally-defi-ts-sdk";
+ *
+ * const sally = new AsyncSallyClient("base", "https://mainnet.base.org");
+ * console.log((await sally.prices.usd(Base.USDC)).asFloat);
+ * ```
+ */
+
+export { AsyncSallyClient } from "./client.js";
+export type { AsyncSallyClientOptions } from "./client.js";
+export { AsyncToken } from "./token.js";
+export { AsyncPrices } from "./modules/prices.js";
+export { AsyncSwap } from "./modules/swap.js";
+export { AsyncWallet } from "./modules/wallet.js";
+export { AsyncLiquidity } from "./modules/liquidity.js";
+export { AsyncFees } from "./modules/fees.js";

package/src/aio/modules/fees.ts

@@ -0,0 +1,60 @@
+/** Async referral & batch-fee accounting (swap controller). */
+
+import { Contract, getAddress } from "ethers";
+import type { AsyncSallyClient } from "../client.js";
+import { ReferralFeeTokens } from "../../types.js";
+
+export class AsyncFees {
+  private _c: AsyncSallyClient;
+  private _swap: Contract;
+
+  constructor(client: AsyncSallyClient) {
+    this._c = client;
+    this._swap = client.swapContract;
+  }
+
+  private _a(x: string): string {
+    return getAddress(x);
+  }
+
+  async referralTokenCount(user: string): Promise<number> {
+    return Number(await this._c.call(this._swap.getFunction("getReferralFeeTokenCount"), [this._a(user)]));
+  }
+
+  async referralTokens(user: string, start = 0, stop = 0): Promise<ReferralFeeTokens> {
+    if (stop === 0) {
+      stop = Math.max(await this.referralTokenCount(this._a(user)), 1);
+    }
+    const r = await this._c.call(this._swap.getFunction("getReferralFeeTokens"), [this._a(user), start, stop]);
+    return ReferralFeeTokens.fromRaw(r);
+  }
+
+  async totalReferralOwed(user: string): Promise<bigint> {
+    return BigInt(await this._c.call(this._swap.getFunction("totalReferralOwed"), [this._a(user)]));
+  }
+
+  async referralFee(user: string, token: string): Promise<bigint> {
+    return BigInt(await this._c.call(this._swap.getFunction("referralFees"), [this._a(user), this._a(token)]));
+  }
+
+  async batchFee(token: string): Promise<bigint> {
+    return BigInt(await this._c.call(this._swap.getFunction("batchFees"), [this._a(token)]));
+  }
+
+  async feeBasisPoints(): Promise<bigint> {
+    return BigInt(await this._c.call(this._swap.getFunction("feeBasisPoints"), []));
+  }
+
+  async swapFee(amount: bigint): Promise<[bigint, bigint]> {
+    const r = await this._c.call(this._swap.getFunction("getSwapFee"), [amount]);
+    return [BigInt(r[0]), BigInt(r[1])];
+  }
+
+  async claimReferral(tokens: string[], tx: Record<string, any> = {}): Promise<any> {
+    return this._c.send(this._swap.getFunction("claimReferralFees"), [tokens.map((t) => this._a(t))], tx);
+  }
+
+  async claimBatch(tokens: string[], tx: Record<string, any> = {}): Promise<any> {
+    return this._c.send(this._swap.getFunction("claimBatchFees"), [tokens.map((t) => this._a(t))], tx);
+  }
+}

package/src/aio/modules/liquidity.ts

@@ -0,0 +1,181 @@
+/** Async liquidity: core adds + position/pool/lock reads. */
+
+import { Contract, getAddress } from "ethers";
+import type { AsyncSallyClient } from "../client.js";
+import { ZERO, isNative } from "../../token.js";
+import {
+  ClaimableFees,
+  Lock,
+  V2PoolState,
+  V2Position,
+  V3PoolState,
+  V3Position,
+  V4Position,
+} from "../../types.js";
+
+type Tx = Record<string, any>;
+
+export class AsyncLiquidity {
+  private _c: AsyncSallyClient;
+  private _liq: Contract;
+  private _side: Contract;
+
+  constructor(client: AsyncSallyClient) {
+    this._c = client;
+    this._liq = client.liquidityContract;
+    this._side = client.sidecarContract;
+  }
+
+  private _a(x: string): string {
+    return getAddress(x);
+  }
+
+  async deadline(secs = 1200): Promise<number> {
+    return Math.floor(Date.now() / 1000) + secs;
+  }
+
+  private async _approveAndValue(pairs: [string, bigint][]): Promise<bigint> {
+    const spender = this._c.addresses["liquidity"];
+    let value = 0n;
+    for (const [token, amount] of pairs) {
+      if (amount <= 0n) continue;
+      if (isNative(token)) value += amount;
+      else await this._c.token(token).ensureAllowance(spender, amount);
+    }
+    return value;
+  }
+
+  // -- adds -------------------------------------------------------------- //
+  async addV2(
+    dexId: number,
+    tokenA: string,
+    tokenB: string,
+    amountA: bigint,
+    amountB: bigint,
+    opts: {
+      amountAMin?: bigint;
+      amountBMin?: bigint;
+      lockDays?: number;
+      referral?: string;
+      deadline?: number | null;
+      approve?: boolean;
+      tx?: Tx;
+    } = {},
+  ): Promise<any> {
+    tokenA = this._a(tokenA);
+    tokenB = this._a(tokenB);
+    const approve = opts.approve ?? true;
+    const value = approve ? await this._approveAndValue([[tokenA, amountA], [tokenB, amountB]]) : 0n;
+    const p = [
+      dexId, tokenA, tokenB, amountA, amountB, opts.amountAMin ?? 0n, opts.amountBMin ?? 0n,
+      opts.lockDays ?? 0, this._a(opts.referral ?? ZERO), opts.deadline ?? (await this.deadline()),
+    ];
+    return this._c.send(this._liq.getFunction("addLiquidityV2"), [p], { value, ...(opts.tx ?? {}) });
+  }
+
+  async addV3(
+    dexId: number,
+    token0: string,
+    token1: string,
+    fee: number,
+    tickLower: number,
+    tickUpper: number,
+    amount0: bigint,
+    amount1: bigint,
+    opts: {
+      amount0Min?: bigint;
+      amount1Min?: bigint;
+      lockDays?: number;
+      referral?: string;
+      deadline?: number | null;
+      approve?: boolean;
+      tx?: Tx;
+    } = {},
+  ): Promise<any> {
+    token0 = this._a(token0);
+    token1 = this._a(token1);
+    const approve = opts.approve ?? true;
+    const value = approve ? await this._approveAndValue([[token0, amount0], [token1, amount1]]) : 0n;
+    const p = [
+      dexId, token0, token1, fee, tickLower, tickUpper, amount0, amount1,
+      opts.amount0Min ?? 0n, opts.amount1Min ?? 0n, opts.lockDays ?? 0, this._a(opts.referral ?? ZERO),
+      opts.deadline ?? (await this.deadline()),
+    ];
+    return this._c.send(this._liq.getFunction("addLiquidityV3"), [p], { value, ...(opts.tx ?? {}) });
+  }
+
+  // -- claim / lock ------------------------------------------------------ //
+  async claimFeesV3(npm: string, tokenId: bigint, recipient: string | null = null, tx: Tx = {}): Promise<any> {
+    recipient = recipient ?? this._c.requireAddress();
+    return this._c.send(this._liq.getFunction("claimFeesV3"), [this._a(npm), tokenId, this._a(recipient)], tx);
+  }
+
+  async massClaimFees(npms: string[], tokenIds: bigint[], outputToken: string, tx: Tx = {}): Promise<any> {
+    return this._c.send(
+      this._liq.getFunction("massClaimFees"),
+      [npms.map((a) => this._a(a)), tokenIds, this._a(outputToken)],
+      tx,
+    );
+  }
+
+  async lockV3(npm: string, tokenId: bigint, lockDays: number, tx: Tx = {}): Promise<any> {
+    return this._c.send(this._liq.getFunction("lockV3Position"), [this._a(npm), tokenId, lockDays], tx);
+  }
+
+  // -- reads ------------------------------------------------------------- //
+  async positionsV2(wallet: string, pairs: string[]): Promise<V2Position[]> {
+    const r = await this._c.call(this._side.getFunction("getV2Positions"), [this._a(wallet), pairs.map((p) => this._a(p))]);
+    return [...r].map((x) => V2Position.fromRaw(x));
+  }
+
+  async positionsV3(wallet: string, start = 0, end = 0): Promise<V3Position[]> {
+    const r = await this._c.call(this._side.getFunction("getV3Positions"), [this._a(wallet), start, end]);
+    return [...r].map((x) => V3Position.fromRaw(x));
+  }
+
+  async positionsV4(wallet: string, start = 0, end = 0): Promise<V4Position[]> {
+    const r = await this._c.call(this._side.getFunction("getV4Positions"), [this._a(wallet), start, end]);
+    return [...r].map((x) => V4Position.fromRaw(x));
+  }
+
+  async poolStateV2(pair: string): Promise<V2PoolState> {
+    return V2PoolState.fromRaw(await this._c.call(this._side.getFunction("getV2PoolState"), [this._a(pair)]));
+  }
+
+  async poolStateV3(pool: string): Promise<V3PoolState> {
+    return V3PoolState.fromRaw(await this._c.call(this._side.getFunction("getV3PoolState"), [this._a(pool)]));
+  }
+
+  async locks(wallet: string): Promise<Lock[]> {
+    const r = await this._c.call(this._side.getFunction("getLocks"), [this._a(wallet)]);
+    return [...r].map((x) => Lock.fromRaw(x));
+  }
+
+  async claimableFees(npm: string, tokenId: bigint): Promise<ClaimableFees> {
+    return ClaimableFees.fromRaw(await this._c.call(this._side.getFunction("getClaimableFees"), [this._a(npm), tokenId]));
+  }
+
+  async usdValue(token: string, amount: bigint): Promise<bigint> {
+    return BigInt(await this._c.call(this._side.getFunction("usdValue"), [this._a(token), amount]));
+  }
+
+  async isPaused(): Promise<boolean> {
+    return Boolean(await this._c.call(this._liq.getFunction("paused"), []));
+  }
+
+  async dexCount(version: number): Promise<number> {
+    const name = { 2: "v2DexCount", 3: "v3DexCount", 4: "v4DexCount" }[version];
+    return Number(await this._c.call(this._liq.getFunction(name!), []));
+  }
+
+  async dexes(version: number): Promise<any[][]> {
+    const name = { 2: "v2Dexes", 3: "v3Dexes", 4: "v4Dexes" }[version];
+    const n = await this.dexCount(version);
+    const out: any[][] = [];
+    for (let i = 0; i < n; i++) {
+      const r = await this._c.call(this._liq.getFunction(name!), [i]);
+      out.push([...r]);
+    }
+    return out;
+  }
+}

package/src/aio/modules/prices.ts

@@ -0,0 +1,57 @@
+/** Async pricing & token-safety reads. */
+
+import { Contract, getAddress } from "ethers";
+import type { AsyncSallyClient } from "../client.js";
+import { PriceResult, TokenInfo } from "../../types.js";
+
+export class AsyncPrices {
+  private _c: AsyncSallyClient;
+  private _lens: Contract;
+
+  constructor(client: AsyncSallyClient) {
+    this._c = client;
+    this._lens = client.lensContract;
+  }
+
+  private _a(x: string): string {
+    return getAddress(x);
+  }
+
+  async usd(token: string): Promise<PriceResult> {
+    return PriceResult.fromRaw(await this._c.call(this._lens.getFunction("getUsdPrice"), [this._a(token)]));
+  }
+
+  async usdImpact(token: string): Promise<PriceResult> {
+    return PriceResult.fromRaw(await this._c.call(this._lens.getFunction("getUsdPriceImpact"), [this._a(token)]));
+  }
+
+  async weth(token: string): Promise<PriceResult> {
+    return PriceResult.fromRaw(await this._c.call(this._lens.getFunction("getWethPrice"), [this._a(token)]));
+  }
+
+  async spot(tokenIn: string, tokenOut: string): Promise<bigint> {
+    return BigInt(await this._c.call(this._lens.getFunction("getSpotPrice"), [this._a(tokenIn), this._a(tokenOut)]));
+  }
+
+  async usdLiquidity(token: string, version: number | null = null): Promise<bigint> {
+    const name = {
+      null: "getUsdLiquidity",
+      2: "getUsdLiquidityV2",
+      3: "getUsdLiquidityV3",
+      4: "getUsdLiquidityV4",
+    }[version === null ? "null" : version];
+    return BigInt(await this._c.call(this._lens.getFunction(name!), [this._a(token)]));
+  }
+
+  async tokenInfo(token: string, opts: { probeValue?: bigint | null } = {}): Promise<TokenInfo> {
+    const { SafetyConfig } = await import("../../safety.js");
+    const { ZERO } = await import("../../token.js");
+    let probeValue = opts.probeValue ?? null;
+    if (probeValue === null) probeValue = new SafetyConfig().probeValue;
+    const raw = await this._lens.getFunction("getTokenInfos").staticCall(this._a(token), {
+      from: ZERO,
+      value: probeValue,
+    });
+    return TokenInfo.fromRaw(raw);
+  }
+}