@cubee_ee/sdk 0.1.0

package/src/clients/tx-builders.ts

@@ -0,0 +1,538 @@
+import {
+  AccountMeta,
+  ComputeBudgetProgram,
+  PublicKey,
+  SystemProgram,
+  TransactionInstruction,
+} from "@solana/web3.js";
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+  createAssociatedTokenAccountIdempotentInstruction,
+} from "@solana/spl-token";
+import BN from "bn.js";
+import { CubeConfig } from "../config";
+import { PoolInfo } from "../types/pool";
+import {
+  AddLiquidityParams,
+  BuiltTx,
+  DeployPoolParams,
+  RemoveLiquidityParams,
+  SingleTokenDepositParams,
+  SwapParams,
+} from "../types/tx";
+import { deriveAta, deriveBptMint, deriveHelperPda } from "../utils/pda";
+
+/**
+ * Low-level transaction builders. Emit raw `TransactionInstruction`s suitable
+ * for combination with others (e.g. versioned transactions with ALTs) in a
+ * single tx. Higher-level convenience lives on `CubicPoolClient`.
+ */
+
+const CUBIC_POOL_DISC = {
+  swap: computeDiscriminator("swap"),
+  addLiquidity: computeDiscriminator("add_liquidity"),
+  removeLiquidity: computeDiscriminator("remove_liquidity"),
+  initializeCubicPool: computeDiscriminator("initialize_cubic_pool"),
+};
+
+const STLD_DISC = {
+  depositSingleToken: computeDiscriminator("deposit_single_token"),
+};
+
+/**
+ * Anchor discriminator: sha256("global:<ix_name>")[0..8]. The SDK
+ * pre-computes only the cases it needs.
+ *
+ * Pre-computed values (confirmed against `src/idl/*.json`):
+ *   swap                  → f8c69e91e17587c8
+ *   add_liquidity         → b59d59438fb63448
+ *   remove_liquidity      → 5055d14818ceb16c
+ *   initialize_cubic_pool → d79474cf79686f83
+ *   deposit_single_token  → a688a62fc7c056a9
+ *
+ * If you change an instruction name in Rust, regenerate by reading the
+ * target/idl/*.json discriminator field.
+ */
+function computeDiscriminator(ixName: string): Buffer {
+  // Fallback: Anchor exposes discriminators in the IDL. We ship the known
+  // ones as a static map; callers passing unknown names error clearly.
+  const KNOWN: Record<string, string> = {
+    swap: "f8c69e91e17587c8",
+    add_liquidity: "b59d59438fb63448",
+    remove_liquidity: "5055d14818ceb16c",
+    initialize_cubic_pool: "d79474cf79686f83",
+    deposit_single_token: "a688a62fc7c056a9",
+    initialize_config: "d07f1501c2bec446",
+  };
+  const hex = KNOWN[ixName];
+  if (!hex) throw new Error(`tx-builders: unknown discriminator for "${ixName}"`);
+  return Buffer.from(hex, "hex");
+}
+
+function requirePositiveMinimumBpt(minimumBptAmount: BN | undefined, ixName: string): BN {
+  if (!minimumBptAmount || minimumBptAmount.lte(new BN(0))) {
+    throw new Error(`${ixName}: minimumBptAmount must be positive`);
+  }
+  return minimumBptAmount;
+}
+
+// ============================================================
+// Swap
+// ============================================================
+
+export function buildSwapIx(
+  cfg: CubeConfig,
+  pool: PoolInfo,
+  params: SwapParams & { minAmountOut: BN }
+): TransactionInstruction {
+  const inTok = pool.tokens[params.tokenInIndex];
+  const outTok = pool.tokens[params.tokenOutIndex];
+
+  const userTokenIn = deriveAta(params.user, inTok.mint, inTok.tokenProgram);
+  const userTokenOut = deriveAta(params.user, outTok.mint, outTok.tokenProgram);
+
+  const data = Buffer.concat([
+    CUBIC_POOL_DISC.swap,
+    encodeU64(params.amountIn),
+    encodeU64(params.minAmountOut),
+    encodeU8(params.tokenInIndex),
+    encodeU8(params.tokenOutIndex),
+  ]);
+
+  const keys: AccountMeta[] = [
+    { pubkey: pool.address, isSigner: false, isWritable: true },
+    { pubkey: inTok.mint, isSigner: false, isWritable: false },
+    { pubkey: outTok.mint, isSigner: false, isWritable: false },
+    { pubkey: userTokenIn, isSigner: false, isWritable: true },
+    { pubkey: userTokenOut, isSigner: false, isWritable: true },
+    { pubkey: inTok.vault, isSigner: false, isWritable: true },
+    { pubkey: outTok.vault, isSigner: false, isWritable: true },
+    { pubkey: params.user, isSigner: true, isWritable: true },
+    { pubkey: inTok.tokenProgram, isSigner: false, isWritable: false },
+    { pubkey: outTok.tokenProgram, isSigner: false, isWritable: false },
+  ];
+
+  return new TransactionInstruction({
+    programId: cfg.programs.cubicPool,
+    keys,
+    data,
+  });
+}
+
+export function buildSwapTx(
+  cfg: CubeConfig,
+  pool: PoolInfo,
+  params: SwapParams & { minAmountOut: BN }
+): BuiltTx {
+  return {
+    instructions: [
+      ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 }),
+      buildSwapIx(cfg, pool, params),
+    ],
+    suggestedCuLimit: 400_000,
+  };
+}
+
+// ============================================================
+// Add liquidity (proportional)
+// ============================================================
+
+export function buildAddLiquidityIx(
+  cfg: CubeConfig,
+  pool: PoolInfo,
+  params: AddLiquidityParams
+): TransactionInstruction {
+  const userBpt = deriveAta(params.user, pool.bptMint, TOKEN_PROGRAM_ID);
+  const minBpt = requirePositiveMinimumBpt(params.minimumBptAmount, "add_liquidity");
+
+  const data = Buffer.concat([
+    CUBIC_POOL_DISC.addLiquidity,
+    encodeVecU64(params.tokenAmounts),
+    encodeU64(minBpt),
+  ]);
+
+  // remaining_accounts layout:
+  //   [user_token_i, vault_i] × N, mint_i × N, token_program_i × N
+  const remaining: AccountMeta[] = [];
+  for (let i = 0; i < pool.tokenCount; i++) {
+    const t = pool.tokens[i];
+    const userAta = deriveAta(params.user, t.mint, t.tokenProgram);
+    remaining.push({ pubkey: userAta, isSigner: false, isWritable: true });
+    remaining.push({ pubkey: t.vault, isSigner: false, isWritable: true });
+  }
+  for (let i = 0; i < pool.tokenCount; i++) {
+    remaining.push({ pubkey: pool.tokens[i].mint, isSigner: false, isWritable: false });
+  }
+  for (let i = 0; i < pool.tokenCount; i++) {
+    remaining.push({ pubkey: pool.tokens[i].tokenProgram, isSigner: false, isWritable: false });
+  }
+
+  const keys: AccountMeta[] = [
+    { pubkey: pool.address, isSigner: false, isWritable: true },
+    { pubkey: pool.bptMint, isSigner: false, isWritable: true },
+    { pubkey: userBpt, isSigner: false, isWritable: true },
+    { pubkey: params.user, isSigner: true, isWritable: true },
+    { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+    ...remaining,
+  ];
+
+  return new TransactionInstruction({
+    programId: cfg.programs.cubicPool,
+    keys,
+    data,
+  });
+}
+
+export function buildAddLiquidityTx(
+  cfg: CubeConfig,
+  pool: PoolInfo,
+  params: AddLiquidityParams
+): BuiltTx {
+  const userBpt = deriveAta(params.user, pool.bptMint, TOKEN_PROGRAM_ID);
+  return {
+    instructions: [
+      ComputeBudgetProgram.setComputeUnitLimit({ units: 600_000 }),
+      createAssociatedTokenAccountIdempotentInstruction(
+        params.user,
+        userBpt,
+        params.user,
+        pool.bptMint,
+        TOKEN_PROGRAM_ID
+      ),
+      buildAddLiquidityIx(cfg, pool, params),
+    ],
+    suggestedCuLimit: 600_000,
+  };
+}
+
+// ============================================================
+// Remove liquidity
+// ============================================================
+
+export function buildRemoveLiquidityIx(
+  cfg: CubeConfig,
+  pool: PoolInfo,
+  params: RemoveLiquidityParams
+): TransactionInstruction {
+  const userBpt = deriveAta(params.user, pool.bptMint, TOKEN_PROGRAM_ID);
+  const mins = params.minimumTokenAmounts ?? pool.tokens.map(() => new BN(0));
+
+  const data = Buffer.concat([
+    CUBIC_POOL_DISC.removeLiquidity,
+    encodeU64(params.bptAmount),
+    encodeVecU64(mins),
+  ]);
+
+  // remove_liquidity remaining_accounts format:
+  //   [vault_i, user_token_i] × N, mint_i × N, token_program_i × N
+  const remaining: AccountMeta[] = [];
+  for (let i = 0; i < pool.tokenCount; i++) {
+    const t = pool.tokens[i];
+    const userAta = deriveAta(params.user, t.mint, t.tokenProgram);
+    remaining.push({ pubkey: t.vault, isSigner: false, isWritable: true });
+    remaining.push({ pubkey: userAta, isSigner: false, isWritable: true });
+  }
+  for (let i = 0; i < pool.tokenCount; i++) {
+    remaining.push({ pubkey: pool.tokens[i].mint, isSigner: false, isWritable: false });
+  }
+  for (let i = 0; i < pool.tokenCount; i++) {
+    remaining.push({ pubkey: pool.tokens[i].tokenProgram, isSigner: false, isWritable: false });
+  }
+
+  const keys: AccountMeta[] = [
+    { pubkey: pool.address, isSigner: false, isWritable: true },
+    { pubkey: pool.bptMint, isSigner: false, isWritable: true },
+    { pubkey: userBpt, isSigner: false, isWritable: true },
+    { pubkey: params.user, isSigner: true, isWritable: true },
+    { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+    ...remaining,
+  ];
+
+  return new TransactionInstruction({
+    programId: cfg.programs.cubicPool,
+    keys,
+    data,
+  });
+}
+
+export function buildRemoveLiquidityTx(
+  cfg: CubeConfig,
+  pool: PoolInfo,
+  params: RemoveLiquidityParams
+): BuiltTx {
+  const ixs: TransactionInstruction[] = [
+    ComputeBudgetProgram.setComputeUnitLimit({ units: cfg.defaults.cuLimit }),
+  ];
+
+  // The contract transfers every pool token to the user's ATA. Include
+  // idempotent creates so a proportional burn works even when the user never
+  // held one of the receive tokens before.
+  for (const t of pool.tokens) {
+    const userAta = deriveAta(params.user, t.mint, t.tokenProgram);
+    ixs.push(
+      createAssociatedTokenAccountIdempotentInstruction(
+        params.user,
+        userAta,
+        params.user,
+        t.mint,
+        t.tokenProgram
+      )
+    );
+  }
+
+  ixs.push(buildRemoveLiquidityIx(cfg, pool, params));
+
+  return {
+    instructions: ixs,
+    suggestedCuLimit: cfg.defaults.cuLimit,
+  };
+}
+
+// ============================================================
+// Single-token deposit (helper program)
+// ============================================================
+
+export function buildSingleTokenDepositIx(
+  cfg: CubeConfig,
+  pool: PoolInfo,
+  params: SingleTokenDepositParams
+): TransactionInstruction {
+  const slip = params.slippageHundredthsBps ?? cfg.defaults.slippageHundredthsBps;
+  const minBpt = requirePositiveMinimumBpt(params.minimumBptAmount, "deposit_single_token");
+  const [helper] = deriveHelperPda(cfg.programs.singleTokenLiquidity, pool.address);
+  const helperBpt = deriveAta(helper, pool.bptMint, TOKEN_PROGRAM_ID);
+  const userBpt = deriveAta(params.user, pool.bptMint, TOKEN_PROGRAM_ID);
+
+  const data = Buffer.concat([
+    STLD_DISC.depositSingleToken,
+    encodeU64(params.amountIn),
+    encodeU8(params.tokenInIndex),
+    encodeU32(slip),
+    encodeU64(minBpt),
+  ]);
+
+  // stld remaining_accounts: [mint_i, user_ata_i, helper_ata_i, vault_i, tp_i] × N
+  const remaining: AccountMeta[] = [];
+  for (let i = 0; i < pool.tokenCount; i++) {
+    const t = pool.tokens[i];
+    const userAta = deriveAta(params.user, t.mint, t.tokenProgram);
+    const helperAta = deriveAta(helper, t.mint, t.tokenProgram);
+    remaining.push({ pubkey: t.mint, isSigner: false, isWritable: false });
+    remaining.push({ pubkey: userAta, isSigner: false, isWritable: true });
+    remaining.push({ pubkey: helperAta, isSigner: false, isWritable: true });
+    remaining.push({ pubkey: t.vault, isSigner: false, isWritable: true });
+    remaining.push({ pubkey: t.tokenProgram, isSigner: false, isWritable: false });
+  }
+
+  const keys: AccountMeta[] = [
+    { pubkey: pool.address, isSigner: false, isWritable: true },
+    { pubkey: helper, isSigner: false, isWritable: false },
+    { pubkey: pool.bptMint, isSigner: false, isWritable: true },
+    { pubkey: helperBpt, isSigner: false, isWritable: true },
+    { pubkey: userBpt, isSigner: false, isWritable: true },
+    { pubkey: params.user, isSigner: true, isWritable: true },
+    { pubkey: cfg.programs.cubicPool, isSigner: false, isWritable: false },
+    { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+    ...remaining,
+  ];
+
+  return new TransactionInstruction({
+    programId: cfg.programs.singleTokenLiquidity,
+    keys,
+    data,
+  });
+}
+
+/**
+ * Full single-token deposit tx: makes sure helper ATAs and the user's
+ * per-token ATAs exist (idempotent create instructions), creates the user's
+ * BPT ATA if absent, then the deposit ix itself. The helper program validates
+ * all user ATAs up front because it may refund dust for any pool token.
+ * CU limit set to 1.4M (mainnet/devnet max).
+ */
+export function buildSingleTokenDepositTx(
+  cfg: CubeConfig,
+  pool: PoolInfo,
+  params: SingleTokenDepositParams
+): BuiltTx {
+  const [helper] = deriveHelperPda(cfg.programs.singleTokenLiquidity, pool.address);
+  const helperBpt = deriveAta(helper, pool.bptMint, TOKEN_PROGRAM_ID);
+  const userBpt = deriveAta(params.user, pool.bptMint, TOKEN_PROGRAM_ID);
+
+  const ixs: TransactionInstruction[] = [
+    ComputeBudgetProgram.setComputeUnitLimit({ units: cfg.defaults.cuLimit }),
+  ];
+  // User + helper ATAs (helper has an off-curve owner). Idempotent — safe to
+  // include even when the accounts already exist.
+  for (const t of pool.tokens) {
+    const userAta = deriveAta(params.user, t.mint, t.tokenProgram);
+    const helperAta = deriveAta(helper, t.mint, t.tokenProgram);
+    ixs.push(
+      createAssociatedTokenAccountIdempotentInstruction(
+        params.user,
+        userAta,
+        params.user,
+        t.mint,
+        t.tokenProgram
+      )
+    );
+    ixs.push(
+      createAssociatedTokenAccountIdempotentInstruction(
+        params.user,
+        helperAta,
+        helper,
+        t.mint,
+        t.tokenProgram
+      )
+    );
+  }
+  ixs.push(
+    createAssociatedTokenAccountIdempotentInstruction(
+      params.user,
+      helperBpt,
+      helper,
+      pool.bptMint,
+      TOKEN_PROGRAM_ID
+    )
+  );
+  ixs.push(
+    createAssociatedTokenAccountIdempotentInstruction(
+      params.user,
+      userBpt,
+      params.user,
+      pool.bptMint,
+      TOKEN_PROGRAM_ID
+    )
+  );
+  ixs.push(buildSingleTokenDepositIx(cfg, pool, params));
+
+  return {
+    instructions: ixs,
+    suggestedCuLimit: cfg.defaults.cuLimit,
+  };
+}
+
+// ============================================================
+// Deploy new pool (PoolFactory)
+// ============================================================
+
+export function buildInitializeConfigIx(
+  cfg: CubeConfig,
+  params: { config: PublicKey; payer: PublicKey; defaultProtocolFeeRate: number }
+): TransactionInstruction {
+  // cubic_pool v0.6.0 initialize_config:
+  //   - the program now enforces `protocol_admin == TreasuryPDA(protocol-admin)`
+  //   - the Treasury PDA is passed as an account; Anchor derives it from
+  //     seeds [b"treasury"] on the protocol-admin program ID and rejects
+  //     anything else, so neither the caller nor the SDK can substitute
+  //     a wallet here. The on-chain `config.protocol_admin` field will
+  //     always be this PDA.
+  const [treasuryPda] = PublicKey.findProgramAddressSync(
+    [Buffer.from("treasury")],
+    cfg.programs.protocolAdmin
+  );
+  const data = Buffer.concat([
+    computeDiscriminator("initialize_config"),
+    treasuryPda.toBuffer(),
+    encodeU16(params.defaultProtocolFeeRate),
+  ]);
+  const keys: AccountMeta[] = [
+    { pubkey: params.config, isSigner: true, isWritable: true },
+    { pubkey: treasuryPda, isSigner: false, isWritable: false },
+    { pubkey: params.payer, isSigner: true, isWritable: true },
+    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+  ];
+  return new TransactionInstruction({
+    programId: cfg.programs.cubicPool,
+    keys,
+    data,
+  });
+}
+
+export function buildInitializeCubicPoolIx(
+  cfg: CubeConfig,
+  params: DeployPoolParams
+): TransactionInstruction {
+  const tokenProgram = params.bptTokenProgram ?? TOKEN_PROGRAM_ID;
+  const [pool] = PublicKey.findProgramAddressSync(
+    [Buffer.from("cubic_pool"), params.configKey.toBuffer(), params.poolId.toArrayLike(Buffer, "le", 8)],
+    cfg.programs.cubicPool
+  );
+  const [bptMint] = deriveBptMint(cfg.programs.cubicPool, pool);
+
+  const data = Buffer.concat([
+    CUBIC_POOL_DISC.initializeCubicPool,
+    encodeVecPubkey(params.tokens),
+    encodeVecU64(params.weightsBps.map((w) => new BN(w))),
+    encodeVecU64(params.virtualBalances),
+    encodeU32(params.swapFeeRate),
+    encodeU64(params.poolId),
+  ]);
+
+  const remaining: AccountMeta[] = params.tokens.map((m) => ({
+    pubkey: m,
+    isSigner: false,
+    isWritable: false,
+  }));
+
+  const keys: AccountMeta[] = [
+    { pubkey: params.configKey, isSigner: false, isWritable: false },
+    { pubkey: pool, isSigner: false, isWritable: true },
+    { pubkey: bptMint, isSigner: false, isWritable: true },
+    { pubkey: params.payer, isSigner: true, isWritable: true },
+    { pubkey: tokenProgram, isSigner: false, isWritable: false },
+    { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+    ...remaining,
+  ];
+
+  return new TransactionInstruction({
+    programId: cfg.programs.cubicPool,
+    keys,
+    data,
+  });
+}
+
+export function buildDeployPoolTx(cfg: CubeConfig, params: DeployPoolParams): BuiltTx {
+  return {
+    instructions: [
+      ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 }),
+      buildInitializeCubicPoolIx(cfg, params),
+    ],
+    suggestedCuLimit: 400_000,
+  };
+}
+
+// ============================================================
+// Borsh encoding helpers (subset used above)
+// ============================================================
+
+function encodeU8(v: number): Buffer {
+  const b = Buffer.alloc(1);
+  b.writeUInt8(v & 0xff, 0);
+  return b;
+}
+function encodeU16(v: number): Buffer {
+  const b = Buffer.alloc(2);
+  b.writeUInt16LE(v & 0xffff, 0);
+  return b;
+}
+function encodeU32(v: number): Buffer {
+  const b = Buffer.alloc(4);
+  b.writeUInt32LE(v >>> 0, 0);
+  return b;
+}
+function encodeU64(v: BN): Buffer {
+  return v.toArrayLike(Buffer, "le", 8);
+}
+function encodeVecU64(vs: BN[]): Buffer {
+  const len = Buffer.alloc(4);
+  len.writeUInt32LE(vs.length, 0);
+  return Buffer.concat([len, ...vs.map(encodeU64)]);
+}
+function encodeVecPubkey(pks: PublicKey[]): Buffer {
+  const len = Buffer.alloc(4);
+  len.writeUInt32LE(pks.length, 0);
+  return Buffer.concat([len, ...pks.map((p) => p.toBuffer())]);
+}

package/src/config/index.ts

@@ -0,0 +1,82 @@
+import { Commitment, PublicKey } from "@solana/web3.js";
+import { NETWORK_PROGRAMS, NetworkPrograms, Network, DEFAULT_RPC_ENDPOINT } from "./networks";
+import { TokenInfo } from "./tokens";
+
+export * from "./networks";
+export * from "./tokens";
+
+/**
+ * Root SDK configuration. Passed into every Client class at construction.
+ * Immutable after creation — rebuild if you need to switch networks.
+ */
+export interface CubeConfig {
+  network: Network;
+  programs: NetworkPrograms;
+  defaults: {
+    rpcEndpoint: string;
+    rpcCommitment: Commitment;
+    /** Used by helpers that prepend a ComputeBudget instruction. */
+    cuLimit: number;
+    /**
+     * Default slippage budget when the caller doesn't pass one. Units:
+     * hundredths of a basis point (matches cubic-pool's `swap_fee_rate`
+     * scale). 50_000 = 5%.
+     */
+    slippageHundredthsBps: number;
+  };
+  /** Optional token registry keyed by mint pubkey string. */
+  tokens?: Record<string, TokenInfo>;
+  /** Optional backend endpoint; consumed by CubeBackendClient. */
+  backendEndpoint?: string;
+}
+
+export interface CubeConfigOverrides {
+  rpcEndpoint?: string;
+  rpcCommitment?: Commitment;
+  cuLimit?: number;
+  slippageHundredthsBps?: number;
+  backendEndpoint?: string;
+  tokens?: Record<string, TokenInfo>;
+}
+
+/** Build a CubeConfig for the named network with optional overrides. */
+export function getConfig(network: Network, overrides: CubeConfigOverrides = {}): CubeConfig {
+  return {
+    network,
+    programs: NETWORK_PROGRAMS[network],
+    defaults: {
+      rpcEndpoint: overrides.rpcEndpoint ?? DEFAULT_RPC_ENDPOINT[network],
+      rpcCommitment: overrides.rpcCommitment ?? "confirmed",
+      cuLimit: overrides.cuLimit ?? 1_400_000,
+      slippageHundredthsBps: overrides.slippageHundredthsBps ?? 50_000,
+    },
+    tokens: overrides.tokens,
+    backendEndpoint: overrides.backendEndpoint,
+  };
+}
+
+export const CUBIC_POOL_SEED = Buffer.from("cubic_pool");
+export const BPT_MINT_SEED = Buffer.from("bpt_mint");
+export const STLD_HELPER_SEED = Buffer.from("stld_helper");
+export const TREASURY_SEED = Buffer.from("treasury");
+
+/** Contract-level constants mirrored from Rust. */
+export const WEIGHT_SCALE = 10_000; // 100 %
+export const MIN_WEIGHT = 100; // 1 %
+export const MAX_WEIGHT = 9_900; // 99 %
+export const MIN_TOKENS = 2;
+export const MAX_TOKENS = 10;
+export const BPT_DECIMALS = 9;
+export const SWAP_FEE_PRECISION = 1_000_000; // 100 %
+export const PROTOCOL_FEE_PRECISION = 10_000; // 100 %
+export const MAX_SWAP_FEE_RATE = 100_000; // 10 %
+export const MAX_PROTOCOL_FEE_RATE = 5_000; // 50 %
+export const MINIMUM_INITIAL_BPT = 1_000n;
+export const SLIPPAGE_PRECISION = 1_000_000;
+export const MIN_SLIPPAGE_HBPS = 10; // 0.001 %
+
+export type ProgramIdKind = "cubicPool" | "singleTokenLiquidity" | "protocolAdmin";
+
+export function programId(cfg: CubeConfig, kind: ProgramIdKind): PublicKey {
+  return cfg.programs[kind];
+}

package/src/config/networks.ts

@@ -0,0 +1,49 @@
+import { PublicKey } from "@solana/web3.js";
+
+export type Network = "mainnet" | "devnet" | "localnet";
+
+export interface NetworkPrograms {
+  cubicPool: PublicKey;
+  singleTokenLiquidity: PublicKey;
+  protocolAdmin: PublicKey;
+}
+
+export const NETWORK_PROGRAMS: Record<Network, NetworkPrograms> = {
+  mainnet: {
+    cubicPool: new PublicKey("8iQtGj9mcUfFUGaiCpPy89swC3s8YTC8FhVZWfgeZhwu"),
+    // TODO(mainnet): single_token_liquidity is NOT deployed on mainnet — this
+    // is the devnet program ID as a placeholder. Single-token deposit is
+    // disabled in the frontend. If/when stld ships on mainnet, replace this
+    // with the real mainnet program ID.
+    singleTokenLiquidity: new PublicKey(
+      "7BpdUH1tzTSXLuQNo6YpjJ8Eagw8AkrS6cnkxiJdCFS2"
+    ),
+    protocolAdmin: new PublicKey(
+      "3jiojHZbjJQ7QLMGSTjFwxVEmx4NtuRy34nLAmsJME81"
+    ),
+  },
+  devnet: {
+    cubicPool: new PublicKey("8iQtGj9mcUfFUGaiCpPy89swC3s8YTC8FhVZWfgeZhwu"),
+    singleTokenLiquidity: new PublicKey(
+      "7BpdUH1tzTSXLuQNo6YpjJ8Eagw8AkrS6cnkxiJdCFS2"
+    ),
+    protocolAdmin: new PublicKey(
+      "3jiojHZbjJQ7QLMGSTjFwxVEmx4NtuRy34nLAmsJME81"
+    ),
+  },
+  localnet: {
+    cubicPool: new PublicKey("8iQtGj9mcUfFUGaiCpPy89swC3s8YTC8FhVZWfgeZhwu"),
+    singleTokenLiquidity: new PublicKey(
+      "7BpdUH1tzTSXLuQNo6YpjJ8Eagw8AkrS6cnkxiJdCFS2"
+    ),
+    protocolAdmin: new PublicKey(
+      "3jiojHZbjJQ7QLMGSTjFwxVEmx4NtuRy34nLAmsJME81"
+    ),
+  },
+};
+
+export const DEFAULT_RPC_ENDPOINT: Record<Network, string> = {
+  mainnet: "https://api.mainnet-beta.solana.com",
+  devnet: "https://api.devnet.solana.com",
+  localnet: "http://127.0.0.1:8899",
+};