@heyanon-arp/sdk 0.0.3 → 0.0.5

package/dist/did/document.d.ts

@@ -5,11 +5,14 @@
  * `identity_pubkey` from the document (not `decoded(did)`) because
  * `identity_pubkey` may have rotated since registration while the DID
  * itself stays stable.
+ *
+ * No `service[]` endpoint: delivery is server-mediated and agents
+ * pull (poll/SSE inbox), so there is no per-agent inbound endpoint
+ * to advertise.
  */
 export interface DidDocument {
     id: string;
     verificationMethod: VerificationMethod[];
-    service: ServiceEndpoint[];
     metadata: {
         key_mode: KeyMode;
         owner_attestation_id: string;
@@ -23,8 +26,3 @@ export interface VerificationMethod {
     controller: string;
     publicKeyMultibase: string;
 }
-export interface ServiceEndpoint {
-    id: string;
-    type: 'ARPEndpoint';
-    serviceEndpoint: string;
-}

package/dist/did/index.d.ts

@@ -1,2 +1,2 @@
 export { formatDid, parseDid, isValidDid } from './format';
-export type { DidDocument, KeyMode, VerificationMethod, ServiceEndpoint } from './document';
+export type { DidDocument, KeyMode, VerificationMethod } from './document';

package/dist/escrow/condition-hash.d.ts

@@ -1,79 +1,66 @@
 import type { AssetIdentifier } from '../types';
 /**
- * Subset of contract terms that the on-chain `condition_hash` binds.
- * Chosen per the escrow design's "condition_hash semantics" decision:
- * fields that the parties must agree on at offer time AND that the
- * release flow must replay against. Excludes timestamps and
- * decline-reason fields (those only exist on terminal rows; including
- * them would make every accepted contract's hash dependent on
- * non-content metadata).
+ * Subset of DELEGATION terms that the on-chain `condition_hash` binds:
+ *   - `delegationId` is the identity binding — it is the root of the
+ *     on-chain derivation chain (`lock_id = sha256("arp-lock-v1" ||
+ *     delegationId_bytes16)`), so it is known before `create_lock` is
+ *     built → NOT circular.
+ *   - `currency` is the single `delegation.currency` field (the one
+ *     asset for both rate + amount); the projection reads the REAL
+ *     delegation field, so a raw delegation row binds currency with no
+ *     caller pre-mapping.
  *
- * The shape MUST match server-side `deriveConditionHash` byte-for-byte;
- * any drift breaks E5 settlement-digest reconstruction (which reads
- * `condition_hash` from the on-chain Lock and expects it to equal a
- * server-side recompute).
+ * `amount` is intentionally NOT here — the concrete locked amount AND its
+ * mint are bound at settlement via the digest (`buildReleaseDigest` binds
+ * `amount` u64 + `mint` 32B) and on-chain in the Lock account. The
+ * condition_hash binds the agreed TERMS (scope / pricing / settlement /
+ * rate / unit / currency), not the amount.
+ *
+ * The shape MUST match server-side + CLI derivation byte-for-byte; the
+ * golden vectors in `condition-hash.test.ts` pin it.
  */
-export interface ContractTermsSubset {
-    contractId: string;
-    version: number;
+export interface DelegationTermsSubset {
+    delegationId: string;
     scopeSummary: string;
     pricingModel: string;
     settlementModel: string;
     rateAmount?: string;
-    rateCurrency?: AssetIdentifier;
     rateUnit?: string;
-    allowedDelegationTags?: string[];
+    currency?: AssetIdentifier;
 }
 /**
- * Loose input shape — the contract DTO / row / public response object
- * may carry many extra fields (`state`, `relationshipId`, timestamps,
- * decline reasons, etc.). Callers pass that whole object; we project
- * onto `ContractTermsSubset` so extra fields can NEVER influence the
- * condition_hash. This protects against silent drift if the public
- * contract shape grows new fields.
- *
- * All fields are typed as optional here so a row pulled directly from
- * Mongoose (where most contract fields are optional in the schema)
- * fits the shape. The actual validity check happens inside
- * `deriveConditionHash`, which throws if a required projected field
- * is undefined — that surface is the right place to fail because
- * `condition_hash` cannot be derived without it.
+ * Loose input for `deriveDelegationConditionHash`. Callers pass a whole
+ * delegation row / DTO; we project onto `DelegationTermsSubset` so extra
+ * fields (`state`, `relationshipId`, `amount`, timestamps, decline
+ * metadata, …) can NEVER influence the hash. Defensive projection:
+ * extra fields can NEVER influence the hash.
  */
-export interface ContractLikeInput {
-    contractId?: string;
-    version?: number;
+export interface DelegationTermsInput {
+    delegationId?: string;
     scopeSummary?: string;
     pricingModel?: string;
     settlementModel?: string;
     rateAmount?: string;
-    rateCurrency?: AssetIdentifier;
     rateUnit?: string;
-    allowedDelegationTags?: string[];
+    currency?: AssetIdentifier;
     [other: string]: unknown;
 }
 /**
- * Compute the 32-byte sha256 condition_hash that binds an on-chain
- * lock to the off-chain contract terms.
- *
- * The function performs an EXPLICIT FIELD PROJECTION before
- * canonicalisation. Even if the caller passes a full contract row
- * with `state`, `createdAt`, `declineReason`, etc., only the eight
- * whitelisted fields are hashed. This is critical for digest
- * stability across SDK versions: adding a field to the public
- * contract shape MUST NOT change `condition_hash` values for existing
- * contracts.
+ * Compute the 32-byte sha256 condition_hash that binds an on-chain lock
+ * to the off-chain DELEGATION terms.
  *
- * Wire procedure:
- *   1. Project the caller's input onto the whitelisted subset.
- *   2. JCS-canonicalize via the SDK's `canonicalBytes`.
- *   3. sha256 → 32-byte digest.
+ * Wire procedure — explicit field
+ * projection → JCS canonicalize (`canonicalBytes`) → sha256. The
+ * projection is the security boundary: adding a field to the public
+ * delegation shape MUST NOT change `condition_hash` for existing
+ * delegations.
  *
- * The same procedure runs on the server during `delegation.offer`
- * validation AND during `receipt cosign` settlement-digest
- * reconstruction. Any field-set drift between offer-time and
- * cosign-time produces a different hash, which fails Ed25519 verify
- * on-chain.
+ * Runs in THREE places that MUST agree byte-for-byte: the buyer's
+ * offer-prep (CLI), the server's `delegation.offer` validation
+ * (recompute + compare to the on-chain bound hash), and the settlement
+ * digest reconstruction. Any field-set drift produces a different hash
+ * → Ed25519 settlement verify fails on-chain.
  *
  * @returns 32-byte condition_hash
  */
-export declare function deriveConditionHash(contract: ContractLikeInput): Uint8Array;
+export declare function deriveDelegationConditionHash(delegation: DelegationTermsInput): Uint8Array;

package/dist/escrow/create-lock.d.ts

@@ -4,7 +4,7 @@ export interface CreateLockArgs {
     lockId: Uint8Array;
     /** u64 amount in base units. */
     amount: bigint;
-    /** 32-byte condition_hash (deriveConditionHash output). */
+    /** 32-byte condition_hash (deriveDelegationConditionHash output). */
     conditionHash: Uint8Array;
     /** u64 unix-seconds expiry. */
     expiry: bigint;

package/dist/escrow/index.d.ts

@@ -1,4 +1,4 @@
 export { deriveLockId, delegationIdToBytes16, bytes16ToDelegationId } from './lock-id';
-export { deriveConditionHash, type ContractTermsSubset, type ContractLikeInput } from './condition-hash';
+export { deriveDelegationConditionHash, type DelegationTermsSubset, type DelegationTermsInput } from './condition-hash';
 export { parseCaip19SolanaAssetId, type ParsedSolanaAssetId } from './caip19';
 export { buildCreateLockIxData, computeCreateLockDiscriminator, CREATE_LOCK_DISCRIMINATOR, type CreateLockArgs, } from './create-lock';

package/dist/escrow/lock-id.d.ts

@@ -41,7 +41,7 @@ export declare function deriveLockId(delegationId: string): Uint8Array;
  * Either way, the same 16-byte representation comes out (UUID body is
  * the lock-id substrate; the `del_` prefix is a wrapper that exists
  * only so the wire shape is unambiguously a delegation reference vs.
- * a contract / receipt id elsewhere in the canonical JSON). Pushing
+ * a receipt id elsewhere in the canonical JSON). Pushing
  * this normalization down into the SDK gives every caller — CLI,
  * server, future TypeScript clients — a single source of truth.
  *

package/dist/index.d.ts

@@ -9,7 +9,6 @@
  *   - envelope     — sign / verify envelope (steps 4-6 of protocol verification)
  *   - cosignature  — receipt + dispute-response co-signatures
  *   - challenge    — ARP-CHALLENGE-v1 ownership proof (registration / rotation)
- *   - webhook      — ARP-WEBHOOK-v1 HMAC header (outbox delivery)
  *   - attestation  — scrypt key-link + key-rotation attestations
  *   - server-chain — signed_message_hash, server_event_hash, audit walker
  *   - settlement   — ARP-SOLANA-* digest stubs (V1.5)
@@ -27,7 +26,6 @@ export * from './did';
 export * from './envelope';
 export * from './cosignature';
 export * from './challenge';
-export * from './webhook';
 export * from './attestation';
 export * from './server-chain';
 export * from './settlement';

package/dist/index.js

@@ -160,8 +160,6 @@ var Purpose = {
   RECEIPT: "ARP-RECEIPT-v1",
   /** Dispute response co-signature payload. */
   DISPUTE_RESPONSE: "ARP-DISPUTE-RESPONSE-v1",
-  /** Webhook delivery HMAC signature payload. */
-  WEBHOOK: "ARP-WEBHOOK-v1",
   /** Identity ownership challenge proof. */
   CHALLENGE: "ARP-CHALLENGE-v1",
   /** Verifiable Credential issued by the platform. */
@@ -267,23 +265,6 @@ function verifyChallenge(challengeBytes, signature, identityPubkey) {
   if (signature.length !== 64) return false;
   return verify2(signature, buildSigningInput(challengeBytes), identityPubkey);
 }
-function buildWebhookSignatureHeader(input, sharedSecret) {
-  const digest = sha2.sha256(canonicalBytes(input));
-  const mac = hmac.hmac(sha2.sha256, sharedSecret, digest);
-  return `${Purpose.WEBHOOK}=${base.base64.encode(mac)}`;
-}
-function verifyWebhookSignatureHeader(headerValue, input, sharedSecret) {
-  const expected = buildWebhookSignatureHeader(input, sharedSecret);
-  return constantTimeEqual(expected, headerValue);
-}
-function constantTimeEqual(a, b) {
-  if (a.length !== b.length) return false;
-  let diff = 0;
-  for (let i = 0; i < a.length; i++) {
-    diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
-  }
-  return diff === 0;
-}
 
 // src/types/identity.ts
 var SCRYPT_PARAMS = {
@@ -580,16 +561,15 @@ function u16LE(value) {
 var SPL_TOKEN_PROGRAM_ID_BASE58 = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
 var TOKEN_2022_PROGRAM_ID_BASE58 = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
 function detectTokenProgramFromOwner(mintAccountOwnerBase58) {
-  switch (mintAccountOwnerBase58) {
-    case SPL_TOKEN_PROGRAM_ID_BASE58:
-      return { kind: "legacy", programIdBase58: SPL_TOKEN_PROGRAM_ID_BASE58 };
-    case TOKEN_2022_PROGRAM_ID_BASE58:
-      return { kind: "token-2022", programIdBase58: TOKEN_2022_PROGRAM_ID_BASE58 };
-    default:
-      throw new Error(
-        `detectTokenProgram: unsupported mint owner ${mintAccountOwnerBase58}; ARP escrow supports legacy SPL Token (${SPL_TOKEN_PROGRAM_ID_BASE58}) and Token-2022 (${TOKEN_2022_PROGRAM_ID_BASE58}) only`
-      );
+  if (mintAccountOwnerBase58 === SPL_TOKEN_PROGRAM_ID_BASE58) {
+    return { kind: "legacy", programIdBase58: SPL_TOKEN_PROGRAM_ID_BASE58 };
+  }
+  if (mintAccountOwnerBase58 === TOKEN_2022_PROGRAM_ID_BASE58) {
+    throw new Error(
+      `detectTokenProgram: mint owner is the Token-2022 program (${TOKEN_2022_PROGRAM_ID_BASE58}), which ARP escrow does not support; use a legacy SPL Token mint (${SPL_TOKEN_PROGRAM_ID_BASE58}) or native SOL`
+    );
   }
+  throw new Error(`detectTokenProgram: unsupported mint owner ${mintAccountOwnerBase58}; ARP escrow supports legacy SPL Token (${SPL_TOKEN_PROGRAM_ID_BASE58}) only`);
 }
 function detectTokenProgramFromOwnerBytes(mintAccountOwnerBytes) {
   if (mintAccountOwnerBytes.length !== 32) {
@@ -738,24 +718,22 @@ function resolveAsset(input) {
   return null;
 }
 var WELL_KNOWN_ASSET_KEYS = Object.keys(WELL_KNOWN_ASSETS);
-function deriveConditionHash(contract) {
-  const required = ["contractId", "version", "scopeSummary", "pricingModel", "settlementModel"];
+function deriveDelegationConditionHash(delegation) {
+  const required = ["delegationId", "scopeSummary", "pricingModel", "settlementModel"];
   for (const field of required) {
-    if (contract[field] === void 0) {
-      throw new Error(`deriveConditionHash: required field '${String(field)}' is missing from the contract input`);
+    if (delegation[field] === void 0) {
+      throw new Error(`deriveDelegationConditionHash: required field '${String(field)}' is missing from the delegation input`);
     }
   }
   const subset = {
-    contractId: contract.contractId,
-    version: contract.version,
-    scopeSummary: contract.scopeSummary,
-    pricingModel: contract.pricingModel,
-    settlementModel: contract.settlementModel
+    delegationId: delegation.delegationId,
+    scopeSummary: delegation.scopeSummary,
+    pricingModel: delegation.pricingModel,
+    settlementModel: delegation.settlementModel
   };
-  if (contract.rateAmount !== void 0) subset.rateAmount = contract.rateAmount;
-  if (contract.rateCurrency !== void 0) subset.rateCurrency = contract.rateCurrency;
-  if (contract.rateUnit !== void 0) subset.rateUnit = contract.rateUnit;
-  if (contract.allowedDelegationTags !== void 0) subset.allowedDelegationTags = contract.allowedDelegationTags;
+  if (delegation.rateAmount !== void 0) subset.rateAmount = delegation.rateAmount;
+  if (delegation.rateUnit !== void 0) subset.rateUnit = delegation.rateUnit;
+  if (delegation.currency !== void 0) subset.currency = delegation.currency;
   const bytes = canonicalBytes(subset);
   return sha2.sha256(bytes);
 }
@@ -835,7 +813,6 @@ exports.SETTLEMENT_PURPOSES = SETTLEMENT_PURPOSES;
 exports.SLIP44_SOLANA = SLIP44_SOLANA;
 exports.SOLANA_CLUSTER_IDS = SOLANA_CLUSTER_IDS;
 exports.SPL_TOKEN_PROGRAM_ID_BASE58 = SPL_TOKEN_PROGRAM_ID_BASE58;
-exports.TOKEN_2022_PROGRAM_ID_BASE58 = TOKEN_2022_PROGRAM_ID_BASE58;
 exports.USDC_MINTS = USDC_MINTS;
 exports.WELL_KNOWN_ASSETS = WELL_KNOWN_ASSETS;
 exports.WELL_KNOWN_ASSET_KEYS = WELL_KNOWN_ASSET_KEYS;
@@ -845,14 +822,13 @@ exports.buildCreateLockIxData = buildCreateLockIxData;
 exports.buildPartialReleaseDigest = buildPartialReleaseDigest;
 exports.buildRefundDigest = buildRefundDigest;
 exports.buildReleaseDigest = buildReleaseDigest;
-exports.buildWebhookSignatureHeader = buildWebhookSignatureHeader;
 exports.bytes16ToDelegationId = bytes16ToDelegationId;
 exports.canonicalBytes = canonicalBytes;
 exports.canonicalJson = canonicalJson;
 exports.canonicalSha256Hex = canonicalSha256Hex;
 exports.computeCreateLockDiscriminator = computeCreateLockDiscriminator;
 exports.delegationIdToBytes16 = delegationIdToBytes16;
-exports.deriveConditionHash = deriveConditionHash;
+exports.deriveDelegationConditionHash = deriveDelegationConditionHash;
 exports.deriveLockId = deriveLockId;
 exports.deriveScryptKey = deriveScryptKey;
 exports.detectTokenProgramFromOwner = detectTokenProgramFromOwner;
@@ -888,4 +864,3 @@ exports.verifyCosignature = verifyCosignature;
 exports.verifyEnvelope = verifyEnvelope;
 exports.verifyKeyLinkAttestation = verifyKeyLinkAttestation;
 exports.verifyKeyRotationAttestation = verifyKeyRotationAttestation;
-exports.verifyWebhookSignatureHeader = verifyWebhookSignatureHeader;

package/dist/index.mjs

@@ -135,8 +135,6 @@ var Purpose = {
   RECEIPT: "ARP-RECEIPT-v1",
   /** Dispute response co-signature payload. */
   DISPUTE_RESPONSE: "ARP-DISPUTE-RESPONSE-v1",
-  /** Webhook delivery HMAC signature payload. */
-  WEBHOOK: "ARP-WEBHOOK-v1",
   /** Identity ownership challenge proof. */
   CHALLENGE: "ARP-CHALLENGE-v1",
   /** Verifiable Credential issued by the platform. */
@@ -242,23 +240,6 @@ function verifyChallenge(challengeBytes, signature, identityPubkey) {
   if (signature.length !== 64) return false;
   return verify2(signature, buildSigningInput(challengeBytes), identityPubkey);
 }
-function buildWebhookSignatureHeader(input, sharedSecret) {
-  const digest = sha256(canonicalBytes(input));
-  const mac = hmac(sha256, sharedSecret, digest);
-  return `${Purpose.WEBHOOK}=${base64.encode(mac)}`;
-}
-function verifyWebhookSignatureHeader(headerValue, input, sharedSecret) {
-  const expected = buildWebhookSignatureHeader(input, sharedSecret);
-  return constantTimeEqual(expected, headerValue);
-}
-function constantTimeEqual(a, b) {
-  if (a.length !== b.length) return false;
-  let diff = 0;
-  for (let i = 0; i < a.length; i++) {
-    diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
-  }
-  return diff === 0;
-}
 
 // src/types/identity.ts
 var SCRYPT_PARAMS = {
@@ -555,16 +536,15 @@ function u16LE(value) {
 var SPL_TOKEN_PROGRAM_ID_BASE58 = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
 var TOKEN_2022_PROGRAM_ID_BASE58 = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
 function detectTokenProgramFromOwner(mintAccountOwnerBase58) {
-  switch (mintAccountOwnerBase58) {
-    case SPL_TOKEN_PROGRAM_ID_BASE58:
-      return { kind: "legacy", programIdBase58: SPL_TOKEN_PROGRAM_ID_BASE58 };
-    case TOKEN_2022_PROGRAM_ID_BASE58:
-      return { kind: "token-2022", programIdBase58: TOKEN_2022_PROGRAM_ID_BASE58 };
-    default:
-      throw new Error(
-        `detectTokenProgram: unsupported mint owner ${mintAccountOwnerBase58}; ARP escrow supports legacy SPL Token (${SPL_TOKEN_PROGRAM_ID_BASE58}) and Token-2022 (${TOKEN_2022_PROGRAM_ID_BASE58}) only`
-      );
+  if (mintAccountOwnerBase58 === SPL_TOKEN_PROGRAM_ID_BASE58) {
+    return { kind: "legacy", programIdBase58: SPL_TOKEN_PROGRAM_ID_BASE58 };
+  }
+  if (mintAccountOwnerBase58 === TOKEN_2022_PROGRAM_ID_BASE58) {
+    throw new Error(
+      `detectTokenProgram: mint owner is the Token-2022 program (${TOKEN_2022_PROGRAM_ID_BASE58}), which ARP escrow does not support; use a legacy SPL Token mint (${SPL_TOKEN_PROGRAM_ID_BASE58}) or native SOL`
+    );
   }
+  throw new Error(`detectTokenProgram: unsupported mint owner ${mintAccountOwnerBase58}; ARP escrow supports legacy SPL Token (${SPL_TOKEN_PROGRAM_ID_BASE58}) only`);
 }
 function detectTokenProgramFromOwnerBytes(mintAccountOwnerBytes) {
   if (mintAccountOwnerBytes.length !== 32) {
@@ -713,24 +693,22 @@ function resolveAsset(input) {
   return null;
 }
 var WELL_KNOWN_ASSET_KEYS = Object.keys(WELL_KNOWN_ASSETS);
-function deriveConditionHash(contract) {
-  const required = ["contractId", "version", "scopeSummary", "pricingModel", "settlementModel"];
+function deriveDelegationConditionHash(delegation) {
+  const required = ["delegationId", "scopeSummary", "pricingModel", "settlementModel"];
   for (const field of required) {
-    if (contract[field] === void 0) {
-      throw new Error(`deriveConditionHash: required field '${String(field)}' is missing from the contract input`);
+    if (delegation[field] === void 0) {
+      throw new Error(`deriveDelegationConditionHash: required field '${String(field)}' is missing from the delegation input`);
     }
   }
   const subset = {
-    contractId: contract.contractId,
-    version: contract.version,
-    scopeSummary: contract.scopeSummary,
-    pricingModel: contract.pricingModel,
-    settlementModel: contract.settlementModel
+    delegationId: delegation.delegationId,
+    scopeSummary: delegation.scopeSummary,
+    pricingModel: delegation.pricingModel,
+    settlementModel: delegation.settlementModel
   };
-  if (contract.rateAmount !== void 0) subset.rateAmount = contract.rateAmount;
-  if (contract.rateCurrency !== void 0) subset.rateCurrency = contract.rateCurrency;
-  if (contract.rateUnit !== void 0) subset.rateUnit = contract.rateUnit;
-  if (contract.allowedDelegationTags !== void 0) subset.allowedDelegationTags = contract.allowedDelegationTags;
+  if (delegation.rateAmount !== void 0) subset.rateAmount = delegation.rateAmount;
+  if (delegation.rateUnit !== void 0) subset.rateUnit = delegation.rateUnit;
+  if (delegation.currency !== void 0) subset.currency = delegation.currency;
   const bytes = canonicalBytes(subset);
   return sha256(bytes);
 }
@@ -795,4 +773,4 @@ function computeCreateLockDiscriminator() {
   return h.slice(0, 8);
 }
 
-export { CAIP19_REGEX, COSIGNATURE_PURPOSES, CREATE_LOCK_DISCRIMINATOR, DECLINE_REASONS, PROTECTED_PURPOSES, PURPOSE_PARTIAL_RELEASE_STRING, PURPOSE_REFUND_STRING, PURPOSE_RELEASE_STRING, Purpose, REFUND_REASON_BYTES, SCRYPT_PARAMS, SETTLEMENT_PURPOSES, SLIP44_SOLANA, SOLANA_CLUSTER_IDS, SPL_TOKEN_PROGRAM_ID_BASE58, TOKEN_2022_PROGRAM_ID_BASE58, USDC_MINTS, WELL_KNOWN_ASSETS, WELL_KNOWN_ASSET_KEYS, base58btcDecode, base58btcEncode, buildCreateLockIxData, buildPartialReleaseDigest, buildRefundDigest, buildReleaseDigest, buildWebhookSignatureHeader, bytes16ToDelegationId, canonicalBytes, canonicalJson, canonicalSha256Hex, computeCreateLockDiscriminator, delegationIdToBytes16, deriveConditionHash, deriveLockId, deriveScryptKey, detectTokenProgramFromOwner, detectTokenProgramFromOwnerBytes, expiresAt, findFirstChainDivergence, formatDid, generateKeyPair, getPublicKey2 as getPublicKey, isAssetIdentifier, isDeclineReason, isValidDid, parseCaip19SolanaAssetId, parseDid, pollUntil, resolveAsset, rfc3339, scryptPasswordProofSign, scryptPasswordProofVerify, senderNonce, serverEventHash, sign2 as sign, signChallenge, signCosignature, signEnvelope, signKeyLinkAttestation, signKeyRotationAttestation, signedMessageHash, uuidV4, verify2 as verify, verifyChallenge, verifyCosignature, verifyEnvelope, verifyKeyLinkAttestation, verifyKeyRotationAttestation, verifyWebhookSignatureHeader };
+export { CAIP19_REGEX, COSIGNATURE_PURPOSES, CREATE_LOCK_DISCRIMINATOR, DECLINE_REASONS, PROTECTED_PURPOSES, PURPOSE_PARTIAL_RELEASE_STRING, PURPOSE_REFUND_STRING, PURPOSE_RELEASE_STRING, Purpose, REFUND_REASON_BYTES, SCRYPT_PARAMS, SETTLEMENT_PURPOSES, SLIP44_SOLANA, SOLANA_CLUSTER_IDS, SPL_TOKEN_PROGRAM_ID_BASE58, USDC_MINTS, WELL_KNOWN_ASSETS, WELL_KNOWN_ASSET_KEYS, base58btcDecode, base58btcEncode, buildCreateLockIxData, buildPartialReleaseDigest, buildRefundDigest, buildReleaseDigest, bytes16ToDelegationId, canonicalBytes, canonicalJson, canonicalSha256Hex, computeCreateLockDiscriminator, delegationIdToBytes16, deriveDelegationConditionHash, deriveLockId, deriveScryptKey, detectTokenProgramFromOwner, detectTokenProgramFromOwnerBytes, expiresAt, findFirstChainDivergence, formatDid, generateKeyPair, getPublicKey2 as getPublicKey, isAssetIdentifier, isDeclineReason, isValidDid, parseCaip19SolanaAssetId, parseDid, pollUntil, resolveAsset, rfc3339, scryptPasswordProofSign, scryptPasswordProofVerify, senderNonce, serverEventHash, sign2 as sign, signChallenge, signCosignature, signEnvelope, signKeyLinkAttestation, signKeyRotationAttestation, signedMessageHash, uuidV4, verify2 as verify, verifyChallenge, verifyCosignature, verifyEnvelope, verifyKeyLinkAttestation, verifyKeyRotationAttestation };

package/dist/purpose.d.ts

@@ -7,8 +7,8 @@
  * "this byte string was signed" assertion is not enough; the bytes
  * themselves carry the role).
  *
- * Adding a new purpose = add an entry here AND amend
- * [00-core/protocol.md](../../00-core/protocol.md) in the same PR.
+ * Adding a new purpose means adding an entry here and keeping
+ * [00-core/protocol.md](../../00-core/protocol.md) in sync.
  */
 export declare const Purpose: {
     /** Default for `protected.purpose` on body messages. */
@@ -17,8 +17,6 @@ export declare const Purpose: {
     readonly RECEIPT: "ARP-RECEIPT-v1";
     /** Dispute response co-signature payload. */
     readonly DISPUTE_RESPONSE: "ARP-DISPUTE-RESPONSE-v1";
-    /** Webhook delivery HMAC signature payload. */
-    readonly WEBHOOK: "ARP-WEBHOOK-v1";
     /** Identity ownership challenge proof. */
     readonly CHALLENGE: "ARP-CHALLENGE-v1";
     /** Verifiable Credential issued by the platform. */
@@ -45,7 +43,7 @@ export declare const Purpose: {
 export type PurposeValue = (typeof Purpose)[keyof typeof Purpose];
 /**
  * `protected.purpose` accepts a subset — the others are payload-level
- * (co-signature / settlement-signature / webhook).
+ * (co-signature / settlement-signature).
  */
 export declare const PROTECTED_PURPOSES: readonly PurposeValue[];
 export declare const COSIGNATURE_PURPOSES: readonly PurposeValue[];

package/dist/settlement/index.d.ts

@@ -1,4 +1,4 @@
 export { buildReleaseDigest, buildPartialReleaseDigest, buildRefundDigest, REFUND_REASON_BYTES, PURPOSE_RELEASE_STRING, PURPOSE_PARTIAL_RELEASE_STRING, PURPOSE_REFUND_STRING, } from './settlement';
 export type { ReleaseDigestInput, PartialReleaseDigestInput, RefundDigestInput, RefundReasonByte } from './settlement';
-export { detectTokenProgramFromOwner, detectTokenProgramFromOwnerBytes, SPL_TOKEN_PROGRAM_ID_BASE58, TOKEN_2022_PROGRAM_ID_BASE58, } from './token-program';
+export { detectTokenProgramFromOwner, detectTokenProgramFromOwnerBytes, SPL_TOKEN_PROGRAM_ID_BASE58 } from './token-program';
 export type { TokenProgramKind, TokenProgramDetection } from './token-program';

package/dist/settlement/token-program.d.ts

@@ -1,47 +1,34 @@
 /**
- * Token-2022 program detection helpers.
+ * Token program detection helpers.
  *
- * The escrow contract dispatches transfer / close-account CPIs based on
- * the mint's program kind: legacy SPL Token (`TokenkegQ...`) or Token-2022
- * (`TokenzQdB...`). The kind is detected on-chain from the mint account's
- * `owner` field; this helper mirrors that logic for off-chain consumers
- * (tx builders, indexers, decoders).
+ * ARP escrow settles in native SOL or a legacy SPL Token mint. The
+ * escrow contract dispatches transfer / close-account CPIs based on the
+ * mint's program kind, detected on-chain from the mint account's `owner`
+ * field; this helper mirrors that logic for off-chain consumers (tx
+ * builders, indexers, decoders).
  *
- * The function takes a 40-byte (or longer) account info buffer in the
- * standard Solana on-chain account layout — the FIRST 32 bytes are the
- * account's owner pubkey (in the wire-level AccountInfoSerialised shape
- * used by getAccountInfo RPC's "encoding=base64" + custom layout). For
- * the more common `getAccountInfo` response, callers should pass the
- * `owner` field directly via a 32-byte buffer.
+ * Token-2022 (the token-extensions program) is NOT supported — a mint
+ * owned by it is rejected here so it can never enter the escrow flow.
  *
- * NOTE: `mintAccountOwnerPubkey` is the OWNER of the mint account on
- * Solana — i.e. the token program that minted it — NOT the mint's
- * mint_authority. Confusingly, both are called "owner" in different
- * contexts.
+ * The function takes the mint account's `owner` pubkey — the program
+ * that minted it — NOT the mint's mint_authority. Confusingly, both are
+ * called "owner" in different contexts.
  */
 /**
  * Legacy SPL Token program ID (base58: `TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA`).
  */
 export declare const SPL_TOKEN_PROGRAM_ID_BASE58 = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
 /**
- * Token-2022 program ID (base58: `TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb`).
- */
-export declare const TOKEN_2022_PROGRAM_ID_BASE58 = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
-/**
- * Token program kind. Maps to the new contract's `token_program_kind`
- * u8 emitted on `LockCreated` events
- * (`apps/arp-solana-contract/programs/arp-solana-contract/src/events.rs`):
- *   'native'     → 0  (mint == `Pubkey::default()`; the program
- *                      ignores the token_program slot but Anchor
- *                      still requires SPL Token or Token-2022 in it)
- *   'legacy'     → 1  (legacy SPL Token program)
- *   'token-2022' → 2  (Token-2022 program)
+ * Token program kind. Maps to the contract's `token_program_kind` u8 on
+ * `LockCreated` events: `native` → 0, `legacy` → 1. (The contract also
+ * defines `2` for Token-2022, but ARP no longer supports it — such a
+ * lock is rejected before it is tracked, so this type never carries it.)
  *
- * `detectTokenProgramFromOwner` below resolves the kind for a NON-
- * native mint by looking at its `.owner` field; native locks are
- * detected from the mint slot value, not from this helper.
+ * `detectTokenProgramFromOwner` resolves the kind for a NON-native mint
+ * by looking at its `.owner` field; native locks are detected from the
+ * mint slot value, not from this helper.
  */
-export type TokenProgramKind = 'legacy' | 'token-2022' | 'native';
+export type TokenProgramKind = 'legacy' | 'native';
 /**
  * Result of `detectTokenProgram`: the program kind + a typed branding for
  * downstream consumers.
@@ -55,9 +42,9 @@ export interface TokenProgramDetection {
  * Detect a mint's token program kind from its OWNER pubkey (the program
  * that owns the mint account in Solana account terms).
  *
- * Throws if the owner is neither legacy SPL Token nor Token-2022 — escrow
- * does not support any other token program (would dispatch CPI to a
- * non-existent surface).
+ * Returns `legacy` for a legacy SPL Token mint. Throws for a Token-2022
+ * mint (unsupported) or any other owner — escrow would otherwise
+ * dispatch a CPI to a surface it does not handle.
  *
  * @param mintAccountOwnerBase58 — the mint account's `.owner` field as
  * a base58 string. From `connection.getAccountInfo(mintPubkey)`, this is

package/dist/types/body.d.ts

@@ -9,8 +9,8 @@
  */
 import type { Body, Did, Sha256Hex } from './envelope';
 /**
- * Chain-qualified asset identifier carried by `contract.rate_currency`
- * and `delegation.currency`. Replaces the V1 string-enum `'USDC'`
+ * Chain-qualified asset identifier carried by `delegation.currency`
+ * (the single asset for both rate + amount). Replaces the V1 string-enum `'USDC'`
  * placeholder — that shape can't disambiguate `USDC on Solana mainnet`
  * from `USDC on Polygon` or `USDC.e bridged on Avalanche` (all the same
  * ticker, different on-chain assets). It also can't represent native
@@ -28,14 +28,10 @@ import type { Body, Did, Sha256Hex } from './envelope';
  *   - `symbol` — short human-readable hint for UI ("USDC", "SOL").
  *     Not used for any logic — purely display sugar. Optional.
  *
- * Validation invariants (server-enforced, both `rate_currency` on the
- * contract and `currency` on the delegation):
+ * Validation invariants (server-enforced on `delegation.currency`):
  *   • `asset_id` ∈ /^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}\/[-a-z0-9]{3,8}:[-.%a-zA-Z0-9]{1,128}$/
  *   • `decimals` ∈ [0, 18]
  *   • `symbol` length ∈ [1, 16] if present
- *   • For `delegation.currency`: must match the contract's
- *     `rate_currency.asset_id` if the contract specifies one
- *     (a delegation under a USDC-priced contract can't quote in SOL).
  */
 export interface AssetIdentifier {
     /** CAIP-19 chain-qualified asset id — e.g. `solana:5eykt.../spl:EPjFWdd5...` */
@@ -47,9 +43,8 @@ export interface AssetIdentifier {
 }
 /**
  * Closed enum of machine-readable decline reasons used across the
- * three decline sites in V1:
+ * two decline sites in V1:
  *   • `handshake_response.content.decision === 'decline'`
- *   • `contract.content.action === 'decline'`
  *   • `delegation.content.action === 'decline'`
  *
  * Required on every decline envelope so the counterparty's reactor
@@ -77,7 +72,7 @@ export declare const DECLINE_REASONS: readonly DeclineReason[];
 export declare function isDeclineReason(v: unknown): v is DeclineReason;
 /**
  * `handshake` — first signed exchange between two agents. Establishes
- * relationship; not a contract.
+ * the relationship; carries no terms (those live on the delegation).
  */
 export interface HandshakeBody extends Body<HandshakeContent> {
     type: 'handshake';
@@ -110,32 +105,8 @@ export interface HandshakeResponseContent {
     [extra: string]: unknown;
 }
 /**
- * `contract` — co-signed agreement between two agents. `action`
- * discriminates lifecycle events.
- */
-export interface ContractBody extends Body<ContractContent> {
-    type: 'contract';
-}
-export interface ContractContent {
-    action: 'proposal' | 'counter' | 'sign' | 'decline';
-    contract_id: string;
-    version: number;
-    scope_summary?: string;
-    pricing_model?: 'flat' | 'usage_based';
-    settlement_model?: 'prepaid' | 'escrow';
-    rate_amount?: string;
-    rate_currency?: AssetIdentifier;
-    rate_unit?: 'task' | 'thread' | 'handoff';
-    allowed_delegation_tags?: string[];
-    /** Machine-readable reason — REQUIRED when `action === 'decline'`. See `DeclineReason`. */
-    reason?: DeclineReason;
-    /** Optional free-text elaboration (e.g. "rate floor 0.20 USDC for current model pricing"). */
-    reason_detail?: string;
-    [extra: string]: unknown;
-}
-/**
- * `delegation` — concrete task offer or lifecycle action under an
- * active contract. `action` discriminates the lifecycle event.
+ * `delegation` — concrete task offer or lifecycle action. `action`
+ * discriminates the lifecycle event.
  */
 export interface DelegationBody extends Body<DelegationContent> {
     type: 'delegation';
@@ -143,13 +114,17 @@ export interface DelegationBody extends Body<DelegationContent> {
 export interface DelegationContent {
     action: 'offer' | 'accept' | 'decline' | 'cancel';
     delegation_id: string;
-    contract_id: string;
     title?: string;
     brief?: Record<string, unknown>;
     acceptance_criteria?: string[];
     deadline?: string;
     amount?: string;
     currency?: AssetIdentifier;
+    scope_summary?: string;
+    pricing_model?: 'flat' | 'usage_based';
+    settlement_model?: 'prepaid' | 'escrow';
+    rate_amount?: string;
+    rate_unit?: 'task' | 'thread' | 'handoff';
     /** Machine-readable reason — REQUIRED when `action === 'decline'`. See `DeclineReason`. */
     reason?: DeclineReason;
     /** Optional free-text elaboration (e.g. "delegation offer missing required brief.goal field"). */
@@ -210,18 +185,6 @@ export interface ReceiptContent {
     notes_hash?: Sha256Hex;
     [extra: string]: unknown;
 }
-/**
- * `memory_delta` — append-only update to a relationship's shared memory.
- */
-export interface MemoryDeltaBody extends Body<MemoryDeltaContent> {
-    type: 'memory_delta';
-}
-export interface MemoryDeltaContent {
-    kind: 'intro' | 'handoff' | 'preference' | 'note' | 'decision' | 'continuity';
-    scope: 'thread_only' | 'thread_and_pilot';
-    content: string;
-    supersedes?: string;
-}
 /**
  * `dispute` — challenge against a delegation outcome. `action`
  * discriminates lifecycle events.
@@ -327,7 +290,7 @@ export interface SettlementSignatureContent {
      * Unix seconds — the `expires_at` value the payee bound into the
      * digest. Server re-uses it when reconstructing the digest and
      * cross-checks against `expires_at > now` + `expires_at <=
-     * lock.expiry - DISPUTE_BUFFER_SECONDS` (ADR-12 §4). The payer
+     * lock.expiry - DISPUTE_BUFFER_SECONDS`. The payer
      * echoes the SAME value on the cosign envelope's settlement_signatures
      * block so both sides sign the same bytes.
      */
@@ -336,7 +299,7 @@ export interface SettlementSignatureContent {
      * Base-unit decimal-integer string — required when `purpose ===
      * 'ARP-SOLANA-PARTIAL-RELEASE-v1.5'`, omitted (or undefined) for
      * full RELEASE. The server cross-checks it against
-     * `receipt.usage.computed_amount` for usage_based contracts before
+     * `receipt.usage.computed_amount` for usage_based delegations before
      * verifying the digest (same invariant
      * `ESC_USAGE_COMPUTED_AMOUNT_MISMATCH` already guards on the
      * propose-time receipt body).
@@ -348,7 +311,7 @@ export interface SettlementSignatureContent {
  * Union over every standard body type. Consumers can narrow on
  * `body.type` via discriminated dispatch.
  */
-export type AnyBody = HandshakeBody | HandshakeResponseBody | ContractBody | DelegationBody | WorkRequestBody | WorkResponseBody | ReceiptBody | MemoryDeltaBody | DisputeBody | SettlementSignatureBody;
+export type AnyBody = HandshakeBody | HandshakeResponseBody | DelegationBody | WorkRequestBody | WorkResponseBody | ReceiptBody | DisputeBody | SettlementSignatureBody;
 /** Receipt co-signature payload — what gets `payload_hash`'d in `attachments.co_signature`. */
 export interface ReceiptCosignPayload {
     purpose: 'ARP-RECEIPT-v1';

package/dist/types/envelope.d.ts

@@ -3,7 +3,7 @@ import type { PurposeValue } from '../purpose';
  * Wire-level types per [00-core/protocol.md](../../../00-core/protocol.md)
  * and [00-core/schemas.md](../../../00-core/schemas.md).
  *
- * Body-type-specific shapes (handshake / contract / delegation / receipt
+ * Body-type-specific shapes (handshake / delegation / receipt
  * / etc.) live alongside their handlers in the consumer code — keeping
  * them out of this file avoids the SDK becoming a kitchen-sink of every
  * message type. A consumer who needs typed bodies can extend `Envelope<T>`

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 export type { Sha256Hex, Ed25519Sig, Did, ProtectedBlock, Body, Attachments, CoSignature, SettlementSignatures, SettlementParty, EscrowLockAttachment, Envelope, PersistedEvent, } from './envelope';
-export type { HandshakeBody, HandshakeContent, HandshakeResponseBody, HandshakeResponseContent, ContractBody, ContractContent, DelegationBody, DelegationContent, WorkRequestBody, WorkRequestContent, WorkResponseBody, WorkResponseContent, ReceiptBody, ReceiptContent, MemoryDeltaBody, MemoryDeltaContent, DisputeBody, DisputeContent, SettlementSignatureBody, SettlementSignatureContent, AnyBody, ReceiptCosignPayload, DisputeResponseCosignPayload, CosignPayload, DeclineReason, AssetIdentifier, } from './body';
+export type { HandshakeBody, HandshakeContent, HandshakeResponseBody, HandshakeResponseContent, DelegationBody, DelegationContent, WorkRequestBody, WorkRequestContent, WorkResponseBody, WorkResponseContent, ReceiptBody, ReceiptContent, DisputeBody, DisputeContent, SettlementSignatureBody, SettlementSignatureContent, AnyBody, ReceiptCosignPayload, DisputeResponseCosignPayload, CosignPayload, DeclineReason, AssetIdentifier, } from './body';
 export { DECLINE_REASONS, isDeclineReason } from './body';
 export type { OwnerSigningMethod, KeyLinkPayload, KeyRotationPayload, ScryptPasswordAttestation } from './identity';
 export { SCRYPT_PARAMS } from './identity';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heyanon-arp/sdk",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "TypeScript SDK for the Agent Relationship Protocol — canonical JSON, Ed25519 envelope sign/verify, did:arp identity, receipt co-signatures, scrypt key attestation, chain-audit helpers.",
   "license": "MIT",
   "keywords": [

package/dist/webhook/index.d.ts

@@ -1,2 +0,0 @@
-export { buildWebhookSignatureHeader, verifyWebhookSignatureHeader } from './webhook';
-export type { WebhookSignableInput } from './webhook';

package/dist/webhook/webhook.d.ts

@@ -1,38 +0,0 @@
-/**
- * `ARP-WEBHOOK-v1` HMAC over the canonical webhook envelope. Used by
- * the OutboxDeliveryWorker for the `X-ARP-Signature` header.
- *
- * Inputs (per backend's outbox spec):
- *   - delivery_id              — outbox row id
- *   - recipient_did
- *   - envelope_message_id      — envelope being delivered
- *   - server_event_hash        — chain head at delivery time
- *   - attempt_n                — 1-based retry counter
- *   - served_at                — RFC3339, when this attempt was generated
- *
- * Each retry produces a different MAC because `attempt_n` and
- * `served_at` participate in canonical input — replays of an old
- * header on a fresh attempt fail HMAC verification.
- */
-export interface WebhookSignableInput {
-    delivery_id: string;
-    recipient_did: string;
-    envelope_message_id: string;
-    server_event_hash: string;
-    attempt_n: number;
-    served_at: string;
-}
-/**
- * Compute `X-ARP-Signature` value: `<purpose>=<base64(HMAC-SHA256(secret, sha256(canonical_json(input))))>`.
- *
- * Recipients lookup their per-sender shared secret, recompute the
- * HMAC over the same canonical input, and compare against the
- * received header.
- */
-export declare function buildWebhookSignatureHeader(input: WebhookSignableInput, sharedSecret: Uint8Array): string;
-/**
- * Constant-time compare an inbound `X-ARP-Signature` header against
- * the expected one. Returns `false` on shape mismatch, missing
- * purpose label, or HMAC mismatch — never throws.
- */
-export declare function verifyWebhookSignatureHeader(headerValue: string, input: WebhookSignableInput, sharedSecret: Uint8Array): boolean;