@oobe-protocol-labs/synapse-sap-sdk 0.1.0

package/dist/types/types/common.d.ts

@@ -0,0 +1,166 @@
+/**
+ * @module types/common
+ * @description Shared helper structs used across accounts and instructions.
+ *
+ * These types appear as nested fields in both on-chain account data
+ * and instruction argument DTOs.
+ *
+ * @category Types
+ * @since v0.1.0
+ */
+import type { PublicKey } from "@solana/web3.js";
+import type BN from "bn.js";
+import type { PluginTypeKind, SettlementModeKind, TokenTypeKind } from "./enums";
+/**
+ * @interface Capability
+ * @description Agent capability descriptor declaring what the agent can do.
+ *
+ * Capabilities use a namespaced identifier format (e.g. `"jupiter:swap"`).
+ * They are indexed on-chain via the `CapabilityIndex` PDA for scalable discovery.
+ *
+ * @category Types
+ * @since v0.1.0
+ *
+ * @example
+ * ```ts
+ * const cap: Capability = {
+ *   id: "jupiter:swap",
+ *   description: "Token swap via Jupiter aggregator",
+ *   protocolId: "jupiter",
+ *   version: "1.0",
+ * };
+ * ```
+ */
+export interface Capability {
+    /** Unique identifier (e.g. `"jupiter:swap"`). */
+    readonly id: string;
+    /** Human-readable description of the capability. */
+    readonly description: string | null;
+    /** Protocol namespace this capability belongs to. */
+    readonly protocolId: string | null;
+    /** Semantic version of the capability. */
+    readonly version: string | null;
+}
+/**
+ * @interface VolumeCurveBreakpoint
+ * @description A single breakpoint in a volume-based pricing curve.
+ *
+ * After a consumer exceeds `afterCalls` total invocations, the effective
+ * price drops to `pricePerCall`. Multiple breakpoints form a tiered
+ * discount schedule (ERC-8004–style).
+ *
+ * @category Types
+ * @since v0.1.0
+ *
+ * @example
+ * ```ts
+ * const curve: VolumeCurveBreakpoint[] = [
+ *   { afterCalls: 100, pricePerCall: new BN(90_000) },
+ *   { afterCalls: 500, pricePerCall: new BN(70_000) },
+ * ];
+ * ```
+ */
+export interface VolumeCurveBreakpoint {
+    /** Number of cumulative calls after which this price tier activates. */
+    readonly afterCalls: number;
+    /** Price per call (in token base units) once `afterCalls` is exceeded. */
+    readonly pricePerCall: BN;
+}
+/**
+ * @interface PricingTier
+ * @description Full pricing tier for agent services, including rate limits,
+ *   supported token, settlement mode, and optional volume discounts.
+ *
+ * Agents can expose multiple tiers (e.g. free, pro) each with independent
+ * rate-limiting and pricing parameters.
+ *
+ * @category Types
+ * @since v0.1.0
+ * @see {@link SettlementMode} for settlement strategies.
+ * @see {@link VolumeCurveBreakpoint} for volume-based discounts.
+ *
+ * @example
+ * ```ts
+ * import { TokenType, SettlementMode } from "@synapse-sap/sdk";
+ *
+ * const tier: PricingTier = {
+ *   tierId: "pro",
+ *   pricePerCall: new BN(100_000),
+ *   minPricePerCall: null,
+ *   maxPricePerCall: null,
+ *   rateLimit: 60,
+ *   maxCallsPerSession: 1000,
+ *   burstLimit: 10,
+ *   tokenType: TokenType.Usdc,
+ *   tokenMint: USDC_MINT,
+ *   tokenDecimals: 6,
+ *   settlementMode: SettlementMode.Escrow,
+ *   minEscrowDeposit: new BN(1_000_000),
+ *   batchIntervalSec: null,
+ *   volumeCurve: null,
+ * };
+ * ```
+ */
+export interface PricingTier {
+    /** Unique identifier for this tier (e.g. `"free"`, `"pro"`). */
+    readonly tierId: string;
+    /** Default price per call in token base units. */
+    readonly pricePerCall: BN;
+    /** Floor price guard (optional). */
+    readonly minPricePerCall: BN | null;
+    /** Ceiling price guard (optional). */
+    readonly maxPricePerCall: BN | null;
+    /** Maximum calls per second allowed. */
+    readonly rateLimit: number;
+    /** Maximum calls allowed within a single session. */
+    readonly maxCallsPerSession: number;
+    /** Burst capacity above steady-state rate limit. */
+    readonly burstLimit: number | null;
+    /** Token type accepted for payment. */
+    readonly tokenType: TokenTypeKind;
+    /** SPL token mint address (required when `tokenType` is `Spl`). */
+    readonly tokenMint: PublicKey | null;
+    /** Decimal places for the token. */
+    readonly tokenDecimals: number | null;
+    /** Settlement strategy for this tier. */
+    readonly settlementMode: SettlementModeKind | null;
+    /** Minimum escrow deposit required (for escrow settlement). */
+    readonly minEscrowDeposit: BN | null;
+    /** Batch settlement interval in seconds (for batched settlement). */
+    readonly batchIntervalSec: number | null;
+    /** Optional volume discount breakpoints. */
+    readonly volumeCurve: VolumeCurveBreakpoint[] | null;
+}
+/**
+ * @interface PluginRef
+ * @description Reference to an active plugin PDA attached to an agent.
+ *
+ * Stored in the agent's `activePlugins` array to track which extensions
+ * are currently enabled.
+ *
+ * @category Types
+ * @since v0.1.0
+ */
+export interface PluginRef {
+    /** Discriminant identifying the plugin extension type. */
+    readonly pluginType: PluginTypeKind;
+    /** PDA address of the plugin account. */
+    readonly pda: PublicKey;
+}
+/**
+ * @interface Settlement
+ * @description Individual settlement entry used in batch settlement instructions.
+ *
+ * Each entry describes how many calls to settle for a given service, identified
+ * by its 32-byte hash.
+ *
+ * @category Types
+ * @since v0.1.0
+ */
+export interface Settlement {
+    /** Number of calls to settle in this batch entry. */
+    readonly callsToSettle: BN;
+    /** SHA-256 hash identifying the service being settled. */
+    readonly serviceHash: number[];
+}
+//# sourceMappingURL=common.d.ts.map

package/dist/types/types/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/types/common.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,MAAM,OAAO,CAAC;AAC5B,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAMjF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,UAAU;IACzB,iDAAiD;IACjD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,oDAAoD;IACpD,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,qDAAqD;IACrD,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,0CAA0C;IAC1C,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,qBAAqB;IACpC,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,YAAY,EAAE,EAAE,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,WAAW,WAAW;IAC1B,gEAAgE;IAChE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kDAAkD;IAClD,QAAQ,CAAC,YAAY,EAAE,EAAE,CAAC;IAC1B,oCAAoC;IACpC,QAAQ,CAAC,eAAe,EAAE,EAAE,GAAG,IAAI,CAAC;IACpC,sCAAsC;IACtC,QAAQ,CAAC,eAAe,EAAE,EAAE,GAAG,IAAI,CAAC;IACpC,wCAAwC;IACxC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,qDAAqD;IACrD,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,oDAAoD;IACpD,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,uCAAuC;IACvC,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;IAClC,mEAAmE;IACnE,QAAQ,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;IACrC,oCAAoC;IACpC,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,yCAAyC;IACzC,QAAQ,CAAC,cAAc,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACnD,+DAA+D;IAC/D,QAAQ,CAAC,gBAAgB,EAAE,EAAE,GAAG,IAAI,CAAC;IACrC,qEAAqE;IACrE,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC,4CAA4C;IAC5C,QAAQ,CAAC,WAAW,EAAE,qBAAqB,EAAE,GAAG,IAAI,CAAC;CACtD;AAMD;;;;;;;;;GASG;AACH,MAAM,WAAW,SAAS;IACxB,0DAA0D;IAC1D,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,yCAAyC;IACzC,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;CACzB;AAMD;;;;;;;;;GASG;AACH,MAAM,WAAW,UAAU;IACzB,qDAAqD;IACrD,QAAQ,CAAC,aAAa,EAAE,EAAE,CAAC;IAC3B,0DAA0D;IAC1D,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC;CAChC"}

package/dist/types/types/enums.d.ts

@@ -0,0 +1,238 @@
+/**
+ * @module types/enums
+ * @description Anchor-compatible enum variant objects for SAP v2.
+ *
+ * Each enum mirrors the Rust discriminant format used by Anchor:
+ * `{ variant: {} }` — e.g. `{ sol: {} }` for `TokenType::Sol`.
+ *
+ * Use the `*Kind` types for function signatures.
+ *
+ * @category Types
+ * @since v0.1.0
+ * @see {@link https://solana.com/docs | Solana Docs}
+ */
+/**
+ * @name TokenType
+ * @description Anchor-compatible enum variants for token types accepted by agent pricing and escrow.
+ *
+ * - `Sol` — Native SOL.
+ * - `Usdc` — USDC stablecoin.
+ * - `Spl` — Arbitrary SPL token (requires `tokenMint`).
+ *
+ * @category Types
+ * @since v0.1.0
+ *
+ * @example
+ * ```ts
+ * import { TokenType } from "@synapse-sap/sdk";
+ *
+ * const tier = { tokenType: TokenType.Sol };
+ * ```
+ */
+export declare const TokenType: {
+    readonly Sol: {
+        readonly sol: {};
+    };
+    readonly Usdc: {
+        readonly usdc: {};
+    };
+    readonly Spl: {
+        readonly spl: {};
+    };
+};
+/**
+ * @name TokenTypeKind
+ * @description Union of all {@link TokenType} variant shapes.
+ *   Use this as the type for any parameter that accepts a token type discriminant.
+ */
+export type TokenTypeKind = (typeof TokenType)[keyof typeof TokenType];
+/**
+ * @name PluginType
+ * @description Anchor-compatible enum variants for plugin extension types.
+ *
+ * Plugins extend agent functionality and are feature-gated on-chain.
+ *
+ * - `Memory` — Encrypted memory / vault storage.
+ * - `Validation` — Custom validation logic.
+ * - `Delegation` — Hot-wallet delegation.
+ * - `Analytics` — Metrics & analytics.
+ * - `Governance` — DAO / governance participation.
+ * - `Custom` — User-defined plugin type.
+ *
+ * @category Types
+ * @since v0.1.0
+ *
+ * @example
+ * ```ts
+ * import { PluginType } from "@synapse-sap/sdk";
+ *
+ * const ref = { pluginType: PluginType.Memory, pda: vaultPda };
+ * ```
+ */
+export declare const PluginType: {
+    readonly Memory: {
+        readonly memory: {};
+    };
+    readonly Validation: {
+        readonly validation: {};
+    };
+    readonly Delegation: {
+        readonly delegation: {};
+    };
+    readonly Analytics: {
+        readonly analytics: {};
+    };
+    readonly Governance: {
+        readonly governance: {};
+    };
+    readonly Custom: {
+        readonly custom: {};
+    };
+};
+/**
+ * @name PluginTypeKind
+ * @description Union of all {@link PluginType} variant shapes.
+ */
+export type PluginTypeKind = (typeof PluginType)[keyof typeof PluginType];
+/**
+ * @name SettlementMode
+ * @description Anchor-compatible enum variants for payment settlement strategies.
+ *
+ * - `Instant` — Pay-per-call, settled immediately on invocation.
+ * - `Escrow` — Pre-funded escrow account with per-call drawdown.
+ * - `Batched` — Aggregated settlement at fixed intervals.
+ * - `X402` — HTTP 402-based micropayment protocol settlement.
+ *
+ * @category Types
+ * @since v0.1.0
+ *
+ * @example
+ * ```ts
+ * import { SettlementMode } from "@synapse-sap/sdk";
+ *
+ * const tier = { settlementMode: SettlementMode.Escrow };
+ * ```
+ */
+export declare const SettlementMode: {
+    readonly Instant: {
+        readonly instant: {};
+    };
+    readonly Escrow: {
+        readonly escrow: {};
+    };
+    readonly Batched: {
+        readonly batched: {};
+    };
+    readonly X402: {
+        readonly x402: {};
+    };
+};
+/**
+ * @name SettlementModeKind
+ * @description Union of all {@link SettlementMode} variant shapes.
+ */
+export type SettlementModeKind = (typeof SettlementMode)[keyof typeof SettlementMode];
+/**
+ * @name ToolHttpMethod
+ * @description Anchor-compatible enum variants for the HTTP method exposed by a tool.
+ *
+ * - `Get` / `Post` / `Put` / `Delete` — Standard REST verbs.
+ * - `Compound` — Multi-step tool (calls several sub-operations).
+ *
+ * @category Types
+ * @since v0.1.0
+ *
+ * @example
+ * ```ts
+ * import { ToolHttpMethod } from "@synapse-sap/sdk";
+ *
+ * const args = { httpMethod: ToolHttpMethod.Post };
+ * ```
+ */
+export declare const ToolHttpMethod: {
+    readonly Get: {
+        readonly get: {};
+    };
+    readonly Post: {
+        readonly post: {};
+    };
+    readonly Put: {
+        readonly put: {};
+    };
+    readonly Delete: {
+        readonly delete: {};
+    };
+    readonly Compound: {
+        readonly compound: {};
+    };
+};
+/**
+ * @name ToolHttpMethodKind
+ * @description Union of all {@link ToolHttpMethod} variant shapes.
+ */
+export type ToolHttpMethodKind = (typeof ToolHttpMethod)[keyof typeof ToolHttpMethod];
+/**
+ * @name ToolCategory
+ * @description Anchor-compatible enum variants for classifying tools in the on-chain registry.
+ *
+ * Categories power cross-agent tool discovery via the `ToolCategoryIndex` PDA.
+ *
+ * - `Swap` — Token swap / DEX tools.
+ * - `Lend` — Lending protocol tools.
+ * - `Stake` — Staking / validator tools.
+ * - `Nft` — NFT minting / marketplace tools.
+ * - `Payment` — Payment & invoicing tools.
+ * - `Data` — Data feeds / oracles.
+ * - `Governance` — DAO & governance tools.
+ * - `Bridge` — Cross-chain bridge tools.
+ * - `Analytics` — On-chain analytics.
+ * - `Custom` — User-defined category.
+ *
+ * @category Types
+ * @since v0.1.0
+ *
+ * @example
+ * ```ts
+ * import { ToolCategory } from "@synapse-sap/sdk";
+ *
+ * const args = { category: ToolCategory.Swap };
+ * ```
+ */
+export declare const ToolCategory: {
+    readonly Swap: {
+        readonly swap: {};
+    };
+    readonly Lend: {
+        readonly lend: {};
+    };
+    readonly Stake: {
+        readonly stake: {};
+    };
+    readonly Nft: {
+        readonly nft: {};
+    };
+    readonly Payment: {
+        readonly payment: {};
+    };
+    readonly Data: {
+        readonly data: {};
+    };
+    readonly Governance: {
+        readonly governance: {};
+    };
+    readonly Bridge: {
+        readonly bridge: {};
+    };
+    readonly Analytics: {
+        readonly analytics: {};
+    };
+    readonly Custom: {
+        readonly custom: {};
+    };
+};
+/**
+ * @name ToolCategoryKind
+ * @description Union of all {@link ToolCategory} variant shapes.
+ */
+export type ToolCategoryKind = (typeof ToolCategory)[keyof typeof ToolCategory];
+//# sourceMappingURL=enums.d.ts.map

package/dist/types/types/enums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.d.ts","sourceRoot":"","sources":["../../../src/types/enums.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;CAIZ,CAAC;AAEX;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAMvE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;CAOb,CAAC;AAEX;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,OAAO,UAAU,CAAC,CAAC;AAM1E;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;CAKjB,CAAC;AAEX;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAC5B,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,cAAc,CAAC,CAAC;AAMvD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;CAMjB,CAAC;AAEX;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAC5B,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,cAAc,CAAC,CAAC;AAMvD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWf,CAAC;AAEX;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAC1B,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC"}

package/dist/types/types/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @module types
+ * @description Strongly-typed domain models for SAP v2.
+ *
+ * Every type mirrors the onchain Rust struct / enum exactly.
+ * Types are organized into four layers:
+ *
+ * - **enums** — Anchor-style enum variant objects (`TokenType`, `ToolCategory`, …)
+ * - **common** — Shared helper structs (`Capability`, `PricingTier`, `Settlement`, …)
+ * - **accounts** — Deserialized on-chain PDA account data (`AgentAccountData`, …)
+ * - **instructions** — Instruction argument DTOs + permission/schema helpers
+ *
+ * @category Types
+ * @since v0.1.0
+ *
+ * @example
+ * ```ts
+ * import type { AgentAccountData, RegisterAgentArgs } from "@synapse-sap/sdk/types";
+ * import { TokenType, SettlementMode } from "@synapse-sap/sdk/types";
+ * ```
+ */
+export { TokenType, PluginType, SettlementMode, ToolHttpMethod, ToolCategory, } from "./enums";
+export type { TokenTypeKind, PluginTypeKind, SettlementModeKind, ToolHttpMethodKind, ToolCategoryKind, } from "./enums";
+export type { Capability, VolumeCurveBreakpoint, PricingTier, PluginRef, Settlement, } from "./common";
+export type { AgentAccountData, AgentStatsData, FeedbackAccountData, CapabilityIndexData, ProtocolIndexData, ToolCategoryIndexData, GlobalRegistryData, MemoryVaultData, SessionLedgerData, EpochPageData, VaultDelegateData, SessionCheckpointData, ToolDescriptorData, EscrowAccountData, AgentAttestationData, MemoryLedgerData, LedgerPageData, } from "./accounts";
+export type { RegisterAgentArgs, UpdateAgentArgs, GiveFeedbackArgs, UpdateFeedbackArgs, PublishToolArgs, UpdateToolArgs, InscribeToolSchemaArgs, InscribeMemoryArgs, CompactInscribeArgs, CreateEscrowArgs, CreateAttestationArgs, DelegatePermissionBit, SchemaTypeValue, CompressionTypeValue, } from "./instructions";
+export { DelegatePermission, SchemaType, CompressionType, } from "./instructions";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,EACL,SAAS,EACT,UAAU,EACV,cAAc,EACd,cAAc,EACd,YAAY,GACb,MAAM,SAAS,CAAC;AAEjB,YAAY,EACV,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,SAAS,CAAC;AAGjB,YAAY,EACV,UAAU,EACV,qBAAqB,EACrB,WAAW,EACX,SAAS,EACT,UAAU,GACX,MAAM,UAAU,CAAC;AAGlB,YAAY,EACV,gBAAgB,EAChB,cAAc,EACd,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,qBAAqB,EACrB,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EACrB,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACpB,gBAAgB,EAChB,cAAc,GACf,MAAM,YAAY,CAAC;AAGpB,YAAY,EACV,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,cAAc,EACd,sBAAsB,EACtB,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,qBAAqB,EACrB,qBAAqB,EACrB,eAAe,EACf,oBAAoB,GACrB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,kBAAkB,EAClB,UAAU,EACV,eAAe,GAChB,MAAM,gBAAgB,CAAC"}