nara-sdk 1.0.45 → 1.0.49

package/index.ts

@@ -34,8 +34,8 @@ export {
   unstake,
   getStakeInfo,
   initializeQuest,
-  setMaxRewardCount,
-  setMinRewardCount,
+  setRewardConfig,
+  setStakeConfig,
   transferQuestAuthority,
   getQuestConfig,
   type QuestInfo,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nara-sdk",
-  "version": "1.0.45",
+  "version": "1.0.49",
   "description": "SDK for the Nara chain (Solana-compatible)",
   "module": "index.ts",
   "main": "index.ts",

package/src/constants.ts

@@ -39,8 +39,9 @@ export const DEFAULT_AGENT_REGISTRY_PROGRAM_ID =
   process.env.AGENT_REGISTRY_PROGRAM_ID || "AgentRegistry111111111111111111111111111111";
 
 /**
- * Address Lookup Table address for transaction optimization.
- * When set, all SDK transactions use VersionedTransaction with this ALT.
+ * Address Lookup Table addresses for transaction optimization.
+ * Supports comma-separated list for multiple ALTs.
+ * When set, all SDK transactions use VersionedTransaction with these ALTs.
  * When empty, uses legacy transactions.
  */
-export const DEFAULT_ALT_ADDRESS = process.env.ALT_ADDRESS || "";
+export const DEFAULT_ALT_ADDRESS = process.env.ALT_ADDRESS || "7u3uwQof8YnTrdYE2ZXgAYQLsDxW9cEJjqC3zJHrZXGo";

package/src/idls/nara_quest.json

@@ -204,16 +204,16 @@
       "args": []
     },
     {
-      "name": "set_max_reward_count",
+      "name": "set_reward_config",
       "discriminator": [
-        247,
-        62,
-        67,
-        243,
-        249,
-        243,
-        102,
-        62
+        163,
+        34,
+        211,
+        14,
+        25,
+        118,
+        181,
+        233
       ],
       "accounts": [
         {
@@ -247,6 +247,10 @@
         }
       ],
       "args": [
+        {
+          "name": "min_reward_count",
+          "type": "u32"
+        },
         {
           "name": "max_reward_count",
           "type": "u32"
@@ -254,16 +258,16 @@
       ]
     },
     {
-      "name": "set_min_reward_count",
+      "name": "set_stake_config",
       "discriminator": [
-        108,
-        213,
-        24,
-        47,
-        93,
-        149,
-        58,
-        4
+        84,
+        37,
+        76,
+        39,
+        236,
+        111,
+        214,
+        191
       ],
       "accounts": [
         {
@@ -298,8 +302,16 @@
       ],
       "args": [
         {
-          "name": "min_reward_count",
-          "type": "u32"
+          "name": "bps_high",
+          "type": "u64"
+        },
+        {
+          "name": "bps_low",
+          "type": "u64"
+        },
+        {
+          "name": "decay_ms",
+          "type": "i64"
         }
       ]
     },
@@ -498,6 +510,30 @@
         48
       ],
       "accounts": [
+        {
+          "name": "game_config",
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  113,
+                  117,
+                  101,
+                  115,
+                  116,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              }
+            ]
+          }
+        },
         {
           "name": "pool",
           "writable": true,
@@ -1192,12 +1228,12 @@
     {
       "code": 6008,
       "name": "InvalidMinRewardCount",
-      "msg": "min_reward_count must be > 0 and <= max_reward_count"
+      "msg": "Invalid reward config: need 0 < min <= max"
     },
     {
       "code": 6009,
-      "name": "InvalidMaxRewardCount",
-      "msg": "max_reward_count must be >= min_reward_count"
+      "name": "InvalidStakeConfig",
+      "msg": "Stake config values must be > 0"
     },
     {
       "code": 6010,
@@ -1208,6 +1244,11 @@
       "code": 6011,
       "name": "InsufficientStakeBalance",
       "msg": "Unstake amount exceeds staked balance"
+    },
+    {
+      "code": 6012,
+      "name": "InsufficientStake",
+      "msg": "Stake does not meet dynamic requirement"
     }
   ],
   "types": [
@@ -1260,6 +1301,18 @@
             "name": "max_reward_count",
             "type": "u32"
           },
+          {
+            "name": "stake_bps_high",
+            "type": "u64"
+          },
+          {
+            "name": "stake_bps_low",
+            "type": "u64"
+          },
+          {
+            "name": "decay_ms",
+            "type": "i64"
+          },
           {
             "name": "_padding",
             "type": {
@@ -1319,11 +1372,19 @@
             "type": "u32"
           },
           {
-            "name": "stake_requirement",
+            "name": "created_at",
+            "type": "i64"
+          },
+          {
+            "name": "stake_high",
+            "type": "u64"
+          },
+          {
+            "name": "stake_low",
             "type": "u64"
           },
           {
-            "name": "min_winner_stake",
+            "name": "avg_participant_stake",
             "type": "u64"
           },
           {

package/src/idls/nara_quest.ts

@@ -210,16 +210,16 @@ export type NaraQuest = {
       "args": []
     },
     {
-      "name": "setMaxRewardCount",
+      "name": "setRewardConfig",
       "discriminator": [
-        247,
-        62,
-        67,
-        243,
-        249,
-        243,
-        102,
-        62
+        163,
+        34,
+        211,
+        14,
+        25,
+        118,
+        181,
+        233
       ],
       "accounts": [
         {
@@ -253,6 +253,10 @@ export type NaraQuest = {
         }
       ],
       "args": [
+        {
+          "name": "minRewardCount",
+          "type": "u32"
+        },
         {
           "name": "maxRewardCount",
           "type": "u32"
@@ -260,16 +264,16 @@ export type NaraQuest = {
       ]
     },
     {
-      "name": "setMinRewardCount",
+      "name": "setStakeConfig",
       "discriminator": [
-        108,
-        213,
-        24,
-        47,
-        93,
-        149,
-        58,
-        4
+        84,
+        37,
+        76,
+        39,
+        236,
+        111,
+        214,
+        191
       ],
       "accounts": [
         {
@@ -304,8 +308,16 @@ export type NaraQuest = {
       ],
       "args": [
         {
-          "name": "minRewardCount",
-          "type": "u32"
+          "name": "bpsHigh",
+          "type": "u64"
+        },
+        {
+          "name": "bpsLow",
+          "type": "u64"
+        },
+        {
+          "name": "decayMs",
+          "type": "i64"
         }
       ]
     },
@@ -504,6 +516,30 @@ export type NaraQuest = {
         48
       ],
       "accounts": [
+        {
+          "name": "gameConfig",
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  113,
+                  117,
+                  101,
+                  115,
+                  116,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              }
+            ]
+          }
+        },
         {
           "name": "pool",
           "writable": true,
@@ -1198,12 +1234,12 @@ export type NaraQuest = {
     {
       "code": 6008,
       "name": "invalidMinRewardCount",
-      "msg": "min_reward_count must be > 0 and <= max_reward_count"
+      "msg": "Invalid reward config: need 0 < min <= max"
     },
     {
       "code": 6009,
-      "name": "invalidMaxRewardCount",
-      "msg": "max_reward_count must be >= min_reward_count"
+      "name": "invalidStakeConfig",
+      "msg": "Stake config values must be > 0"
     },
     {
       "code": 6010,
@@ -1214,6 +1250,11 @@ export type NaraQuest = {
       "code": 6011,
       "name": "insufficientStakeBalance",
       "msg": "Unstake amount exceeds staked balance"
+    },
+    {
+      "code": 6012,
+      "name": "insufficientStake",
+      "msg": "Stake does not meet dynamic requirement"
     }
   ],
   "types": [
@@ -1266,6 +1307,18 @@ export type NaraQuest = {
             "name": "maxRewardCount",
             "type": "u32"
           },
+          {
+            "name": "stakeBpsHigh",
+            "type": "u64"
+          },
+          {
+            "name": "stakeBpsLow",
+            "type": "u64"
+          },
+          {
+            "name": "decayMs",
+            "type": "i64"
+          },
           {
             "name": "padding",
             "type": {
@@ -1325,11 +1378,19 @@ export type NaraQuest = {
             "type": "u32"
           },
           {
-            "name": "stakeRequirement",
+            "name": "createdAt",
+            "type": "i64"
+          },
+          {
+            "name": "stakeHigh",
+            "type": "u64"
+          },
+          {
+            "name": "stakeLow",
             "type": "u64"
           },
           {
-            "name": "minWinnerStake",
+            "name": "avgParticipantStake",
             "type": "u64"
           },
           {

package/src/quest.ts

@@ -50,10 +50,16 @@ export interface QuestInfo {
   deadline: number;
   timeRemaining: number;
   expired: boolean;
-  /** Minimum stake required to submit an answer (in NARA) */
-  stakeRequirement: number;
-  /** Minimum stake to be eligible for rewards (in NARA) */
-  minWinnerStake: number;
+  /** High stake requirement for the current round (in NARA, decays over time) */
+  stakeHigh: number;
+  /** Low stake requirement for the current round (in NARA, floor after decay) */
+  stakeLow: number;
+  /** Running average participant stake for the current round (in NARA) */
+  avgParticipantStake: number;
+  /** Unix timestamp when the current question was created */
+  createdAt: number;
+  /** Current effective stake requirement after parabolic decay (in NARA) */
+  effectiveStakeRequirement: number;
 }
 
 export interface StakeInfo {
@@ -242,6 +248,26 @@ function getStakeTokenAccount(stakeRecordPda: PublicKey): PublicKey {
   return getAssociatedTokenAddressSync(WSOL_MINT, stakeRecordPda, true);
 }
 
+/**
+ * Compute the effective stake requirement using the parabolic decay formula.
+ * effective = stakeHigh - (stakeHigh - stakeLow) * (elapsed / decay)^2
+ * All amounts in NARA (not lamports). Times in milliseconds.
+ */
+function computeEffectiveStake(
+  stakeHigh: number,
+  stakeLow: number,
+  createdAt: number,
+  decayMs: number,
+  nowMs: number
+): number {
+  if (decayMs <= 0) return stakeLow;
+  const elapsedMs = nowMs - createdAt;
+  if (elapsedMs >= decayMs) return stakeLow;
+  const range = stakeHigh - stakeLow;
+  const ratio = elapsedMs / decayMs;
+  return stakeHigh - range * ratio * ratio;
+}
+
 // ─── SDK functions ───────────────────────────────────────────────
 
 /**
@@ -263,6 +289,26 @@ export async function getQuestInfo(
 
   const active = pool.question.length > 0 && secsLeft > 0;
 
+  const stakeHigh = Number(pool.stakeHigh.toString()) / LAMPORTS_PER_SOL;
+  const stakeLow = Number(pool.stakeLow.toString()) / LAMPORTS_PER_SOL;
+  const createdAt = pool.createdAt.toNumber();
+
+  // Fetch decayMs from GameConfig for effective calculation
+  const programId = new PublicKey(options?.programId ?? DEFAULT_QUEST_PROGRAM_ID);
+  const [configPda] = PublicKey.findProgramAddressSync(
+    [new TextEncoder().encode("quest_config")],
+    programId
+  );
+  const config = await program.account.gameConfig.fetch(configPda);
+  const decayMs = Number(config.decayMs.toString());
+
+  // createdAt is unix timestamp (seconds), convert to ms for decay calculation
+  const nowMs = Date.now();
+  const createdAtMs = createdAt * 1000;
+  const effectiveStakeRequirement = computeEffectiveStake(
+    stakeHigh, stakeLow, createdAtMs, decayMs, nowMs
+  );
+
   return {
     active,
     round: pool.round.toString(),
@@ -277,8 +323,11 @@ export async function getQuestInfo(
     deadline,
     timeRemaining: secsLeft,
     expired: secsLeft <= 0,
-    stakeRequirement: Number(pool.stakeRequirement.toString()) / LAMPORTS_PER_SOL,
-    minWinnerStake: Number(pool.minWinnerStake.toString()) / LAMPORTS_PER_SOL,
+    stakeHigh,
+    stakeLow,
+    avgParticipantStake: Number(pool.avgParticipantStake.toString()) / LAMPORTS_PER_SOL,
+    createdAt,
+    effectiveStakeRequirement,
   };
 }
 
@@ -372,7 +421,7 @@ export async function submitAnswer(
     if (options.stake === "auto") {
       const quest = await getQuestInfo(connection, wallet, options);
       const stakeInfo = await getStakeInfo(connection, wallet.publicKey, options);
-      const required = quest.stakeRequirement;
+      const required = quest.effectiveStakeRequirement;
       const current = stakeInfo?.amount ?? 0;
       const deficit = required - current;
       if (deficit > 0) {
@@ -649,34 +698,40 @@ export async function initializeQuest(
 }
 
 /**
- * Set the maximum reward count (authority only).
+ * Set the reward config (authority only).
  */
-export async function setMaxRewardCount(
+export async function setRewardConfig(
   connection: Connection,
   wallet: Keypair,
+  minRewardCount: number,
   maxRewardCount: number,
   options?: QuestOptions
 ): Promise<string> {
   const program = createProgram(connection, wallet, options?.programId);
   const ix = await program.methods
-    .setMaxRewardCount(maxRewardCount)
+    .setRewardConfig(minRewardCount, maxRewardCount)
     .accounts({ authority: wallet.publicKey } as any)
     .instruction();
   return sendTx(connection, wallet, [ix]);
 }
 
 /**
- * Set the minimum reward count (authority only).
+ * Set the stake config (authority only).
+ * @param bpsHigh - Upper bound multiplier in basis points (e.g. 100000 = 10x average)
+ * @param bpsLow - Lower bound multiplier in basis points (e.g. 1000 = 0.1x average)
+ * @param decayMs - Time window in milliseconds for parabolic decay from high to low
  */
-export async function setMinRewardCount(
+export async function setStakeConfig(
   connection: Connection,
   wallet: Keypair,
-  minRewardCount: number,
+  bpsHigh: number,
+  bpsLow: number,
+  decayMs: number,
   options?: QuestOptions
 ): Promise<string> {
   const program = createProgram(connection, wallet, options?.programId);
   const ix = await program.methods
-    .setMinRewardCount(minRewardCount)
+    .setStakeConfig(new BN(bpsHigh), new BN(bpsLow), new BN(decayMs))
     .accounts({ authority: wallet.publicKey } as any)
     .instruction();
   return sendTx(connection, wallet, [ix]);
@@ -705,7 +760,14 @@ export async function transferQuestAuthority(
 export async function getQuestConfig(
   connection: Connection,
   options?: QuestOptions
-): Promise<{ authority: PublicKey; minRewardCount: number; maxRewardCount: number }> {
+): Promise<{
+  authority: PublicKey;
+  minRewardCount: number;
+  maxRewardCount: number;
+  stakeBpsHigh: number;
+  stakeBpsLow: number;
+  decayMs: number;
+}> {
   const kp = Keypair.generate();
   const program = createProgram(connection, kp, options?.programId);
   const programId = new PublicKey(options?.programId ?? DEFAULT_QUEST_PROGRAM_ID);
@@ -718,5 +780,8 @@ export async function getQuestConfig(
     authority: config.authority,
     minRewardCount: config.minRewardCount,
     maxRewardCount: config.maxRewardCount,
+    stakeBpsHigh: Number(config.stakeBpsHigh.toString()),
+    stakeBpsLow: Number(config.stakeBpsLow.toString()),
+    decayMs: Number(config.decayMs.toString()),
   };
 }

package/src/tx.ts

@@ -1,8 +1,8 @@
 /**
  * Shared transaction sending utility with optional Address Lookup Table support.
  *
- * When DEFAULT_ALT_ADDRESS is set, transactions are sent as VersionedTransaction
- * with the ALT for smaller on-chain size. Otherwise, legacy Transaction is used.
+ * When ALT addresses are configured, transactions are sent as VersionedTransaction
+ * with ALTs for smaller on-chain size. Otherwise, legacy Transaction is used.
  */
 
 import {
@@ -18,44 +18,63 @@ import {
 } from "@solana/web3.js";
 import { DEFAULT_ALT_ADDRESS } from "./constants";
 
-let _cachedAlt: AddressLookupTableAccount | null = null;
-let _cachedAltAddress: string = "";
-let _overrideAltAddress: string | null = null;
+let _cachedAlts: AddressLookupTableAccount[] = [];
+let _cachedAltKey: string = "";
+let _overrideAltAddresses: string[] | null = null;
 
 /**
- * Set a global ALT address at runtime (overrides DEFAULT_ALT_ADDRESS / env).
- * Pass empty string or null to disable ALT.
+ * Set global ALT addresses at runtime (overrides DEFAULT_ALT_ADDRESS / env).
+ * Pass empty array or null to disable ALT.
  */
-export function setAltAddress(address: string | null): void {
-  _overrideAltAddress = address;
-  // Invalidate cache when address changes
-  _cachedAlt = null;
-  _cachedAltAddress = "";
+export function setAltAddress(addresses: string | string[] | null): void {
+  if (addresses === null) {
+    _overrideAltAddresses = [];
+  } else if (typeof addresses === "string") {
+    _overrideAltAddresses = addresses ? [addresses] : [];
+  } else {
+    _overrideAltAddresses = addresses.filter(Boolean);
+  }
+  // Invalidate cache when addresses change
+  _cachedAlts = [];
+  _cachedAltKey = "";
 }
 
 /**
- * Get the current effective ALT address.
+ * Get the current effective ALT addresses.
  */
-export function getAltAddress(): string {
-  return _overrideAltAddress ?? DEFAULT_ALT_ADDRESS;
+export function getAltAddress(): string[] {
+  if (_overrideAltAddresses !== null) return _overrideAltAddresses;
+  if (!DEFAULT_ALT_ADDRESS) return [];
+  // env supports comma-separated list
+  return DEFAULT_ALT_ADDRESS.split(",").map((s) => s.trim()).filter(Boolean);
 }
 
-async function loadAlt(
+async function loadAlts(
   connection: Connection
-): Promise<AddressLookupTableAccount | null> {
-  const addr = getAltAddress();
-  if (!addr) return null;
+): Promise<AddressLookupTableAccount[]> {
+  const addrs = getAltAddress();
+  if (!addrs.length) return [];
 
-  // Cache the ALT account to avoid repeated fetches
-  if (_cachedAlt && _cachedAltAddress === addr) return _cachedAlt;
+  const key = addrs.join(",");
+  if (_cachedAlts.length && _cachedAltKey === key) return _cachedAlts;
 
-  const result = await connection.getAddressLookupTable(new PublicKey(addr));
-  if (!result.value) {
-    throw new Error(`Address Lookup Table not found: ${addr}`);
+  const results: AddressLookupTableAccount[] = [];
+  for (const addr of addrs) {
+    try {
+      const result = await connection.getAddressLookupTable(new PublicKey(addr));
+      if (result.value) {
+        results.push(result.value);
+      } else {
+        console.warn(`[nara-sdk] ALT not found: ${addr}, skipping`);
+      }
+    } catch (e) {
+      console.warn(`[nara-sdk] Failed to load ALT ${addr}: ${e}, skipping`);
+    }
   }
-  _cachedAlt = result.value;
-  _cachedAltAddress = addr;
-  return _cachedAlt;
+
+  _cachedAlts = results;
+  _cachedAltKey = key;
+  return _cachedAlts;
 }
 
 /**
@@ -75,7 +94,7 @@ export async function getRecentPriorityFee(
 
 /**
  * Send a transaction with optional ALT support.
- * If DEFAULT_ALT_ADDRESS is configured, uses VersionedTransaction.
+ * If ALT addresses are configured, uses VersionedTransaction.
  * Otherwise, uses legacy Transaction.
  *
  * opts.computeUnitLimit - set CU limit (ComputeBudgetProgram.setComputeUnitLimit)
@@ -113,18 +132,18 @@ export async function sendTx(
   }
   const allInstructions = [...budgetIxs, ...instructions];
 
-  const alt = await loadAlt(connection);
+  const alts = await loadAlts(connection);
   const { blockhash, lastValidBlockHeight } =
     await connection.getLatestBlockhash("confirmed");
 
   let signature: string;
 
-  if (alt) {
+  if (alts.length) {
     const message = new TransactionMessage({
       payerKey: payer.publicKey,
       recentBlockhash: blockhash,
       instructions: allInstructions,
-    }).compileToV0Message([alt]);
+    }).compileToV0Message(alts);
 
     const tx = new VersionedTransaction(message);
     const allSigners = [payer, ...(signers ?? [])];
@@ -160,14 +179,38 @@ export async function sendTx(
     });
   }
 
-  const confirmation = await connection.confirmTransaction(
-    { signature, blockhash, lastValidBlockHeight },
-    "confirmed"
-  );
-  if (confirmation.value.err) {
-    throw new Error(
-      `Transaction ${signature} failed: ${JSON.stringify(confirmation.value.err)}`
-    );
+  // Poll for confirmation (avoid confirmTransaction which uses WebSocket)
+  const startTime = Date.now();
+  const TIMEOUT_MS = 20_000;
+  const POLL_INTERVAL_MS = 1_000;
+
+  while (Date.now() - startTime < TIMEOUT_MS) {
+    const currentBlockHeight = await connection.getBlockHeight("confirmed");
+    if (currentBlockHeight > lastValidBlockHeight) {
+      throw new Error(
+        `Transaction ${signature} expired: block height exceeded`
+      );
+    }
+
+    const statusResult = await connection.getSignatureStatuses([signature]);
+    const status = statusResult?.value?.[0];
+
+    if (status) {
+      if (status.err) {
+        throw new Error(
+          `Transaction ${signature} failed: ${JSON.stringify(status.err)}`
+        );
+      }
+      if (
+        status.confirmationStatus === "confirmed" ||
+        status.confirmationStatus === "finalized"
+      ) {
+        return signature;
+      }
+    }
+
+    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
   }
-  return signature;
+
+  throw new Error(`Transaction ${signature} confirmation timeout`);
 }