@telaro/sacp 1.0.0

package/INTEGRATION.md

@@ -0,0 +1,238 @@
+# sACP Integration Guide
+
+Concrete recipes for the four common ways teams plug into sACP.
+Pick the role you play and follow the matching section.
+
+- [Role 1. Agent framework / SDK author](#role-1--agent-framework--sdk-author) (SendAI, Eliza, Crestal, similar)
+- [Role 2. DApp gating on agent commerce](#role-2--dapp-gating-on-agent-commerce) (you accept agent service and want bonded settlement)
+- [Role 3. Validator operator](#role-3--validator-operator) (you stake bond and act as Evaluator across many Jobs)
+- [Role 4. Reputation / indexer integrator](#role-4--reputation--indexer-integrator) (you mirror sACP state for analytics or trust scoring)
+
+If your case isn't here, open an issue or DM
+[@telaroai](https://x.com/telaroai). we'll add a recipe.
+
+---
+
+## Role 1. Agent framework / SDK author
+
+You ship a TypeScript / Rust SDK that agent operators install. You
+want your agents to be able to **place jobs** (act as Client) and
+**fulfill jobs** (act as Provider) on a standard.
+
+### Minimum surface
+
+1. **Add `@telaro/sacp` as a peer dependency** of your SDK so users
+   already pulling your SDK get sACP for free.
+2. **Expose two methods**: `placeJob(...)` and `claimJob(...)`. Each
+   wraps the sACP instruction builders with your SDK's idioms
+   (provider client, error handling, retries).
+3. **Surface job state in your agent loop**. Agents poll `fetchJob`
+   on PDAs they care about and react to state changes.
+
+### Reference pattern
+
+```ts
+// In your SDK
+import {
+  buildCreateJobIx,
+  buildSubmitWorkIx,
+  fetchJob,
+} from "@telaro/sacp/job";
+
+export class MyAgent {
+  async placeJob(params: { provider, evaluator, workUri, amount }) {
+    const jobId = BigInt(Date.now()) * 1000n;
+    const { ix, jobPda } = buildCreateJobIx({
+      jobId,
+      roles: { client: this.wallet.publicKey, ...params },
+      bondMint: USDC_MINT,
+      amount: params.amount,
+      workUri: params.workUri,
+    });
+    await this.sendTx([ix]);
+    return { jobId, jobPda };
+  }
+
+  async fulfillJob(jobId, submissionUri) {
+    const ix = buildSubmitWorkIx(this.wallet.publicKey, jobId, submissionUri);
+    return this.sendTx([ix]);
+  }
+
+  async watchJob(jobId, onStateChange) {
+    let last;
+    while (true) {
+      const job = await fetchJob(this.conn, jobId);
+      if (job?.state !== last) {
+        last = job?.state;
+        onStateChange(job);
+      }
+      await sleep(2000);
+    }
+  }
+}
+```
+
+### Why integrate
+
+- One standard for cross-source agent commerce on Solana
+- Verifiable settlement state (no off-chain agreements)
+- Built-in evaluator economy via Part B
+- Cross-chain compatibility with ERC-8183 (Base, BSC)
+
+### Co-marketing path
+
+If your framework ships a sACP integration, we'll co-publish:
+the announcement, a worked example in our docs, and a slot on
+the [sACP standard](https://sacp.dev) landing page (coming
+soon). Open a PR or email build@telaro.xyz.
+
+---
+
+## Role 2. DApp gating on agent commerce
+
+You run a DApp that accepts agent-provided services (data
+analysis, content generation, custom workflows) and you want
+settlement that doesn't depend on a centralized escrow.
+
+### Minimum surface
+
+1. **Use sACP as your escrow layer**. Your DApp creates the Job;
+   your selected agent fulfills.
+2. **Pick the Evaluator path**:
+   - Single signer (you settle)
+   - Multisig (multi-stakeholder DApp)
+   - Validation Registry (delegated bonded evaluators)
+3. **Surface Job state in your UI**. Users see the job moving
+   through the state machine in real time.
+
+### Reference pattern
+
+```ts
+import { buildCreateJobIx, fetchJob } from "@telaro/sacp/job";
+
+// User clicks "Hire agent to do X"
+const { ix, jobPda } = buildCreateJobIx({
+  jobId,
+  roles: {
+    client: dappEscrowPda,    // your DApp's PDA, signs via CPI
+    provider: selectedAgent,
+    evaluator: yourMultisigPda,
+  },
+  bondMint: USDC_MINT,
+  amount: jobPrice,
+  workUri: `ipfs://${requestSpec.cid}`,
+});
+
+// CPI from your program, or sign with your treasury wallet
+await this.sendTx([ix]);
+```
+
+### Why integrate
+
+- No custom escrow contract to audit
+- Standardized dispute flow
+- Optional validator network you don't have to operate yourself
+
+---
+
+## Role 3. Validator operator
+
+You commit USDC bond and earn fees by serving as Evaluator
+across Jobs. Bond is slashed on disputed verdicts.
+
+### Onboarding
+
+1. Generate a validator authority keypair (cold + hot recommended).
+2. `register_validator` with operator metadata URI.
+3. `stake_bond` (USDC in v0.1; JitoSOL via adapter in v0.2).
+4. Run a verdict-acceptance daemon that watches `JobDisputed`
+   events for Jobs that target your validator PDA.
+5. Issue verdicts. Defend against challenges within the window.
+
+### Reference pattern
+
+```ts
+import {
+  findValidatorPda,
+  buildAcceptVerdictIx,
+} from "@telaro/sacp/validation";
+
+const [validatorPda] = findValidatorPda(operator.publicKey);
+
+// In your daemon, on a Disputed Job that names validatorPda:
+const ix = buildAcceptVerdictIx(jobId, "Provider"); // your decision
+await sendTx([ix]);
+```
+
+### Reward + risk
+
+- **Reward**: fee per verdict (set per-Job by Client; defaults TBD).
+- **Slash**: 100% of bond at risk on every challenged verdict the
+  challenger wins. Splits 70% to challenger, 30% to public treasury.
+
+The full validator runbook (key management, monitoring, dispute
+defense playbook) ships with v0.2.
+
+---
+
+## Role 4. Reputation / indexer integrator
+
+You aggregate on-chain state for analytics, trust scoring,
+discovery (e.g. you build something like 8004scan, or you're
+Telaro's own indexer extending to cover sACP).
+
+### Minimum surface
+
+1. **Subscribe to the four event types**:
+   `JobCreated`, `JobFunded`, `WorkSubmitted`, `JobSettled` (and the
+   Validation events `ValidatorRegistered`, `BondStaked`,
+   `ValidatorSlashed`).
+2. **Decode account state**: Job, Submission, Verdict, Validator.
+   Layouts are documented in
+   [`src/job.ts`](src/job.ts) (`fetchJob`) and
+   [`src/validation.ts`](src/validation.ts) (`fetchValidator`).
+3. **Materialize derived signals**: settlement rate per Provider,
+   slash rate per Validator, dispute frequency, average job value.
+
+### Reference pattern
+
+```ts
+import {
+  SACP_PROGRAM_ID,
+  SACP_VALIDATION_PROGRAM_ID,
+} from "@telaro/sacp";
+
+// Anchor event signatures = sha256("event:<name>")[..8]
+// or watch via `onLogs(programId, ...)`.
+const sub = conn.onLogs(SACP_PROGRAM_ID, (log) => {
+  // parse log.logs for "Program data:" lines, base64-decode, dispatch.
+});
+```
+
+### Why integrate
+
+- Single source of truth for agent commerce state on Solana
+- Composable trust signals (combine with Telaro bond, 8004 publishes,
+  etc.)
+
+---
+
+## Spec change cadence
+
+- **v0.1** (now): SDK signatures and PDA seeds frozen. Implementation
+  details (escrow CPI, JitoSOL adapter) ship in v0.2 without
+  signature changes.
+- **v1.0** (target Q4 2026): governance moves to public RFC process;
+  spec changes require RFC + 30-day comment period.
+
+If you're worried about a signature change before v1.0, pin
+`@telaro/sacp@~0.1.0`. semver minor bumps will not change PDA seeds
+or instruction argument layout.
+
+---
+
+## Need help?
+
+- Open a GitHub issue at [Telaro-Protocol](https://github.com/Telaro-Protocol/Telaro-Protocol/issues)
+- Email build@telaro.xyz
+- Cold DM [@telaroai](https://x.com/telaroai) on X

package/README.md

@@ -0,0 +1,253 @@
+# @telaro/sacp
+
+**Solana Agent Commerce Protocol. TypeScript SDK.**
+
+[![npm](https://img.shields.io/npm/v/@telaro/sacp.svg)](https://www.npmjs.com/package/@telaro/sacp)
+
+sACP is a Solana-native protocol for AI agent commerce: bonded job
+escrow, dispute resolution, and bonded-validator economy. ERC-8183
+compatible at the semantic level.
+
+- **Spec**: [`docs/srfc/sacp-v0.1.md`](https://github.com/Telaro-Protocol/Telaro-Protocol/blob/main/docs/srfc/sacp-v0.1.md)
+- **Reference impl**: [Telaro Protocol](https://telaro.xyz)
+- **Status v0.3**: full standard live on devnet. `record_verdict`
+  restores the standalone Verdict PDA from SRFC v0.1, and the
+  `issue_verdict` cross-program CPI bridge lets a bonded validator
+  settle a Job dispute in a single transaction (validator bond is
+  real collateral). Verified by 5 devnet smoke tests:
+  happy / dispute+record_verdict / reclaim / validation (slash) /
+  bonded-evaluator (CPI).
+
+---
+
+## What's deployed (devnet)
+
+| Program | Program ID | Status |
+|---|---|---|
+| `sacp_job` (Part A. Job Lifecycle) | [`8WAQhJJUnPqiKoJ35dNMSbRWNJsdRqu1f7uVqMwLHZuF`](https://explorer.solana.com/address/8WAQhJJUnPqiKoJ35dNMSbRWNJsdRqu1f7uVqMwLHZuF?cluster=devnet) | live |
+| `sacp_validation` (Part B. Validation Registry) | [`GbWzXwirzzed3WjshJaMat9hiWgVSiPR8tAUj4oJnfMC`](https://explorer.solana.com/address/GbWzXwirzzed3WjshJaMat9hiWgVSiPR8tAUj4oJnfMC?cluster=devnet) | live |
+
+---
+
+## What v0.3 ships
+
+| Surface | v0.3 | v1.0 plan |
+|---|---|---|
+| Job state machine (Open → Funded → Submitted → Settled / Disputed) | ✅ devnet | mainnet |
+| `create_job`, `submit_work`, `accept_work`, `dispute_work`, `submit_verdict`, `reclaim_escrow` | ✅ full SPL escrow CPI |. |
+| Escrow vault PDA + rent close on settle | ✅ |. |
+| Validation Registry: register / stake / withdraw / challenge / 70-30 slash | ✅ full SPL bond CPI |. |
+| Standalone `Verdict` PDA via `record_verdict` | ✅ |. |
+| `sacp_validation::issue_verdict` → `sacp_job::submit_verdict` CPI bridge | ✅ bonded validator path verified e2e |. |
+| Cross-chain dispatch (Base → Solana via Wormhole) | informative only | normative |
+
+The full standard. escrow settlement, bonded validator economy,
+permanent verdict provenance. works on devnet today. The CPI bridge
+in particular makes the validator's bond real collateral: a
+`challenge_verdict` against a verdict the validator issued can slash
+70% of their bond to the challenger.
+
+---
+
+## Install
+
+```sh
+pnpm add @telaro/sacp @solana/web3.js
+# or
+npm install @telaro/sacp @solana/web3.js
+```
+
+Node ≥20.
+
+---
+
+## Quickstart. drive a Job end-to-end on devnet
+
+This is the literal flow our smoke test runs. Copy it, run it, see
+the four real transactions on Solana Explorer.
+
+```ts
+import {
+  Connection,
+  Keypair,
+  PublicKey,
+  Transaction,
+  sendAndConfirmTransaction,
+} from "@solana/web3.js";
+import {
+  buildCreateJobIx,
+  buildFundJobIx,
+  buildSubmitWorkIx,
+  buildAcceptWorkIx,
+  fetchJob,
+} from "@telaro/sacp/job";
+
+const conn = new Connection("https://api.devnet.solana.com", "confirmed");
+
+// You play Client; provider & evaluator are fresh keypairs for the demo.
+const client = Keypair.generate();      // fund this with devnet SOL first
+const provider = Keypair.generate();
+const evaluator = Keypair.generate();
+const jobId = BigInt(Date.now()) * 1000n;
+
+const USDC_DEVNET = new PublicKey("4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU");
+
+// 1) Open the Job. initializes the escrow vault PDA.
+const { ix: createIx, jobPda } = buildCreateJobIx({
+  jobId,
+  roles: {
+    client: client.publicKey,
+    provider: provider.publicKey,
+    evaluator: evaluator.publicKey,
+  },
+  bondMint: USDC_DEVNET,
+  amount: 1_000_000n,                   // 1 USDC (decimals = 6)
+  workUri: "ipfs://Qm...your work order...",
+});
+await sendAndConfirmTransaction(conn, new Transaction().add(createIx), [client]);
+
+// 2) Fund. Client transfers 1 USDC → escrow vault via SPL CPI.
+//    Provide the Client's USDC ATA.
+await sendAndConfirmTransaction(
+  conn,
+  new Transaction().add(
+    buildFundJobIx({
+      client: client.publicKey,
+      jobId,
+      amount: 1_000_000n,
+      clientTokenAccount: clientUsdcAta,
+    }),
+  ),
+  [client],
+);
+
+// 3) Provider submits work.
+await sendAndConfirmTransaction(
+  conn,
+  new Transaction().add(
+    buildSubmitWorkIx(provider.publicKey, jobId, "ipfs://Qm...submission..."),
+  ),
+  [provider],
+);
+
+// 4) Client accepts → Settled. Vault drains to Provider's ATA + closes.
+await sendAndConfirmTransaction(
+  conn,
+  new Transaction().add(
+    buildAcceptWorkIx({
+      client: client.publicKey,
+      provider: provider.publicKey,
+      jobId,
+      providerTokenAccount: providerUsdcAta,
+    }),
+  ),
+  [client],
+);
+
+// Verify on-chain state.
+const job = await fetchJob(conn, jobId);
+console.log(job?.state); // "Settled"
+```
+
+Run our exact smoke test against your wallet:
+
+```sh
+git clone https://github.com/Telaro-Protocol/Telaro-Protocol
+cd Telaro-Protocol
+pnpm install
+pnpm --filter @telaro/sacp run smoke
+```
+
+Output ends with four Solana Explorer links you can click through.
+
+### Other verified paths
+
+The repository also ships three additional smoke tests covering every
+branch of the state machine. All four pass against the devnet
+deployment.
+
+```sh
+pnpm --filter @telaro/sacp run smoke              # happy path (4 tx, real SPL escrow)
+pnpm --filter @telaro/sacp run smoke:dispute      # dispute → verdict + record_verdict (5 tx)
+pnpm --filter @telaro/sacp run smoke:reclaim      # client reclaim after timeout (2 tx + deadline guard)
+pnpm --filter @telaro/sacp run smoke:validation   # validator register/stake/challenge/resolve, 70/30 slash (2 scenarios)
+pnpm --filter @telaro/sacp run smoke:bonded       # bonded validator → CPI bridge → settlement (7 tx)
+```
+
+---
+
+## Disputes
+
+When the Client rejects the submitted work:
+
+```ts
+import { buildDisputeWorkIx, buildSubmitVerdictIx } from "@telaro/sacp/job";
+
+// Instead of accept_work, Client disputes with a reason hash
+// (e.g. SHA-256 of a public reason document).
+const reasonHash = new Uint8Array(32); // populate with real hash
+await sendAndConfirmTransaction(
+  conn,
+  new Transaction().add(buildDisputeWorkIx(client.publicKey, jobId, reasonHash)),
+  [client],
+);
+
+// Evaluator then settles. Winner = "Client" or "Provider".
+await sendAndConfirmTransaction(
+  conn,
+  new Transaction().add(buildSubmitVerdictIx(evaluator.publicKey, jobId, "Provider")),
+  [evaluator],
+);
+```
+
+---
+
+## Validation Registry (Part B)
+
+`@telaro/sacp/validation` exposes the bonded-validator surface. A
+Validator PDA can be wired into a Job's `evaluator` slot, which puts
+the validator's bond at risk every time it issues a verdict.
+
+```ts
+import { findValidatorPda } from "@telaro/sacp/validation";
+
+const operator = Keypair.generate();
+const [validatorPda] = findValidatorPda(operator.publicKey);
+
+// validatorPda can now be used as the `evaluator` in buildCreateJobIx.
+```
+
+The full validator-side flow (register, stake, accept verdict,
+respond to challenge) is in
+[`src/validation.ts`](https://github.com/Telaro-Protocol/Telaro-Protocol/blob/main/packages/sacp/src/validation.ts).
+See [INTEGRATION.md](https://github.com/Telaro-Protocol/Telaro-Protocol/blob/main/packages/sacp/INTEGRATION.md)
+for the validator operator runbook.
+
+---
+
+## ERC-8183 compatibility
+
+The Job state machine, role definitions, and dispute outcomes map 1:1
+to ERC-8183. See the spec's
+[ERC-8183 mapping table](https://github.com/Telaro-Protocol/Telaro-Protocol/blob/main/docs/srfc/sacp-v0.1.md#erc-8183-mapping).
+
+Cross-chain dispatch (a Base-side ERC-8183 Job that addresses a
+Solana-side Provider) is informative in v0.1 and normative in v0.2,
+piggybacking the existing Telaro → Base Wormhole bridge.
+
+---
+
+## How to verify the SDK matches the on-chain program
+
+The SDK does not depend on a generated Anchor IDL. Instead, it builds
+instructions from raw Borsh + the standard Anchor 0.30 discriminator
+(`sha256("global:<name>")[..8]`). The PDAs are derived from the same
+seeds declared in the Rust source. If you want to verify the SDK and
+program agree, the smoke test does exactly that. it confirms every
+state transition by reading the Job account directly after each call.
+
+---
+
+## License
+
+MIT (spec) · Apache-2.0 (this SDK).

package/dist/codec.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Low-level codec utilities for talking to the sACP Anchor programs
+ * without depending on a generated IDL.
+ *
+ * Anchor 0.30 instruction encoding:
+ *   1. 8-byte discriminator = sha256("global:<instruction_name>")[..8]
+ *   2. Followed by Borsh-encoded args in declaration order.
+ *
+ * We hand-roll the encoders here so the SDK has zero coupling to the
+ * Anchor build pipeline. That matters because Anchor 0.30 + recent
+ * rustc can't always emit an IDL (see anchor-syn issue with
+ * proc-macro2 `source_file`), and we don't want our SDK to inherit
+ * that fragility.
+ *
+ * All numeric encoders write little-endian, matching Solana's wire
+ * convention.
+ */
+export declare function anchorDiscriminator(instructionName: string): Buffer;
+export declare function encodeU8(value: number): Buffer;
+export declare function encodeU64(value: bigint): Buffer;
+export declare function encodeI64(value: bigint): Buffer;
+/**
+ * Borsh string: 4-byte little-endian length followed by UTF-8 bytes.
+ * Spec mandates URIs ≤ 256 bytes; we enforce in the high-level builder
+ * rather than the codec.
+ */
+export declare function encodeString(value: string): Buffer;
+/**
+ * 32-byte fixed array, used for hashes. Throws if input isn't exactly
+ * 32 bytes — saner than silently truncating.
+ */
+export declare function encodeBytes32(bytes: Uint8Array): Buffer;
+/** Concatenate the discriminator with serialized args. */
+export declare function encodeInstruction(name: string, ...args: Buffer[]): Buffer;
+//# sourceMappingURL=codec.d.ts.map

package/dist/codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../src/codec.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AAEH,wBAAgB,mBAAmB,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAGnE;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAI9C;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAI/C;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAI/C;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKlD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAKvD;AAED,0DAA0D;AAC1D,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAEzE"}

package/dist/codec.js

@@ -0,0 +1,63 @@
+import { sha256 } from "@noble/hashes/sha256";
+/**
+ * Low-level codec utilities for talking to the sACP Anchor programs
+ * without depending on a generated IDL.
+ *
+ * Anchor 0.30 instruction encoding:
+ *   1. 8-byte discriminator = sha256("global:<instruction_name>")[..8]
+ *   2. Followed by Borsh-encoded args in declaration order.
+ *
+ * We hand-roll the encoders here so the SDK has zero coupling to the
+ * Anchor build pipeline. That matters because Anchor 0.30 + recent
+ * rustc can't always emit an IDL (see anchor-syn issue with
+ * proc-macro2 `source_file`), and we don't want our SDK to inherit
+ * that fragility.
+ *
+ * All numeric encoders write little-endian, matching Solana's wire
+ * convention.
+ */
+export function anchorDiscriminator(instructionName) {
+    const digest = sha256(new TextEncoder().encode(`global:${instructionName}`));
+    return Buffer.from(digest.subarray(0, 8));
+}
+export function encodeU8(value) {
+    const buf = Buffer.alloc(1);
+    buf.writeUInt8(value & 0xff);
+    return buf;
+}
+export function encodeU64(value) {
+    const buf = Buffer.alloc(8);
+    buf.writeBigUInt64LE(value);
+    return buf;
+}
+export function encodeI64(value) {
+    const buf = Buffer.alloc(8);
+    buf.writeBigInt64LE(value);
+    return buf;
+}
+/**
+ * Borsh string: 4-byte little-endian length followed by UTF-8 bytes.
+ * Spec mandates URIs ≤ 256 bytes; we enforce in the high-level builder
+ * rather than the codec.
+ */
+export function encodeString(value) {
+    const utf8 = Buffer.from(value, "utf8");
+    const len = Buffer.alloc(4);
+    len.writeUInt32LE(utf8.length);
+    return Buffer.concat([len, utf8]);
+}
+/**
+ * 32-byte fixed array, used for hashes. Throws if input isn't exactly
+ * 32 bytes — saner than silently truncating.
+ */
+export function encodeBytes32(bytes) {
+    if (bytes.length !== 32) {
+        throw new Error(`encodeBytes32: expected 32 bytes, got ${bytes.length}`);
+    }
+    return Buffer.from(bytes);
+}
+/** Concatenate the discriminator with serialized args. */
+export function encodeInstruction(name, ...args) {
+    return Buffer.concat([anchorDiscriminator(name), ...args]);
+}
+//# sourceMappingURL=codec.js.map

package/dist/codec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.js","sourceRoot":"","sources":["../src/codec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAE9C;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,UAAU,mBAAmB,CAAC,eAAuB;IACzD,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,UAAU,eAAe,EAAE,CAAC,CAAC,CAAC;IAC7E,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAC5C,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,KAAa;IACpC,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC5B,GAAG,CAAC,UAAU,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;IAC7B,OAAO,GAAG,CAAC;AACb,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,KAAa;IACrC,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC5B,GAAG,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;IAC5B,OAAO,GAAG,CAAC;AACb,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,KAAa;IACrC,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC5B,GAAG,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;IAC3B,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,KAAa;IACxC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACxC,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC5B,GAAG,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC/B,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC;AACpC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,KAAiB;IAC7C,IAAI,KAAK,CAAC,MAAM,KAAK,EAAE,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CAAC,yCAAyC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;IAC3E,CAAC;IACD,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC5B,CAAC;AAED,0DAA0D;AAC1D,MAAM,UAAU,iBAAiB,CAAC,IAAY,EAAE,GAAG,IAAc;IAC/D,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC;AAC7D,CAAC"}

package/dist/constants.d.ts

@@ -0,0 +1,50 @@
+import { PublicKey } from "@solana/web3.js";
+/**
+ * sACP program IDs.
+ *
+ * v0.1 deployments live on Solana devnet. Mainnet program IDs will
+ * be added at v1.0; the SDK is version-locked, so a v0.1 SDK only
+ * talks to a v0.1 deployment.
+ *
+ * Deployed: 2026-06-04, slot 467078075 (job) / 467078115 (validation).
+ */
+export declare const SACP_PROGRAM_ID: PublicKey;
+export declare const SACP_VALIDATION_PROGRAM_ID: PublicKey;
+/** Job state machine seed namespace — keeps PDAs cleanly separated. */
+export declare const JOB_SEED_PREFIX = "job";
+export declare const ESCROW_SEED_PREFIX = "escrow";
+export declare const ESCROW_VAULT_SEED_PREFIX = "vault";
+export declare const SUBMISSION_SEED_PREFIX = "submission";
+export declare const VERDICT_SEED_PREFIX = "verdict";
+export declare const CONFIG_SEED_PREFIX = "config";
+export declare const OFFERING_SEED_PREFIX = "offering";
+export declare const NEGOTIATION_SEED_PREFIX = "negotiation";
+/** Validation registry seed namespace. */
+export declare const VALIDATOR_SEED_PREFIX = "validator";
+export declare const BOND_SEED_PREFIX = "bond";
+export declare const BOND_AUTHORITY_SEED_PREFIX = "bond_authority";
+export declare const BOND_VAULT_SEED_PREFIX = "bond_vault";
+export declare const CHALLENGE_SEED_PREFIX = "challenge";
+export declare const TREASURY_AUTHORITY_SEED_PREFIX = "treasury_authority";
+export declare const TREASURY_VAULT_SEED_PREFIX = "treasury_vault";
+export declare const RESOLVER_CONFIG_SEED_PREFIX = "resolver_config";
+/**
+ * Default windows (seconds) baked into v0.1. These can be overridden
+ * per-job at `create_job` time; the constants are the protocol-level
+ * defaults that match the spec.
+ */
+export declare const DEFAULT_SUBMIT_WINDOW_SECS: number;
+export declare const DEFAULT_ACCEPT_WINDOW_SECS: number;
+export declare const DEFAULT_DISPUTE_WINDOW_SECS: number;
+export declare const DEFAULT_CHALLENGE_WINDOW_SECS: number;
+/** Slash distribution constants (basis points). */
+export declare const SLASH_TO_CHALLENGER_BPS = 7000;
+export declare const SLASH_TO_TREASURY_BPS = 3000;
+/** Protocol take-rate constants. Program-enforced cap; the authority
+ * can choose any value in [0, MAX_TAKE_RATE_BPS]. */
+export declare const FEE_DENOMINATOR_BPS = 10000;
+export declare const MAX_TAKE_RATE_BPS = 500;
+/** Maximum fraction of the protocol fee routable to the evaluator
+ * (v0.7+). 10_000 bps = 100% of the fee. */
+export declare const MAX_VALIDATOR_SHARE_BPS = 10000;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;;;;GAQG;AAEH,eAAO,MAAM,eAAe,WAE3B,CAAC;AAEF,eAAO,MAAM,0BAA0B,WAEtC,CAAC;AAEF,uEAAuE;AACvE,eAAO,MAAM,eAAe,QAAQ,CAAC;AACrC,eAAO,MAAM,kBAAkB,WAAW,CAAC;AAC3C,eAAO,MAAM,wBAAwB,UAAU,CAAC;AAChD,eAAO,MAAM,sBAAsB,eAAe,CAAC;AACnD,eAAO,MAAM,mBAAmB,YAAY,CAAC;AAC7C,eAAO,MAAM,kBAAkB,WAAW,CAAC;AAC3C,eAAO,MAAM,oBAAoB,aAAa,CAAC;AAC/C,eAAO,MAAM,uBAAuB,gBAAgB,CAAC;AAErD,0CAA0C;AAC1C,eAAO,MAAM,qBAAqB,cAAc,CAAC;AACjD,eAAO,MAAM,gBAAgB,SAAS,CAAC;AACvC,eAAO,MAAM,0BAA0B,mBAAmB,CAAC;AAC3D,eAAO,MAAM,sBAAsB,eAAe,CAAC;AACnD,eAAO,MAAM,qBAAqB,cAAc,CAAC;AACjD,eAAO,MAAM,8BAA8B,uBAAuB,CAAC;AACnE,eAAO,MAAM,0BAA0B,mBAAmB,CAAC;AAC3D,eAAO,MAAM,2BAA2B,oBAAoB,CAAC;AAE7D;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,QAAe,CAAC;AACvD,eAAO,MAAM,0BAA0B,QAAe,CAAC;AACvD,eAAO,MAAM,2BAA2B,QAAmB,CAAC;AAC5D,eAAO,MAAM,6BAA6B,QAAe,CAAC;AAE1D,mDAAmD;AACnD,eAAO,MAAM,uBAAuB,OAAQ,CAAC;AAC7C,eAAO,MAAM,qBAAqB,OAAQ,CAAC;AAE3C;qDACqD;AACrD,eAAO,MAAM,mBAAmB,QAAS,CAAC;AAC1C,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC;4CAC4C;AAC5C,eAAO,MAAM,uBAAuB,QAAS,CAAC"}