@heyanon-arp/sdk 0.0.35 → 0.0.37

package/dist/assets.d.ts

@@ -91,6 +91,20 @@ export declare function findAssetByAssetId(assetId: string): {
     cluster: SolanaCluster;
     key: string;
 } | null;
+/**
+ * Best-effort mint → display metadata, for labelling settlement-volume buckets.
+ *   - native SOL sentinel → `{ SOL, 9 }` (assetId null: the `slip44` CAIP-19 is
+ *     cluster-specific and the bare mint can't disambiguate devnet/mainnet);
+ *   - SPL mint → the EXACT whitelist entry (an SPL mint is cluster-unique, so
+ *     symbol + decimals + asset_id are precise);
+ *   - unrecognised mint → all null (the caller still has the raw mint + the
+ *     base-unit sum, so the figure is never lost — just unlabelled).
+ */
+export declare function findAssetMetaByMint(mint: string): {
+    assetId: string | null;
+    symbol: string | null;
+    decimals: number | null;
+};
 /**
  * Membership check. With `cluster` the asset must be listed for THAT
  * cluster; without it, listed for any cluster.

package/dist/index.js

@@ -502,6 +502,16 @@ var DiscoverySorts = {
   RECENT: "recent",
   CREATED: "created"
 };
+var AGENT_BADGES = ["proven", "limited", "new", "flagged"];
+var AgentBadges = {
+  PROVEN: "proven",
+  LIMITED: "limited",
+  NEW: "new",
+  FLAGGED: "flagged"
+};
+function isAgentBadge(v) {
+  return typeof v === "string" && AGENT_BADGES.includes(v);
+}
 
 // src/types/inbox.ts
 var INBOX_BLOCK_SCOPES = ["account", "did"];
@@ -559,6 +569,84 @@ function isReservedName(name) {
 function isValidAgentName(name) {
   return AGENT_NAME_REGEX.test(normalizeName(name));
 }
+var LOCK_ACCOUNT_SIZE = 269;
+var LOCK_ACCOUNT_DISCRIMINATOR = new Uint8Array([8, 255, 36, 202, 210, 22, 57, 137]);
+var LOCK_STATE_NAMES = ["created", "canceled", "in_progress", "submitted", "paid", "revoked", "disputing", "dispute_resolved", "dispute_closed"];
+var LOCK_TERMINAL_STATES = ["canceled", "paid", "revoked", "dispute_resolved", "dispute_closed"];
+var LockTerminalStates = {
+  CANCELED: "canceled",
+  PAID: "paid",
+  REVOKED: "revoked",
+  DISPUTE_RESOLVED: "dispute_resolved",
+  DISPUTE_CLOSED: "dispute_closed"
+};
+var ESCROW_RELEASE_METHODS = ["buyer_approved", "review_timeout"];
+function isEscrowReleaseMethod(v) {
+  return typeof v === "string" && ESCROW_RELEASE_METHODS.includes(v);
+}
+var LockStates = {
+  CREATED: "created",
+  CANCELED: "canceled",
+  IN_PROGRESS: "in_progress",
+  SUBMITTED: "submitted",
+  PAID: "paid",
+  REVOKED: "revoked",
+  DISPUTING: "disputing",
+  DISPUTE_RESOLVED: "dispute_resolved",
+  DISPUTE_CLOSED: "dispute_closed"
+};
+var EscrowReleaseMethods = {
+  BUYER_APPROVED: "buyer_approved",
+  REVIEW_TIMEOUT: "review_timeout"
+};
+var NATIVE_SOL_MINT_BASE58 = "11111111111111111111111111111111";
+function decodeLockAccount(data) {
+  if (data.length !== LOCK_ACCOUNT_SIZE) {
+    throw new Error(`decodeLockAccount: expected ${LOCK_ACCOUNT_SIZE} bytes, got ${data.length}`);
+  }
+  for (let i = 0; i < 8; i++) {
+    if (data[i] !== LOCK_ACCOUNT_DISCRIMINATOR[i]) {
+      throw new Error("decodeLockAccount: account discriminator is not Lock");
+    }
+  }
+  const stateByte = data[185];
+  const state = LOCK_STATE_NAMES[stateByte];
+  if (state === void 0) {
+    throw new Error(`decodeLockAccount: unknown LockState discriminant ${stateByte}`);
+  }
+  const mint = base.base58.encode(data.slice(113, 145));
+  return {
+    lockId: toHex(data.subarray(8, 40)),
+    version: data[40],
+    payer: base.base58.encode(data.slice(41, 73)),
+    payee: base.base58.encode(data.slice(73, 105)),
+    amount: readU64LE(data, 105),
+    mint,
+    isNative: mint === NATIVE_SOL_MINT_BASE58,
+    conditionHash: toHex(data.subarray(145, 177)),
+    expiry: readU64LE(data, 177),
+    state,
+    stateByte,
+    feeBpsAtLock: data[186] | data[187] << 8,
+    feeRecipientAtLock: base.base58.encode(data.slice(188, 220)),
+    workerStakeAtLock: readU64LE(data, 220),
+    operatorDisputeFeeAtLock: readU64LE(data, 228),
+    treasuryAtLock: base.base58.encode(data.slice(236, 268)),
+    bump: data[268]
+  };
+}
+function toHex(bytes) {
+  let hex = "";
+  for (const b of bytes) hex += b.toString(16).padStart(2, "0");
+  return hex;
+}
+function readU64LE(buf, off) {
+  let v = 0n;
+  for (let i = 0; i < 8; i++) {
+    v |= BigInt(buf[off + i]) << BigInt(8 * i);
+  }
+  return v;
+}
 
 // src/assets.ts
 var SOLANA_CLUSTER_IDS = {
@@ -621,6 +709,18 @@ function findAssetByAssetId(assetId) {
   }
   return null;
 }
+function findAssetMetaByMint(mint) {
+  if (mint === NATIVE_SOL_MINT_BASE58) return { assetId: null, symbol: "SOL", decimals: 9 };
+  for (const assets of Object.values(ASSET_WHITELIST)) {
+    for (const asset of assets) {
+      const splIdx = asset.asset_id.indexOf("/spl:");
+      if (splIdx !== -1 && asset.asset_id.slice(splIdx + "/spl:".length) === mint) {
+        return { assetId: asset.asset_id, symbol: asset.symbol ?? null, decimals: asset.decimals };
+      }
+    }
+  }
+  return { assetId: null, symbol: null, decimals: null };
+}
 function isWhitelistedAssetId(assetId, cluster) {
   const hit = findAssetByAssetId(assetId);
   if (!hit) return false;
@@ -801,84 +901,6 @@ function buildResolveDisputeIxData(args, opts = {}) {
   out.set(args.disputeId, 41);
   return out;
 }
-var LOCK_ACCOUNT_SIZE = 269;
-var LOCK_ACCOUNT_DISCRIMINATOR = new Uint8Array([8, 255, 36, 202, 210, 22, 57, 137]);
-var LOCK_STATE_NAMES = ["created", "canceled", "in_progress", "submitted", "paid", "revoked", "disputing", "dispute_resolved", "dispute_closed"];
-var LOCK_TERMINAL_STATES = ["canceled", "paid", "revoked", "dispute_resolved", "dispute_closed"];
-var LockTerminalStates = {
-  CANCELED: "canceled",
-  PAID: "paid",
-  REVOKED: "revoked",
-  DISPUTE_RESOLVED: "dispute_resolved",
-  DISPUTE_CLOSED: "dispute_closed"
-};
-var ESCROW_RELEASE_METHODS = ["buyer_approved", "review_timeout"];
-function isEscrowReleaseMethod(v) {
-  return typeof v === "string" && ESCROW_RELEASE_METHODS.includes(v);
-}
-var LockStates = {
-  CREATED: "created",
-  CANCELED: "canceled",
-  IN_PROGRESS: "in_progress",
-  SUBMITTED: "submitted",
-  PAID: "paid",
-  REVOKED: "revoked",
-  DISPUTING: "disputing",
-  DISPUTE_RESOLVED: "dispute_resolved",
-  DISPUTE_CLOSED: "dispute_closed"
-};
-var EscrowReleaseMethods = {
-  BUYER_APPROVED: "buyer_approved",
-  REVIEW_TIMEOUT: "review_timeout"
-};
-var NATIVE_SOL_MINT_BASE58 = "11111111111111111111111111111111";
-function decodeLockAccount(data) {
-  if (data.length !== LOCK_ACCOUNT_SIZE) {
-    throw new Error(`decodeLockAccount: expected ${LOCK_ACCOUNT_SIZE} bytes, got ${data.length}`);
-  }
-  for (let i = 0; i < 8; i++) {
-    if (data[i] !== LOCK_ACCOUNT_DISCRIMINATOR[i]) {
-      throw new Error("decodeLockAccount: account discriminator is not Lock");
-    }
-  }
-  const stateByte = data[185];
-  const state = LOCK_STATE_NAMES[stateByte];
-  if (state === void 0) {
-    throw new Error(`decodeLockAccount: unknown LockState discriminant ${stateByte}`);
-  }
-  const mint = base.base58.encode(data.slice(113, 145));
-  return {
-    lockId: toHex(data.subarray(8, 40)),
-    version: data[40],
-    payer: base.base58.encode(data.slice(41, 73)),
-    payee: base.base58.encode(data.slice(73, 105)),
-    amount: readU64LE(data, 105),
-    mint,
-    isNative: mint === NATIVE_SOL_MINT_BASE58,
-    conditionHash: toHex(data.subarray(145, 177)),
-    expiry: readU64LE(data, 177),
-    state,
-    stateByte,
-    feeBpsAtLock: data[186] | data[187] << 8,
-    feeRecipientAtLock: base.base58.encode(data.slice(188, 220)),
-    workerStakeAtLock: readU64LE(data, 220),
-    operatorDisputeFeeAtLock: readU64LE(data, 228),
-    treasuryAtLock: base.base58.encode(data.slice(236, 268)),
-    bump: data[268]
-  };
-}
-function toHex(bytes) {
-  let hex = "";
-  for (const b of bytes) hex += b.toString(16).padStart(2, "0");
-  return hex;
-}
-function readU64LE(buf, off) {
-  let v = 0n;
-  for (let i = 0; i < 8; i++) {
-    v |= BigInt(buf[off + i]) << BigInt(8 * i);
-  }
-  return v;
-}
 var SPL_TOKEN_PROGRAM_ID = new web3_js.PublicKey(SPL_TOKEN_PROGRAM_ID_BASE58);
 var ASSOCIATED_TOKEN_PROGRAM_ID = new web3_js.PublicKey(ASSOCIATED_TOKEN_PROGRAM_ID_BASE58);
 var NATIVE_SOL_MINT = new web3_js.PublicKey(NATIVE_SOL_MINT_BASE58);
@@ -1200,6 +1222,7 @@ var CliAuthTokenErrorCodes = {
   REQUIRED: "AUTH_TOKEN_REQUIRED"
 };
 
+exports.AGENT_BADGES = AGENT_BADGES;
 exports.AGENT_NAME_REGEX = AGENT_NAME_REGEX;
 exports.AGENT_TAG_REGEX = AGENT_TAG_REGEX;
 exports.ASSET_DECIMALS_MAX = ASSET_DECIMALS_MAX;
@@ -1209,6 +1232,7 @@ exports.ASSET_SYMBOL_MIN_LEN = ASSET_SYMBOL_MIN_LEN;
 exports.ASSET_WHITELIST = ASSET_WHITELIST;
 exports.ASSOCIATED_TOKEN_PROGRAM_ID = ASSOCIATED_TOKEN_PROGRAM_ID;
 exports.ASSOCIATED_TOKEN_PROGRAM_ID_BASE58 = ASSOCIATED_TOKEN_PROGRAM_ID_BASE58;
+exports.AgentBadges = AgentBadges;
 exports.BODY_TYPES = BODY_TYPES;
 exports.BodyTypes = BodyTypes;
 exports.CAIP19_REGEX = CAIP19_REGEX;
@@ -1314,11 +1338,13 @@ exports.deriveStakeVaultPda = deriveStakeVaultPda;
 exports.expiresAt = expiresAt;
 exports.fetchLockAccount = fetchLockAccount;
 exports.findAssetByAssetId = findAssetByAssetId;
+exports.findAssetMetaByMint = findAssetMetaByMint;
 exports.findFirstChainDivergence = findFirstChainDivergence;
 exports.formatDid = formatDid;
 exports.generateKeyPair = generateKeyPair;
 exports.getPublicKey = getPublicKey2;
 exports.instructionDiscriminator = instructionDiscriminator;
+exports.isAgentBadge = isAgentBadge;
 exports.isAssetIdentifier = isAssetIdentifier;
 exports.isBodyType = isBodyType;
 exports.isCliLoginSessionWireState = isCliLoginSessionWireState;

package/dist/index.mjs

@@ -477,6 +477,16 @@ var DiscoverySorts = {
   RECENT: "recent",
   CREATED: "created"
 };
+var AGENT_BADGES = ["proven", "limited", "new", "flagged"];
+var AgentBadges = {
+  PROVEN: "proven",
+  LIMITED: "limited",
+  NEW: "new",
+  FLAGGED: "flagged"
+};
+function isAgentBadge(v) {
+  return typeof v === "string" && AGENT_BADGES.includes(v);
+}
 
 // src/types/inbox.ts
 var INBOX_BLOCK_SCOPES = ["account", "did"];
@@ -534,6 +544,84 @@ function isReservedName(name) {
 function isValidAgentName(name) {
   return AGENT_NAME_REGEX.test(normalizeName(name));
 }
+var LOCK_ACCOUNT_SIZE = 269;
+var LOCK_ACCOUNT_DISCRIMINATOR = new Uint8Array([8, 255, 36, 202, 210, 22, 57, 137]);
+var LOCK_STATE_NAMES = ["created", "canceled", "in_progress", "submitted", "paid", "revoked", "disputing", "dispute_resolved", "dispute_closed"];
+var LOCK_TERMINAL_STATES = ["canceled", "paid", "revoked", "dispute_resolved", "dispute_closed"];
+var LockTerminalStates = {
+  CANCELED: "canceled",
+  PAID: "paid",
+  REVOKED: "revoked",
+  DISPUTE_RESOLVED: "dispute_resolved",
+  DISPUTE_CLOSED: "dispute_closed"
+};
+var ESCROW_RELEASE_METHODS = ["buyer_approved", "review_timeout"];
+function isEscrowReleaseMethod(v) {
+  return typeof v === "string" && ESCROW_RELEASE_METHODS.includes(v);
+}
+var LockStates = {
+  CREATED: "created",
+  CANCELED: "canceled",
+  IN_PROGRESS: "in_progress",
+  SUBMITTED: "submitted",
+  PAID: "paid",
+  REVOKED: "revoked",
+  DISPUTING: "disputing",
+  DISPUTE_RESOLVED: "dispute_resolved",
+  DISPUTE_CLOSED: "dispute_closed"
+};
+var EscrowReleaseMethods = {
+  BUYER_APPROVED: "buyer_approved",
+  REVIEW_TIMEOUT: "review_timeout"
+};
+var NATIVE_SOL_MINT_BASE58 = "11111111111111111111111111111111";
+function decodeLockAccount(data) {
+  if (data.length !== LOCK_ACCOUNT_SIZE) {
+    throw new Error(`decodeLockAccount: expected ${LOCK_ACCOUNT_SIZE} bytes, got ${data.length}`);
+  }
+  for (let i = 0; i < 8; i++) {
+    if (data[i] !== LOCK_ACCOUNT_DISCRIMINATOR[i]) {
+      throw new Error("decodeLockAccount: account discriminator is not Lock");
+    }
+  }
+  const stateByte = data[185];
+  const state = LOCK_STATE_NAMES[stateByte];
+  if (state === void 0) {
+    throw new Error(`decodeLockAccount: unknown LockState discriminant ${stateByte}`);
+  }
+  const mint = base58.encode(data.slice(113, 145));
+  return {
+    lockId: toHex(data.subarray(8, 40)),
+    version: data[40],
+    payer: base58.encode(data.slice(41, 73)),
+    payee: base58.encode(data.slice(73, 105)),
+    amount: readU64LE(data, 105),
+    mint,
+    isNative: mint === NATIVE_SOL_MINT_BASE58,
+    conditionHash: toHex(data.subarray(145, 177)),
+    expiry: readU64LE(data, 177),
+    state,
+    stateByte,
+    feeBpsAtLock: data[186] | data[187] << 8,
+    feeRecipientAtLock: base58.encode(data.slice(188, 220)),
+    workerStakeAtLock: readU64LE(data, 220),
+    operatorDisputeFeeAtLock: readU64LE(data, 228),
+    treasuryAtLock: base58.encode(data.slice(236, 268)),
+    bump: data[268]
+  };
+}
+function toHex(bytes) {
+  let hex = "";
+  for (const b of bytes) hex += b.toString(16).padStart(2, "0");
+  return hex;
+}
+function readU64LE(buf, off) {
+  let v = 0n;
+  for (let i = 0; i < 8; i++) {
+    v |= BigInt(buf[off + i]) << BigInt(8 * i);
+  }
+  return v;
+}
 
 // src/assets.ts
 var SOLANA_CLUSTER_IDS = {
@@ -596,6 +684,18 @@ function findAssetByAssetId(assetId) {
   }
   return null;
 }
+function findAssetMetaByMint(mint) {
+  if (mint === NATIVE_SOL_MINT_BASE58) return { assetId: null, symbol: "SOL", decimals: 9 };
+  for (const assets of Object.values(ASSET_WHITELIST)) {
+    for (const asset of assets) {
+      const splIdx = asset.asset_id.indexOf("/spl:");
+      if (splIdx !== -1 && asset.asset_id.slice(splIdx + "/spl:".length) === mint) {
+        return { assetId: asset.asset_id, symbol: asset.symbol ?? null, decimals: asset.decimals };
+      }
+    }
+  }
+  return { assetId: null, symbol: null, decimals: null };
+}
 function isWhitelistedAssetId(assetId, cluster) {
   const hit = findAssetByAssetId(assetId);
   if (!hit) return false;
@@ -776,84 +876,6 @@ function buildResolveDisputeIxData(args, opts = {}) {
   out.set(args.disputeId, 41);
   return out;
 }
-var LOCK_ACCOUNT_SIZE = 269;
-var LOCK_ACCOUNT_DISCRIMINATOR = new Uint8Array([8, 255, 36, 202, 210, 22, 57, 137]);
-var LOCK_STATE_NAMES = ["created", "canceled", "in_progress", "submitted", "paid", "revoked", "disputing", "dispute_resolved", "dispute_closed"];
-var LOCK_TERMINAL_STATES = ["canceled", "paid", "revoked", "dispute_resolved", "dispute_closed"];
-var LockTerminalStates = {
-  CANCELED: "canceled",
-  PAID: "paid",
-  REVOKED: "revoked",
-  DISPUTE_RESOLVED: "dispute_resolved",
-  DISPUTE_CLOSED: "dispute_closed"
-};
-var ESCROW_RELEASE_METHODS = ["buyer_approved", "review_timeout"];
-function isEscrowReleaseMethod(v) {
-  return typeof v === "string" && ESCROW_RELEASE_METHODS.includes(v);
-}
-var LockStates = {
-  CREATED: "created",
-  CANCELED: "canceled",
-  IN_PROGRESS: "in_progress",
-  SUBMITTED: "submitted",
-  PAID: "paid",
-  REVOKED: "revoked",
-  DISPUTING: "disputing",
-  DISPUTE_RESOLVED: "dispute_resolved",
-  DISPUTE_CLOSED: "dispute_closed"
-};
-var EscrowReleaseMethods = {
-  BUYER_APPROVED: "buyer_approved",
-  REVIEW_TIMEOUT: "review_timeout"
-};
-var NATIVE_SOL_MINT_BASE58 = "11111111111111111111111111111111";
-function decodeLockAccount(data) {
-  if (data.length !== LOCK_ACCOUNT_SIZE) {
-    throw new Error(`decodeLockAccount: expected ${LOCK_ACCOUNT_SIZE} bytes, got ${data.length}`);
-  }
-  for (let i = 0; i < 8; i++) {
-    if (data[i] !== LOCK_ACCOUNT_DISCRIMINATOR[i]) {
-      throw new Error("decodeLockAccount: account discriminator is not Lock");
-    }
-  }
-  const stateByte = data[185];
-  const state = LOCK_STATE_NAMES[stateByte];
-  if (state === void 0) {
-    throw new Error(`decodeLockAccount: unknown LockState discriminant ${stateByte}`);
-  }
-  const mint = base58.encode(data.slice(113, 145));
-  return {
-    lockId: toHex(data.subarray(8, 40)),
-    version: data[40],
-    payer: base58.encode(data.slice(41, 73)),
-    payee: base58.encode(data.slice(73, 105)),
-    amount: readU64LE(data, 105),
-    mint,
-    isNative: mint === NATIVE_SOL_MINT_BASE58,
-    conditionHash: toHex(data.subarray(145, 177)),
-    expiry: readU64LE(data, 177),
-    state,
-    stateByte,
-    feeBpsAtLock: data[186] | data[187] << 8,
-    feeRecipientAtLock: base58.encode(data.slice(188, 220)),
-    workerStakeAtLock: readU64LE(data, 220),
-    operatorDisputeFeeAtLock: readU64LE(data, 228),
-    treasuryAtLock: base58.encode(data.slice(236, 268)),
-    bump: data[268]
-  };
-}
-function toHex(bytes) {
-  let hex = "";
-  for (const b of bytes) hex += b.toString(16).padStart(2, "0");
-  return hex;
-}
-function readU64LE(buf, off) {
-  let v = 0n;
-  for (let i = 0; i < 8; i++) {
-    v |= BigInt(buf[off + i]) << BigInt(8 * i);
-  }
-  return v;
-}
 var SPL_TOKEN_PROGRAM_ID = new PublicKey(SPL_TOKEN_PROGRAM_ID_BASE58);
 var ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey(ASSOCIATED_TOKEN_PROGRAM_ID_BASE58);
 var NATIVE_SOL_MINT = new PublicKey(NATIVE_SOL_MINT_BASE58);
@@ -1175,4 +1197,4 @@ var CliAuthTokenErrorCodes = {
   REQUIRED: "AUTH_TOKEN_REQUIRED"
 };
 
-export { AGENT_NAME_REGEX, AGENT_TAG_REGEX, ASSET_DECIMALS_MAX, ASSET_DECIMALS_MIN, ASSET_SYMBOL_MAX_LEN, ASSET_SYMBOL_MIN_LEN, ASSET_WHITELIST, ASSOCIATED_TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID_BASE58, BODY_TYPES, BodyTypes, CAIP19_REGEX, CLI_AUTH_TOKEN_ERROR_CODES, CLI_LOGIN_SESSION_STATES, CLI_LOGIN_SESSION_STORED_STATES, CREATE_LOCK_DISCRIMINATOR, CREATE_LOCK_NATIVE_DISCRIMINATOR, CURRENT_PROTOCOL_VERSION, CliAuthTokenErrorCodes, CliLoginSessionStates, DECIMAL_AMOUNT_REGEX, DECLINE_REASONS, DELEGATION_ACTIONS, DELEGATION_ACTIVE_STATES, DELEGATION_OFFER_REJECTION_CODES, DELEGATION_STATES, DEVNET_MINTS, DID_ARP_REGEX, DISCOVERY_SORTS, DelegationActions, DelegationOfferRejectionCodes, DelegationStates, DiscoverySorts, ED25519_SIG_PREFIX, ESCROW_PDA_SEEDS, ESCROW_PROGRAM_ID_BASE58, ESCROW_RELEASE_METHODS, EscrowReleaseMethods, HANDSHAKE_DECISIONS, HandshakeDecisions, INBOX_BLOCK_SCOPES, InboxBlockScopes, LIVE_RELATIONSHIP_STATE_NAMES, LOCK_ACCOUNT_DISCRIMINATOR, LOCK_ACCOUNT_SIZE, LOCK_STATE_NAMES, LOCK_TERMINAL_STATES, LockStates, LockTerminalStates, MAINNET_MINTS, MAX_CLOCK_SKEW_SECONDS, MAX_ENVELOPE_TTL_SECONDS, NATIVE_SOL_MINT, NATIVE_SOL_MINT_BASE58, NO_ARG_LIFECYCLE_INSTRUCTIONS, OWNER_SIGNING_METHODS, POST_COMMIT_ERROR_CODES, POST_COMMIT_ERROR_CODE_PREFIXES, PROTOCOL_VERSIONS, Purpose, READ_MODEL_STATUSES, RECEIPT_VERDICTS, RELATIONSHIP_STATE_NAMES, RESERVED_NAMES, ReadModelStatuses, ReceiptVerdicts, RelationshipStates, SCRYPT_PARAMS, SHA256_HEX_RE, SLIP44_SOLANA, SOLANA_CLUSTER_IDS, SPL_TOKEN_PROGRAM_ID, SPL_TOKEN_PROGRAM_ID_BASE58, SYSTEM_PROGRAM_ID_BASE58, TOKEN_2022_PROGRAM_ID_BASE58, WELL_KNOWN_ASSETS, WELL_KNOWN_ASSET_KEYS, WORK_LOG_STATES, WorkLogStates, base58btcDecode, base58btcEncode, buildAcceptLockIx, buildCancelLockIx, buildClaimExpiredWorkIx, buildClaimWorkPaymentIx, buildCloseDisputeIx, buildCreateLockIx, buildCreateLockIxData, buildLifecycleIxData, buildOpenDisputeIx, buildResolveDisputeIx, buildResolveDisputeIxData, buildSubmitWorkIx, bytes16ToDelegationId, canonicalBytes, canonicalJson, canonicalSha256Hex, decodeLockAccount, delegationIdToBytes16, deriveAta, deriveCollateralConfigPda, deriveConfigPda, deriveDelegationConditionHash, deriveDisputeResolutionPda, deriveEscrowPda, deriveEventAuthorityPda, deriveLockId, deriveLockPda, deriveOperatorAuthPda, deriveScryptKey, deriveStakeVaultPda, expiresAt, fetchLockAccount, findAssetByAssetId, findFirstChainDivergence, formatDid, generateKeyPair, getPublicKey2 as getPublicKey, instructionDiscriminator, isAssetIdentifier, isBodyType, isCliLoginSessionWireState, isDecimalAmountString, isDeclineReason, isDelegationAction, isDelegationState, isEscrowReleaseMethod, isHandshakeDecision, isPostCommitErrorCode, isReadModelStatus, isReceiptVerdict, isRelationshipState, isReservedName, isSha256Hex, isValidAgentName, isValidDid, isWhitelistedAssetId, isWorkLogState, normalizeName, parseCaip19SolanaAssetId, parseDid, pollUntil, resolveAsset, rfc3339, scryptPasswordProofSign, scryptPasswordProofVerify, senderNonce, serverEventHash, sign2 as sign, signChallenge, signEnvelope, signKeyLinkAttestation, signedMessageHash, uuidV4, verify2 as verify, verifyChallenge, verifyEnvelope, verifyKeyLinkAttestation };
+export { AGENT_BADGES, AGENT_NAME_REGEX, AGENT_TAG_REGEX, ASSET_DECIMALS_MAX, ASSET_DECIMALS_MIN, ASSET_SYMBOL_MAX_LEN, ASSET_SYMBOL_MIN_LEN, ASSET_WHITELIST, ASSOCIATED_TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID_BASE58, AgentBadges, BODY_TYPES, BodyTypes, CAIP19_REGEX, CLI_AUTH_TOKEN_ERROR_CODES, CLI_LOGIN_SESSION_STATES, CLI_LOGIN_SESSION_STORED_STATES, CREATE_LOCK_DISCRIMINATOR, CREATE_LOCK_NATIVE_DISCRIMINATOR, CURRENT_PROTOCOL_VERSION, CliAuthTokenErrorCodes, CliLoginSessionStates, DECIMAL_AMOUNT_REGEX, DECLINE_REASONS, DELEGATION_ACTIONS, DELEGATION_ACTIVE_STATES, DELEGATION_OFFER_REJECTION_CODES, DELEGATION_STATES, DEVNET_MINTS, DID_ARP_REGEX, DISCOVERY_SORTS, DelegationActions, DelegationOfferRejectionCodes, DelegationStates, DiscoverySorts, ED25519_SIG_PREFIX, ESCROW_PDA_SEEDS, ESCROW_PROGRAM_ID_BASE58, ESCROW_RELEASE_METHODS, EscrowReleaseMethods, HANDSHAKE_DECISIONS, HandshakeDecisions, INBOX_BLOCK_SCOPES, InboxBlockScopes, LIVE_RELATIONSHIP_STATE_NAMES, LOCK_ACCOUNT_DISCRIMINATOR, LOCK_ACCOUNT_SIZE, LOCK_STATE_NAMES, LOCK_TERMINAL_STATES, LockStates, LockTerminalStates, MAINNET_MINTS, MAX_CLOCK_SKEW_SECONDS, MAX_ENVELOPE_TTL_SECONDS, NATIVE_SOL_MINT, NATIVE_SOL_MINT_BASE58, NO_ARG_LIFECYCLE_INSTRUCTIONS, OWNER_SIGNING_METHODS, POST_COMMIT_ERROR_CODES, POST_COMMIT_ERROR_CODE_PREFIXES, PROTOCOL_VERSIONS, Purpose, READ_MODEL_STATUSES, RECEIPT_VERDICTS, RELATIONSHIP_STATE_NAMES, RESERVED_NAMES, ReadModelStatuses, ReceiptVerdicts, RelationshipStates, SCRYPT_PARAMS, SHA256_HEX_RE, SLIP44_SOLANA, SOLANA_CLUSTER_IDS, SPL_TOKEN_PROGRAM_ID, SPL_TOKEN_PROGRAM_ID_BASE58, SYSTEM_PROGRAM_ID_BASE58, TOKEN_2022_PROGRAM_ID_BASE58, WELL_KNOWN_ASSETS, WELL_KNOWN_ASSET_KEYS, WORK_LOG_STATES, WorkLogStates, base58btcDecode, base58btcEncode, buildAcceptLockIx, buildCancelLockIx, buildClaimExpiredWorkIx, buildClaimWorkPaymentIx, buildCloseDisputeIx, buildCreateLockIx, buildCreateLockIxData, buildLifecycleIxData, buildOpenDisputeIx, buildResolveDisputeIx, buildResolveDisputeIxData, buildSubmitWorkIx, bytes16ToDelegationId, canonicalBytes, canonicalJson, canonicalSha256Hex, decodeLockAccount, delegationIdToBytes16, deriveAta, deriveCollateralConfigPda, deriveConfigPda, deriveDelegationConditionHash, deriveDisputeResolutionPda, deriveEscrowPda, deriveEventAuthorityPda, deriveLockId, deriveLockPda, deriveOperatorAuthPda, deriveScryptKey, deriveStakeVaultPda, expiresAt, fetchLockAccount, findAssetByAssetId, findAssetMetaByMint, findFirstChainDivergence, formatDid, generateKeyPair, getPublicKey2 as getPublicKey, instructionDiscriminator, isAgentBadge, isAssetIdentifier, isBodyType, isCliLoginSessionWireState, isDecimalAmountString, isDeclineReason, isDelegationAction, isDelegationState, isEscrowReleaseMethod, isHandshakeDecision, isPostCommitErrorCode, isReadModelStatus, isReceiptVerdict, isRelationshipState, isReservedName, isSha256Hex, isValidAgentName, isValidDid, isWhitelistedAssetId, isWorkLogState, normalizeName, parseCaip19SolanaAssetId, parseDid, pollUntil, resolveAsset, rfc3339, scryptPasswordProofSign, scryptPasswordProofVerify, senderNonce, serverEventHash, sign2 as sign, signChallenge, signEnvelope, signKeyLinkAttestation, signedMessageHash, uuidV4, verify2 as verify, verifyChallenge, verifyEnvelope, verifyKeyLinkAttestation };

package/dist/types/agent.d.ts

@@ -144,6 +144,66 @@ export interface AgentReputation {
     computed: boolean;
     lastComputedAt?: string | null;
 }
+/**
+ * Settled on-chain volume for ONE asset, from one role (earned as payee /
+ * paid as payer). Amounts are exact integer base-units (string, never a
+ * float); `amountDecimal` is the human form, present only when the asset's
+ * decimals are known. `mint` is always the unambiguous identifier — `assetId`
+ * /`symbol`/`decimals` are best-effort labels (null for an unrecognised mint).
+ */
+export interface AssetVolume {
+    mint: string;
+    assetId: string | null;
+    symbol: string | null;
+    decimals: number | null;
+    amountBaseUnits: string;
+    amountDecimal: string | null;
+    lockCount: number;
+}
+/**
+ * Per-agent settled-escrow volume, split by role and bucketed by asset.
+ *
+ * SCOPE (v1): covers the happy-path `paid` settlement only. Payouts that came
+ * through ARBITRATION (a `dispute_resolved` lock won by the payee) are NOT yet
+ * in these figures — they ARE reflected in the reputation counters
+ * (`settledEscrows`/`disputedEscrows`), so for a heavily-disputed agent the
+ * volume can under-report relative to the settled-escrow count.
+ */
+export interface AgentSettlementVolume {
+    /** Received as payee (the worker side) — the headline trust signal. */
+    earnedByAsset: AssetVolume[];
+    /** Spent as payer (the buyer side). */
+    paidByAsset: AssetVolume[];
+    /** Span of settled activity (a Paid lock's last on-chain transition). */
+    firstSettledAt: string | null;
+    lastSettledAt: string | null;
+}
+/**
+ * Derived ratios from the reputation counters. Each is `null` when its
+ * denominator is 0 (no basis to compute), never a misleading 0.
+ */
+export interface AgentStatsRates {
+    /** completed / (completed + failed) delegations. */
+    completionRate: number | null;
+    /** disputed / onchainCycles — share of terminal cycles that hit a dispute. */
+    disputeRate: number | null;
+    /** disputesAdverse / disputed — share of disputes ruled against. */
+    adverseDisputeRate: number | null;
+}
+/**
+ * Quantitative per-agent stats — `GET /v1/agents/:did/stats`. PUBLIC, no-auth.
+ * Counters/scores reuse the materialised reputation row (single source of truth
+ * with `/reputation`); rates are derived; volume is aggregated live from the
+ * on-chain escrow-lock mirror (cached). `computed: false` ⇒ no settled cycle yet.
+ */
+export interface AgentStats {
+    did: string;
+    computed: boolean;
+    counters: ReputationCounters;
+    scores: ReputationScores;
+    rates: AgentStatsRates;
+    volume: AgentSettlementVolume;
+}
 /**
  * Agent capability-tag charset — lowercase alphanumeric + dash +
  * underscore, 1-40 chars. Single source of truth for the server's

package/dist/types/discovery.d.ts

@@ -16,6 +16,29 @@ export declare const DiscoverySorts: {
     readonly RECENT: "recent";
     readonly CREATED: "created";
 };
+/**
+ * Earned-evidence discovery badge — a coarse "how much real on-chain
+ * history" signal carried on every search row + profile, DISTINCT from
+ * the manual platform `trusted` flag. Same vocab shape as the protocol
+ * sets (as-const array + union + guard + named-member const-object).
+ *
+ * `proven` = enough completed payee cycles across distinct owners;
+ * `limited` = some real on-chain cycles, below the proven bar;
+ * `new` = zero settled cycles (escrow/stake-backed but unproven);
+ * `flagged` = adverse evidence (a lost dispute or a no-show/revoke) —
+ * dominates the positive ladder, never masked by a high score or `trusted`.
+ */
+export declare const AGENT_BADGES: readonly ["proven", "limited", "new", "flagged"];
+export type AgentBadge = (typeof AGENT_BADGES)[number];
+/** Named-member accessor for {@link AgentBadge} (vocab-tested). */
+export declare const AgentBadges: {
+    readonly PROVEN: "proven";
+    readonly LIMITED: "limited";
+    readonly NEW: "new";
+    readonly FLAGGED: "flagged";
+};
+/** Type guard for {@link AgentBadge} (rejects non-members + non-strings). */
+export declare function isAgentBadge(v: unknown): v is AgentBadge;
 /**
  * Query for `GET /v1/discovery/search` (server DTO
  * `DiscoverySearchQueryDto`). Every field optional; filters AND-compose.
@@ -32,6 +55,16 @@ export interface DiscoverySearchQuery {
     accepts?: string;
     /** Only agents seen within the liveness window. */
     online?: boolean;
+    /** Return ONLY platform-trusted agents (the manual `trusted` allow-list flag). */
+    trustedOnly?: boolean;
+    /** Include unproven (zero settled cycle) agents — default true; `false` hard-excludes cold-start. */
+    includeUnproven?: boolean;
+    /** Hard filter: minimum settled on-chain cycles. */
+    minOnchainCycles?: number;
+    /** Hard filter: minimum completed delegations AS THE PAYEE (paid work delivered). */
+    minCompletedAsPayee?: number;
+    /** Hard filter: minimum distinct (owner-resolved) counterparts. */
+    minDistinctCounterparts?: number;
     /** `reputation` (composite desc, default) | `recent` | `created` (cursor). */
     sort?: DiscoverySort;
     /** Zero-based page index (offset = page × limit) — reputation/recent sorts. */
@@ -73,6 +106,10 @@ export interface DiscoveryResult {
     reputation: DiscoveryReputation;
     liveness: DiscoveryLiveness;
     registeredAt: string;
+    /** Platform-curated trust flag (manual DB allow-list) — NOT earned reputation. */
+    trusted: boolean;
+    /** Earned-evidence badge derived from on-chain history (see {@link AgentBadge}). */
+    badge: AgentBadge;
 }
 /** Pagination envelope metadata on a discovery search page. */
 export interface DiscoveryPagination {
@@ -104,6 +141,10 @@ export interface DiscoveryProfile {
     tags: string[];
     acceptPrefs?: AcceptPrefs;
     registeredAt: string;
+    /** Platform-curated trust flag (manual DB allow-list) — NOT earned reputation. */
+    trusted: boolean;
+    /** Earned-evidence badge derived from on-chain history (see {@link AgentBadge}). */
+    badge: AgentBadge;
     reputation: AgentReputation;
     /** Liveness, plus `lastEventAt` (last protocol event either side). */
     liveness: DiscoveryLiveness & {

package/dist/types/index.d.ts

@@ -10,14 +10,14 @@ export type { WorkLogState } from './work-log';
 export { WORK_LOG_STATES, WorkLogStates, isWorkLogState } from './work-log';
 export type { ReadModelStatus } from './event';
 export { READ_MODEL_STATUSES, ReadModelStatuses, isReadModelStatus } from './event';
-export type { DiscoverySort, DiscoverySearchQuery, DiscoveryReputation, DiscoveryLiveness, DiscoveryResult, DiscoveryPagination, DiscoverySearchResponse, DiscoveryProfile, } from './discovery';
-export { DISCOVERY_SORTS, DiscoverySorts } from './discovery';
+export type { DiscoverySort, AgentBadge, DiscoverySearchQuery, DiscoveryReputation, DiscoveryLiveness, DiscoveryResult, DiscoveryPagination, DiscoverySearchResponse, DiscoveryProfile, } from './discovery';
+export { DISCOVERY_SORTS, DiscoverySorts, AGENT_BADGES, AgentBadges, isAgentBadge } from './discovery';
 export type { InboxBlockScope, InboxBlock, BlockInboxBody } from './inbox';
 export { INBOX_BLOCK_SCOPES, InboxBlockScopes } from './inbox';
 export type { CliSessionCreated, CliTokenIssued, CliWhoami, MyAgentSummary, CliLoginSessionStoredState, CliLoginSessionWireState, } from './cli-auth';
 export { CLI_LOGIN_SESSION_STORED_STATES, CLI_LOGIN_SESSION_STATES, CliLoginSessionStates, isCliLoginSessionWireState } from './cli-auth';
 export type { AssetIdentifierWire, DelegationPublic, DisputeResolutionPublic, ReceiptPublic, RelationshipPublic, WorkLogPublic, EventPublic, IngestResult, SenderSequenceResponse, InboxUnblockResult, ListRelationshipsQuery, ListInboxQuery, ListEventsQuery, ListDelegationsQuery, ListWorkLogsQuery, ListReceiptsQuery, } from './read-model';
-export type { AcceptPrefs, AcceptCurrency, AgentRegisteredResponse, AgentPublic, UpdateAgentBody, RegisterAgentRequest, ChallengeResponse, ReputationScores, ReputationCounters, AgentReputation, } from './agent';
+export type { AcceptPrefs, AcceptCurrency, AgentRegisteredResponse, AgentPublic, UpdateAgentBody, RegisterAgentRequest, ChallengeResponse, ReputationScores, ReputationCounters, AgentReputation, AssetVolume, AgentSettlementVolume, AgentStatsRates, AgentStats, } from './agent';
 export { AGENT_TAG_REGEX, AGENT_NAME_REGEX, RESERVED_NAMES, isReservedName, isValidAgentName, normalizeName } from './agent';
 export type { OwnerSigningMethod, KeyLinkPayload, ScryptPasswordAttestation } from './identity';
 export { SCRYPT_PARAMS, OWNER_SIGNING_METHODS } from './identity';

package/package.json

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