nara-sdk 1.0.44 → 1.0.48

package/index.ts

@@ -18,7 +18,7 @@ export {
 } from "./src/constants";
 
 // Export transaction helper
-export { sendTx, setAltAddress, getAltAddress } from "./src/tx";
+export { sendTx, setAltAddress, getAltAddress, getRecentPriorityFee } from "./src/tx";
 
 // Export quest functions and types
 export {
@@ -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.44",
+  "version": "1.0.48",
   "description": "SDK for the Nara chain (Solana-compatible)",
   "module": "index.ts",
   "main": "index.ts",

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) {
@@ -423,7 +472,11 @@ export async function submitAnswer(
     ixs.push(logIx);
   }
 
-  const signature = await sendTx(connection, wallet, ixs, [], { skipPreflight: true });
+  const signature = await sendTx(connection, wallet, ixs, [], {
+    skipPreflight: true,
+    computeUnitLimit: 500_000,
+    computeUnitPrice: "auto",
+  });
   return { signature };
 }
 
@@ -645,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]);
@@ -701,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);
@@ -714,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

@@ -7,6 +7,7 @@
 
 import {
   AddressLookupTableAccount,
+  ComputeBudgetProgram,
   Connection,
   Keypair,
   PublicKey,
@@ -57,11 +58,30 @@ async function loadAlt(
   return _cachedAlt;
 }
 
+/**
+ * Get the recent average priority fee (in micro-lamports per CU).
+ * Samples the last few slots via getRecentPrioritizationFees.
+ */
+export async function getRecentPriorityFee(
+  connection: Connection,
+): Promise<number> {
+  const fees = await connection.getRecentPrioritizationFees();
+  if (!fees.length) return 0;
+  const nonZero = fees.filter((f) => f.prioritizationFee > 0);
+  if (!nonZero.length) return 0;
+  const avg = nonZero.reduce((s, f) => s + f.prioritizationFee, 0) / nonZero.length;
+  return Math.ceil(avg);
+}
+
 /**
  * Send a transaction with optional ALT support.
  * If DEFAULT_ALT_ADDRESS is configured, uses VersionedTransaction.
  * Otherwise, uses legacy Transaction.
  *
+ * opts.computeUnitLimit - set CU limit (ComputeBudgetProgram.setComputeUnitLimit)
+ * opts.computeUnitPrice - set CU price in micro-lamports (ComputeBudgetProgram.setComputeUnitPrice)
+ * opts.computeUnitPrice = "auto" - auto-fetch recent average priority fee
+ *
  * @returns transaction signature
  */
 export async function sendTx(
@@ -69,8 +89,30 @@ export async function sendTx(
   payer: Keypair,
   instructions: TransactionInstruction[],
   signers?: Keypair[],
-  opts?: { skipPreflight?: boolean }
+  opts?: { skipPreflight?: boolean; computeUnitLimit?: number; computeUnitPrice?: number | "auto" }
 ): Promise<string> {
+  // Prepend compute budget instructions
+  const budgetIxs: TransactionInstruction[] = [];
+  if (opts?.computeUnitLimit) {
+    budgetIxs.push(
+      ComputeBudgetProgram.setComputeUnitLimit({ units: opts.computeUnitLimit })
+    );
+  }
+  if (opts?.computeUnitPrice !== undefined) {
+    let price: number;
+    if (opts.computeUnitPrice === "auto") {
+      price = await getRecentPriorityFee(connection);
+    } else {
+      price = opts.computeUnitPrice;
+    }
+    if (price > 0) {
+      budgetIxs.push(
+        ComputeBudgetProgram.setComputeUnitPrice({ microLamports: price })
+      );
+    }
+  }
+  const allInstructions = [...budgetIxs, ...instructions];
+
   const alt = await loadAlt(connection);
   const { blockhash, lastValidBlockHeight } =
     await connection.getLatestBlockhash("confirmed");
@@ -81,7 +123,7 @@ export async function sendTx(
     const message = new TransactionMessage({
       payerKey: payer.publicKey,
       recentBlockhash: blockhash,
-      instructions,
+      instructions: allInstructions,
     }).compileToV0Message([alt]);
 
     const tx = new VersionedTransaction(message);
@@ -103,7 +145,7 @@ export async function sendTx(
     tx.recentBlockhash = blockhash;
     tx.lastValidBlockHeight = lastValidBlockHeight;
     tx.feePayer = payer.publicKey;
-    for (const ix of instructions) tx.add(ix);
+    for (const ix of allInstructions) tx.add(ix);
     const allSigners = [payer, ...(signers ?? [])];
     const seen = new Set<string>();
     const uniqueSigners = allSigners.filter((s) => {
@@ -118,14 +160,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`);
 }