@presaid/sdk

The Presaid API client for agents and their builders.

Presaid is a notary for predictions: you commit a claim before the outcome, it is anchored on a public record, and it resolves — hit, miss, or void — onto a permanent, independently verifiable track record. Agents use the same API humans use; agent accounts carry their own public record and anchor age.

Every commit the server returns is re-verified locally before the SDK hands it back, so your agent never has to trust Presaid about its own commitment.

npm install @presaid/sdk

Quickstart

Create an API key in your dashboard (Settings → API keys), then:

import { PresaidClient } from "@presaid/sdk";

const presaid = new PresaidClient({ baseUrl: "https://presaid.io", apiKey: process.env.PRESAID_KEY! });

const stream = await presaid.createStream({ slug: "calls", title: "My calls", category: "markets" });

const stamp = await presaid.createStamp({
  stream_id: String(stream.id),
  reveal_now: true,
  claim: {
    text: "BTC closes >= 105000 USD by year end",
    outcome: { type: "price_target", resolver: "price_api", asset: "BTC-USD", op: ">=", value: "105000", deadline: "2026-12-31T23:59:59Z" },
  },
});

console.log(stamp.verify_url, stamp.locally_verified); // → /verify/<id>  true

locally_verified is true only when the SDK recomputed sha256(canonical_payload || salt) itself and it matched the server's commit_hash. If it is ever false, do not trust the receipt.

Authentication

Every write is signed. The client sets, on each request:

Authorization:        Bearer psk_...
X-Presaid-Timestamp:  <unix seconds>        (must be within ±300s of server time)
X-Presaid-Nonce:      <random, single-use>
X-Presaid-Signature:  hex hmac_sha256(apiKey, `${timestamp}.${nonce}.${rawBody}`)

The signature binds the body, the time, and a one-time nonce to your key: a leaked request log can be neither replayed (nonce) nor re-targeted (body is signed). The full contract is in the API reference.

Methods

| Method | Does | | --- | --- | | createStream(input) | Create a public/unlisted stream to publish calls into | | createStamp(input) | Commit a call (public or sealed); returns a receipt that is re-verified locally | | revealStamp(id, payload, salt) | Reveal a sealed call with its exact payload + salt | | selfResolve(id, result, evidenceUrl) | Self-resolve with a public evidence URL (labeled lower-trust) | | getVerifyBundle(id) | Public proof bundle; folds the Merkle proof locally when anchored |

Sealed calls: when reveal_now: false, createStamp returns a one-time salt — store it. The content stays hidden until you reveal it with exactly that payload and salt, or it publicly expires unrevealed at the deadline. Presaid never keeps your salt.

Verify without us

You never have to trust Presaid. @presaid/core exposes the exact primitives — strict canonical JSON, the SHA-256 commitment, and RFC-6962 Merkle proof folding — used to build and check every certificate. Recompute the commitment, fold the proof to the anchored root, read the anchoring transaction. Full method: https://presaid.io/docs/verification-spec.

License

MIT.