@oobe-protocol-labs/synapse-sap-sdk 0.10.1 → 0.12.5

package/src/registries/index.ts

@@ -95,3 +95,49 @@ export type {
   RegisterBothResult,
   TripleCheckResult,
 } from "./metaplex-bridge";
+
+export {
+  FairScaleRegistry,
+  HumanScoreNamespace,
+  FairScaleError,
+  FAIRSCALE,
+} from "./fairscale";
+export type {
+  FairScaleConfig,
+  FairScaleTier,
+  FairScalePreset,
+  FairScaleTask,
+  FairScalePillars,
+  FairScaleBadge,
+  FairScaleAction,
+  FairScaleSignals,
+  FairScaleRecommendationTier,
+  FairScaleDirectorySort,
+  FairScaleDescriptionAlignment,
+  FairScaleRedFlag,
+  FairScaleVerifications,
+  FairScaleMeta,
+  AgentScoreResult,
+  TrustGateResult,
+  BatchScoreResult,
+  ScoreOptions,
+  TrustGateOptions,
+  ScoreAiOptions,
+  DirectoryOptions,
+  DirectoryEntry,
+  DirectoryResult,
+  LeaderboardResult,
+  ScoreHistoryResult,
+  CreditOptions,
+  CreditResult,
+  CreditConfidence,
+  CreditUnderwriting,
+  CreditLendingTerms,
+  CreditRiskFlag,
+  CreditPillars,
+  CreditAttestation,
+  HumanScoreResult,
+  HumanScoreFeatures,
+  AggregatedReputation,
+  AggregateOptions,
+} from "./fairscale";

package/src/registries/x402.ts

@@ -88,6 +88,7 @@ import type {
 } from "../types";
 import {
   buildPriorityFeeIxs,
+  computeBatchSettleCu,
   buildRpcOptions,
 } from "../utils/priority-fee";
 import type { SettleOptions } from "../utils/priority-fee";
@@ -856,13 +857,19 @@ export class X402Registry {
       totalCalls,
     );
 
-    // Build priority fee instructions (empty array if no opts)
-    const preIxs = buildPriorityFeeIxs(opts);
-    const rpcOpts = buildRpcOptions(opts);
+    // Auto-size CU to the batch length when the caller didn't pin one.
+    // Default Solana cap (200k) is tight past ~8 entries; a CU limit
+    // costs nothing extra (only caps the maximum charge).
+    const effectiveOpts: SettleOptions = {
+      ...opts,
+      computeUnits: opts?.computeUnits ?? computeBatchSettleCu(settlements.length),
+    };
+    const preIxs = buildPriorityFeeIxs(effectiveOpts);
+    const rpcOpts = buildRpcOptions(effectiveOpts);
 
     let builder = this.methods
       .settleBatch(settlements)
-      .accounts({
+      .accountsPartial({
         wallet: this.wallet,
         agent: agentPda,
         agentStats: statsPda,

package/src/utils/index.ts

@@ -66,6 +66,7 @@ export {
   DEFAULT_SETTLE_PRIORITY_FEE,
   DEFAULT_SETTLE_COMPUTE_UNITS,
   DEFAULT_BATCH_SETTLE_COMPUTE_UNITS,
+  computeBatchSettleCu,
 } from "./priority-fee";
 export type {
   PriorityFeeConfig,

package/src/utils/priority-fee.ts

@@ -59,6 +59,61 @@ export const DEFAULT_SETTLE_COMPUTE_UNITS = 100_000;
  */
 export const DEFAULT_BATCH_SETTLE_COMPUTE_UNITS = 300_000;
 
+/**
+ * Per-settlement CU cost observed for `settle_batch` (sha256 of the
+ * service hash, dedup scan, volume-curve math, account writes).
+ *
+ * @since v0.11.0
+ * @internal
+ */
+const BATCH_SETTLE_CU_PER_ENTRY = 25_000;
+
+/**
+ * Fixed CU overhead for a `settle_batch` transaction independent of
+ * the entry count (signature verify, account loads, transfer, event).
+ *
+ * @since v0.11.0
+ * @internal
+ */
+const BATCH_SETTLE_CU_BASE = 60_000;
+
+/**
+ * Hard ceiling — Solana caps a single instruction at 1.4M CU. We
+ * stay below that so a transaction with extra preInstructions
+ * (priority-fee, ATA creation) still fits.
+ *
+ * @since v0.11.0
+ * @internal
+ */
+const BATCH_SETTLE_CU_MAX = 1_200_000;
+
+/**
+ * @name computeBatchSettleCu
+ * @description Compute the CU limit needed by `settle_batch` for a
+ * given entry count. Returned value is safe to pass to
+ * `ComputeBudgetProgram.setComputeUnitLimit`.
+ *
+ * Formula: `60_000 + n * 25_000`, clamped to 1.2M.
+ *
+ * @param entryCount - Number of settlements in the batch (1..N).
+ * @returns CU limit suitable for `setComputeUnitLimit`.
+ *
+ * @example
+ * ```ts
+ * const cu = computeBatchSettleCu(20); // 560_000
+ * ```
+ *
+ * @category Utils
+ * @since v0.11.0
+ */
+export function computeBatchSettleCu(entryCount: number): number {
+  if (!Number.isFinite(entryCount) || entryCount <= 0) {
+    return DEFAULT_BATCH_SETTLE_COMPUTE_UNITS;
+  }
+  const raw = BATCH_SETTLE_CU_BASE + Math.ceil(entryCount) * BATCH_SETTLE_CU_PER_ENTRY;
+  return Math.min(raw, BATCH_SETTLE_CU_MAX);
+}
+
 // ═══════════════════════════════════════════════════════════════════
 //  Types
 // ═══════════════════════════════════════════════════════════════════