@cubee_ee/sdk 0.1.8 → 0.2.3

package/src/clients/tx-builders.ts

@@ -1,5 +1,6 @@
 import {
   AccountMeta,
+  AddressLookupTableProgram,
   ComputeBudgetProgram,
   PublicKey,
   SystemProgram,
@@ -34,6 +35,7 @@ const CUBIC_POOL_DISC = {
   addLiquidity: computeDiscriminator("add_liquidity"),
   removeLiquidity: computeDiscriminator("remove_liquidity"),
   initializeCubicPool: computeDiscriminator("initialize_cubic_pool"),
+  initializePoolAlt: computeDiscriminator("initialize_pool_alt"),
 };
 
 const STLD_DISC = {
@@ -62,6 +64,7 @@ function computeDiscriminator(ixName: string): Buffer {
     add_liquidity: "b59d59438fb63448",
     remove_liquidity: "5055d14818ceb16c",
     initialize_cubic_pool: "d79474cf79686f83",
+    initialize_pool_alt: "fb874202f4490c90",
     deposit_single_token: "a688a62fc7c056a9",
     initialize_config: "d07f1501c2bec446",
   };
@@ -504,6 +507,103 @@ export function buildDeployPoolTx(cfg: CubeConfig, params: DeployPoolParams): Bu
   };
 }
 
+// ============================================================
+// initialize_pool_alt — per-pool Address Lookup Table
+// ============================================================
+
+export interface InitializePoolAltParams {
+  /** Pool PDA. */
+  pool: PublicKey;
+  /** `CubicPoolConfig` account this pool is pinned to. Read by the
+   *  program to gate the alternative-authority path (`config.protocol_admin`). */
+  config: PublicKey;
+  /** Authority. Must equal either `pool.pool_admin` (per-pool owner
+   *  path) or `config.protocol_admin` (Treasury PDA via the
+   *  protocol-admin CPI wrapper). The ALT address is derived from
+   *  `[authority, recent_slot]`. */
+  authority: PublicKey;
+  /** Rent payer. Decoupled from `authority` so the wrapper path can
+   *  pay from a regular wallet while Treasury PDA acts as authority.
+   *  In the pool-admin path pass the same key for both. */
+  payer: PublicKey;
+  /**
+   * Recent slot. Used by the upstream ALT program to derive the table
+   * address as `[authority, recent_slot]`. Must be a slot the runtime
+   * still has in slot-hashes — caller should pass
+   * `await connection.getSlot('finalized')`.
+   */
+  recentSlot: BN;
+}
+
+/**
+ * Re-derives the Address Lookup Table address from `(authority, recent_slot)`
+ * the same way the upstream ALT program does.
+ *
+ * `@solana/web3.js` v1 doesn't expose `deriveLookupTableAddress` as a static,
+ * so we inline the seed derivation.
+ */
+export function deriveAltAddress(authority: PublicKey, recentSlot: BN): PublicKey {
+  const slotBuf = recentSlot.toArrayLike(Buffer, "le", 8);
+  const [addr] = PublicKey.findProgramAddressSync(
+    [authority.toBuffer(), slotBuf],
+    AddressLookupTableProgram.programId,
+  );
+  return addr;
+}
+
+/**
+ * Build the on-chain `initialize_pool_alt` instruction. Performs three
+ * upstream CPIs inside the program: create + extend + freeze. After
+ * this ix lands, the ALT is immutable and the pool's `lookup_table`
+ * field points at it.
+ *
+ * Caller must NOT use the ALT in the same slot (warmup) — wait at
+ * least one slot before sending any v0 tx that references it.
+ */
+export function buildInitializePoolAltIx(
+  cfg: CubeConfig,
+  params: InitializePoolAltParams,
+): TransactionInstruction {
+  const altAddr = deriveAltAddress(params.authority, params.recentSlot);
+
+  const data = Buffer.concat([
+    CUBIC_POOL_DISC.initializePoolAlt,
+    encodeU64(params.recentSlot),
+  ]);
+
+  // Account order MUST match cubic-pool's InitializePoolAlt context:
+  //   pool, config, authority, payer, lookup_table, system_program, alt_program.
+  const keys: AccountMeta[] = [
+    { pubkey: params.pool, isSigner: false, isWritable: true },
+    { pubkey: params.config, isSigner: false, isWritable: false },
+    { pubkey: params.authority, isSigner: true, isWritable: false },
+    { pubkey: params.payer, isSigner: true, isWritable: true },
+    { pubkey: altAddr, isSigner: false, isWritable: true },
+    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+    { pubkey: AddressLookupTableProgram.programId, isSigner: false, isWritable: false },
+  ];
+
+  return new TransactionInstruction({
+    programId: cfg.programs.cubicPool,
+    keys,
+    data,
+  });
+}
+
+export function buildInitializePoolAltTx(
+  cfg: CubeConfig,
+  params: InitializePoolAltParams,
+): BuiltTx & { lookupTable: PublicKey } {
+  return {
+    instructions: [
+      ComputeBudgetProgram.setComputeUnitLimit({ units: 200_000 }),
+      buildInitializePoolAltIx(cfg, params),
+    ],
+    suggestedCuLimit: 200_000,
+    lookupTable: deriveAltAddress(params.authority, params.recentSlot),
+  };
+}
+
 // ============================================================
 // Borsh encoding helpers (subset used above)
 // ============================================================

package/src/clients/versioned.ts

@@ -0,0 +1,80 @@
+import {
+  AddressLookupTableAccount,
+  Connection,
+  PublicKey,
+  TransactionInstruction,
+  TransactionMessage,
+  VersionedTransaction,
+} from "@solana/web3.js";
+import { PoolInfo } from "../types/pool";
+import { BuiltTx } from "../types/tx";
+import { SdkResult, err, ok } from "../types/result";
+
+/**
+ * Compile a set of instructions into a `VersionedTransaction` (v0),
+ * optionally using a per-pool Address Lookup Table to shrink the wire
+ * size below the 1232-byte legacy ceiling.
+ *
+ * ALT inclusion rules:
+ *   - If `lookupTable` is `PublicKey.default` (or undefined) → no ALT
+ *     is referenced; the tx is v0 but uses only static account keys.
+ *   - Otherwise → fetch the ALT via `connection.getAddressLookupTable`
+ *     and include it. If the fetch fails, the function returns an
+ *     `alt_fetch_failed` error rather than silently falling back.
+ *
+ * Wallets supporting the standard `signTransaction(Transaction |
+ * VersionedTransaction)` overload (Phantom, Solflare, Backpack, Glow,
+ * the wallet-adapter set since 2023) sign these without changes.
+ */
+export async function buildVersionedTx(
+  conn: Connection,
+  payer: PublicKey,
+  instructions: TransactionInstruction[],
+  lookupTable: PublicKey | undefined,
+): Promise<SdkResult<{ tx: VersionedTransaction; alts: AddressLookupTableAccount[] }>> {
+  const alts: AddressLookupTableAccount[] = [];
+
+  if (lookupTable && !lookupTable.equals(PublicKey.default)) {
+    try {
+      const res = await conn.getAddressLookupTable(lookupTable);
+      if (!res.value) {
+        return err(
+          "alt_fetch_failed",
+          `Lookup table ${lookupTable.toBase58()} not found on-chain. ` +
+            "The pool advertises an ALT but the account is missing — " +
+            "the ALT may have been closed or the RPC is stale.",
+        );
+      }
+      alts.push(res.value);
+    } catch (e) {
+      return err(
+        "alt_fetch_failed",
+        `Failed to fetch lookup table ${lookupTable.toBase58()}`,
+        e,
+      );
+    }
+  }
+
+  const { blockhash } = await conn.getLatestBlockhash("confirmed");
+  const msg = new TransactionMessage({
+    payerKey: payer,
+    recentBlockhash: blockhash,
+    instructions,
+  }).compileToV0Message(alts);
+
+  return ok({ tx: new VersionedTransaction(msg), alts });
+}
+
+/**
+ * Convenience: take a SDK-built `BuiltTx` and a pool snapshot, produce
+ * a signed-ready `VersionedTransaction`. Picks up `pool.lookupTable`
+ * automatically.
+ */
+export async function compileBuiltTx(
+  conn: Connection,
+  payer: PublicKey,
+  built: BuiltTx,
+  pool: Pick<PoolInfo, "lookupTable">,
+): Promise<SdkResult<{ tx: VersionedTransaction; alts: AddressLookupTableAccount[] }>> {
+  return buildVersionedTx(conn, payer, built.instructions, pool.lookupTable);
+}

package/src/config/networks.ts

@@ -16,41 +16,41 @@ export const NETWORK_PROGRAMS: Record<Network, NetworkPrograms> = {
     // disabled in the frontend. If/when stld ships on mainnet, replace this
     // with the real mainnet program ID.
     singleTokenLiquidity: new PublicKey(
-      "7BpdUH1tzTSXLuQNo6YpjJ8Eagw8AkrS6cnkxiJdCFS2"
+      "7BpdUH1tzTSXLuQNo6YpjJ8Eagw8AkrS6cnkxiJdCFS2",
     ),
     protocolAdmin: new PublicKey(
-      "3jiojHZbjJQ7QLMGSTjFwxVEmx4NtuRy34nLAmsJME81"
+      "3jiojHZbjJQ7QLMGSTjFwxVEmx4NtuRy34nLAmsJME81",
     ),
   },
   devnet: {
     cubicPool: new PublicKey("8iQtGj9mcUfFUGaiCpPy89swC3s8YTC8FhVZWfgeZhwu"),
     singleTokenLiquidity: new PublicKey(
-      "7BpdUH1tzTSXLuQNo6YpjJ8Eagw8AkrS6cnkxiJdCFS2"
+      "7BpdUH1tzTSXLuQNo6YpjJ8Eagw8AkrS6cnkxiJdCFS2",
     ),
     protocolAdmin: new PublicKey(
-      "3jiojHZbjJQ7QLMGSTjFwxVEmx4NtuRy34nLAmsJME81"
+      "3jiojHZbjJQ7QLMGSTjFwxVEmx4NtuRy34nLAmsJME81",
     ),
   },
   localnet: {
     cubicPool: new PublicKey("8iQtGj9mcUfFUGaiCpPy89swC3s8YTC8FhVZWfgeZhwu"),
     singleTokenLiquidity: new PublicKey(
-      "7BpdUH1tzTSXLuQNo6YpjJ8Eagw8AkrS6cnkxiJdCFS2"
+      "7BpdUH1tzTSXLuQNo6YpjJ8Eagw8AkrS6cnkxiJdCFS2",
     ),
     protocolAdmin: new PublicKey(
-      "3jiojHZbjJQ7QLMGSTjFwxVEmx4NtuRy34nLAmsJME81"
+      "3jiojHZbjJQ7QLMGSTjFwxVEmx4NtuRy34nLAmsJME81",
     ),
   },
 };
 
 export const DEFAULT_RPC_ENDPOINT: Record<Network, string> = {
-  mainnet: "https://api.mainnet-beta.solana.com",
+  mainnet: "https://solana.drpc.org",
   devnet: "https://api.devnet.solana.com",
   localnet: "http://127.0.0.1:8899",
 };
 
 export const DEFAULT_RPC_ENDPOINTS: Record<Network, string[]> = {
   mainnet: [
-    "https://api.mainnet-beta.solana.com",
+    "https://solana.drpc.org",
     "https://solana-rpc.publicnode.com",
     "https://solana.api.pocket.network",
   ],