@bondedhq/shared 0.0.0-stage → 0.1.0

package/dist/schemas/attestation.d.ts

@@ -0,0 +1,284 @@
+import { type TypedDataDomain } from "viem";
+import { z } from "zod";
+/**
+ * Signed messages from the Arena's attester. See docs/SPECIFICATION.md Section 6.4.
+ * Attestations are posted to every chain's BondedRegistry; quotes are accepted by CoverManager.
+ * The EIP-712 type strings below must match the Solidity typehashes in `BondedTypes.sol`.
+ */
+/** Model family of the agent's brain, used for correlation caps. Codes are uint8 on-chain. */
+export declare const ModelFamily: z.ZodEnum<{
+    unknown: "unknown";
+    "anthropic-claude": "anthropic-claude";
+    "openai-gpt": "openai-gpt";
+    "google-gemini": "google-gemini";
+    "meta-llama": "meta-llama";
+    mistral: "mistral";
+    deepseek: "deepseek";
+    qwen: "qwen";
+    "xai-grok": "xai-grok";
+    "decision-model": "decision-model";
+    other: "other";
+}>;
+export type ModelFamily = z.infer<typeof ModelFamily>;
+export declare const MODEL_FAMILY_CODE: Record<ModelFamily, number>;
+export declare const ZERO_BYTES32: `0x${string}`;
+export declare const Attestation: z.ZodObject<{
+    agentId: z.ZodString;
+    score: z.ZodNumber;
+    expectedLossBps: z.ZodNumber;
+    reportHash: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    mandateHash: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    codeHash: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    teeMeasurement: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>>;
+    modelFamily: z.ZodEnum<{
+        unknown: "unknown";
+        "anthropic-claude": "anthropic-claude";
+        "openai-gpt": "openai-gpt";
+        "google-gemini": "google-gemini";
+        "meta-llama": "meta-llama";
+        mistral: "mistral";
+        deepseek: "deepseek";
+        qwen: "qwen";
+        "xai-grok": "xai-grok";
+        "decision-model": "decision-model";
+        other: "other";
+    }>;
+    issuedAt: z.ZodNumber;
+    expiresAt: z.ZodNumber;
+}, z.core.$strip>;
+export type Attestation = z.infer<typeof Attestation>;
+export declare const Quote: z.ZodObject<{
+    agentId: z.ZodString;
+    vault: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    coverAmount: z.ZodString;
+    premiumRateBps: z.ZodNumber;
+    score: z.ZodNumber;
+    modelFamily: z.ZodEnum<{
+        unknown: "unknown";
+        "anthropic-claude": "anthropic-claude";
+        "openai-gpt": "openai-gpt";
+        "google-gemini": "google-gemini";
+        "meta-llama": "meta-llama";
+        mistral: "mistral";
+        deepseek: "deepseek";
+        qwen: "qwen";
+        "xai-grok": "xai-grok";
+        "decision-model": "decision-model";
+        other: "other";
+    }>;
+    mandateHash: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    reportHash: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    minBond: z.ZodString;
+    expiresAt: z.ZodNumber;
+    nonce: z.ZodString;
+}, z.core.$strip>;
+export type Quote = z.infer<typeof Quote>;
+export declare const EIP712_DOMAIN_NAME = "Bonded";
+export declare const EIP712_DOMAIN_VERSION = "1";
+export declare function bondedDomain(chainId: number, verifyingContract: `0x${string}`): TypedDataDomain;
+export declare const ATTESTATION_TYPES: {
+    readonly Attestation: readonly [{
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "score";
+        readonly type: "uint16";
+    }, {
+        readonly name: "expectedLossBps";
+        readonly type: "uint32";
+    }, {
+        readonly name: "reportHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "mandateHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "codeHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "teeMeasurement";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "modelFamily";
+        readonly type: "uint8";
+    }, {
+        readonly name: "issuedAt";
+        readonly type: "uint64";
+    }, {
+        readonly name: "expiresAt";
+        readonly type: "uint64";
+    }];
+};
+export declare const QUOTE_TYPES: {
+    readonly Quote: readonly [{
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "vault";
+        readonly type: "address";
+    }, {
+        readonly name: "coverAmount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "premiumRateBps";
+        readonly type: "uint32";
+    }, {
+        readonly name: "score";
+        readonly type: "uint16";
+    }, {
+        readonly name: "modelFamily";
+        readonly type: "uint8";
+    }, {
+        readonly name: "mandateHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "reportHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "minBond";
+        readonly type: "uint256";
+    }, {
+        readonly name: "expiresAt";
+        readonly type: "uint64";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }];
+};
+/** The EIP-712 type strings. Solidity typehashes are keccak256 of these exact strings. */
+export declare const ATTESTATION_TYPE_STRING: string;
+export declare const QUOTE_TYPE_STRING: string;
+export declare const ATTESTATION_TYPEHASH: `0x${string}`;
+export declare const QUOTE_TYPEHASH: `0x${string}`;
+/** Converts a validated attestation into the message shape viem signs. */
+export declare function attestationMessage(input: Attestation): {
+    agentId: bigint;
+    score: number;
+    expectedLossBps: number;
+    reportHash: `0x${string}`;
+    mandateHash: `0x${string}`;
+    codeHash: `0x${string}`;
+    teeMeasurement: `0x${string}`;
+    modelFamily: number;
+    issuedAt: bigint;
+    expiresAt: bigint;
+};
+/** Converts a validated quote into the message shape viem signs. */
+export declare function quoteMessage(input: Quote): {
+    agentId: bigint;
+    vault: `0x${string}`;
+    coverAmount: bigint;
+    premiumRateBps: number;
+    score: number;
+    modelFamily: number;
+    mandateHash: `0x${string}`;
+    reportHash: `0x${string}`;
+    minBond: bigint;
+    expiresAt: bigint;
+    nonce: bigint;
+};
+/** Full typed-data payload for signing or verifying an attestation with viem. */
+export declare function attestationTypedData(domain: TypedDataDomain, attestation: Attestation): {
+    domain: TypedDataDomain;
+    types: {
+        readonly Attestation: readonly [{
+            readonly name: "agentId";
+            readonly type: "uint256";
+        }, {
+            readonly name: "score";
+            readonly type: "uint16";
+        }, {
+            readonly name: "expectedLossBps";
+            readonly type: "uint32";
+        }, {
+            readonly name: "reportHash";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "mandateHash";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "codeHash";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "teeMeasurement";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "modelFamily";
+            readonly type: "uint8";
+        }, {
+            readonly name: "issuedAt";
+            readonly type: "uint64";
+        }, {
+            readonly name: "expiresAt";
+            readonly type: "uint64";
+        }];
+    };
+    primaryType: "Attestation";
+    message: {
+        agentId: bigint;
+        score: number;
+        expectedLossBps: number;
+        reportHash: `0x${string}`;
+        mandateHash: `0x${string}`;
+        codeHash: `0x${string}`;
+        teeMeasurement: `0x${string}`;
+        modelFamily: number;
+        issuedAt: bigint;
+        expiresAt: bigint;
+    };
+};
+/** Full typed-data payload for signing or verifying a quote with viem. */
+export declare function quoteTypedData(domain: TypedDataDomain, quote: Quote): {
+    domain: TypedDataDomain;
+    types: {
+        readonly Quote: readonly [{
+            readonly name: "agentId";
+            readonly type: "uint256";
+        }, {
+            readonly name: "vault";
+            readonly type: "address";
+        }, {
+            readonly name: "coverAmount";
+            readonly type: "uint256";
+        }, {
+            readonly name: "premiumRateBps";
+            readonly type: "uint32";
+        }, {
+            readonly name: "score";
+            readonly type: "uint16";
+        }, {
+            readonly name: "modelFamily";
+            readonly type: "uint8";
+        }, {
+            readonly name: "mandateHash";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "reportHash";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "minBond";
+            readonly type: "uint256";
+        }, {
+            readonly name: "expiresAt";
+            readonly type: "uint64";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }];
+    };
+    primaryType: "Quote";
+    message: {
+        agentId: bigint;
+        vault: `0x${string}`;
+        coverAmount: bigint;
+        premiumRateBps: number;
+        score: number;
+        modelFamily: number;
+        mandateHash: `0x${string}`;
+        reportHash: `0x${string}`;
+        minBond: bigint;
+        expiresAt: bigint;
+        nonce: bigint;
+    };
+};
+//# sourceMappingURL=attestation.d.ts.map

package/dist/schemas/attestation.js

@@ -0,0 +1,175 @@
+import { keccak256, stringToBytes } from "viem";
+import { z } from "zod";
+import { bytes32, evmAddress, uintString, unixSeconds } from "./common.js";
+/**
+ * Signed messages from the Arena's attester. See docs/SPECIFICATION.md Section 6.4.
+ * Attestations are posted to every chain's BondedRegistry; quotes are accepted by CoverManager.
+ * The EIP-712 type strings below must match the Solidity typehashes in `BondedTypes.sol`.
+ */
+/** Model family of the agent's brain, used for correlation caps. Codes are uint8 on-chain. */
+export const ModelFamily = z.enum([
+    "unknown",
+    "anthropic-claude",
+    "openai-gpt",
+    "google-gemini",
+    "meta-llama",
+    "mistral",
+    "deepseek",
+    "qwen",
+    "xai-grok",
+    "decision-model",
+    "other",
+]);
+export const MODEL_FAMILY_CODE = {
+    unknown: 0,
+    "anthropic-claude": 1,
+    "openai-gpt": 2,
+    "google-gemini": 3,
+    "meta-llama": 4,
+    mistral: 5,
+    deepseek: 6,
+    qwen: 7,
+    "xai-grok": 8,
+    /** Typed decision models such as Laya or Jev. */
+    "decision-model": 9,
+    other: 255,
+};
+export const ZERO_BYTES32 = `0x${"0".repeat(64)}`;
+export const Attestation = z
+    .object({
+    agentId: uintString,
+    /** Bonded Score, 0–100. */
+    score: z.number().int().min(0).max(100),
+    /** Expected annual loss as a fraction of cover, in basis points. */
+    expectedLossBps: z.number().int().min(0).max(10_000),
+    /** Hash of the full Arena report. */
+    reportHash: bytes32,
+    /** Hash of the mandate the agent was rated under. */
+    mandateHash: bytes32,
+    /** Hash of the agent's code/config version that was rated. */
+    codeHash: bytes32,
+    /** TEE measurement of the running agent, or zero when not in a TEE. */
+    teeMeasurement: bytes32.default(ZERO_BYTES32),
+    modelFamily: ModelFamily,
+    issuedAt: unixSeconds,
+    expiresAt: unixSeconds,
+})
+    .refine((a) => a.expiresAt > a.issuedAt, {
+    message: "expiresAt must be after issuedAt",
+    path: ["expiresAt"],
+});
+export const Quote = z.object({
+    agentId: uintString,
+    vault: evmAddress,
+    /** Cover amount in base-asset units (USDC has 6 decimals). */
+    coverAmount: uintString,
+    /** Annual premium rate in basis points of cover. */
+    premiumRateBps: z.number().int().min(0).max(10_000),
+    score: z.number().int().min(0).max(100),
+    modelFamily: ModelFamily,
+    mandateHash: bytes32,
+    reportHash: bytes32,
+    /** Minimum operator bond in base-asset units. */
+    minBond: uintString,
+    expiresAt: unixSeconds,
+    nonce: uintString,
+});
+export const EIP712_DOMAIN_NAME = "Bonded";
+export const EIP712_DOMAIN_VERSION = "1";
+export function bondedDomain(chainId, verifyingContract) {
+    return {
+        name: EIP712_DOMAIN_NAME,
+        version: EIP712_DOMAIN_VERSION,
+        chainId,
+        verifyingContract,
+    };
+}
+export const ATTESTATION_TYPES = {
+    Attestation: [
+        { name: "agentId", type: "uint256" },
+        { name: "score", type: "uint16" },
+        { name: "expectedLossBps", type: "uint32" },
+        { name: "reportHash", type: "bytes32" },
+        { name: "mandateHash", type: "bytes32" },
+        { name: "codeHash", type: "bytes32" },
+        { name: "teeMeasurement", type: "bytes32" },
+        { name: "modelFamily", type: "uint8" },
+        { name: "issuedAt", type: "uint64" },
+        { name: "expiresAt", type: "uint64" },
+    ],
+};
+export const QUOTE_TYPES = {
+    Quote: [
+        { name: "agentId", type: "uint256" },
+        { name: "vault", type: "address" },
+        { name: "coverAmount", type: "uint256" },
+        { name: "premiumRateBps", type: "uint32" },
+        { name: "score", type: "uint16" },
+        { name: "modelFamily", type: "uint8" },
+        { name: "mandateHash", type: "bytes32" },
+        { name: "reportHash", type: "bytes32" },
+        { name: "minBond", type: "uint256" },
+        { name: "expiresAt", type: "uint64" },
+        { name: "nonce", type: "uint256" },
+    ],
+};
+/** The EIP-712 type strings. Solidity typehashes are keccak256 of these exact strings. */
+export const ATTESTATION_TYPE_STRING = encodeTypeString("Attestation", ATTESTATION_TYPES.Attestation);
+export const QUOTE_TYPE_STRING = encodeTypeString("Quote", QUOTE_TYPES.Quote);
+export const ATTESTATION_TYPEHASH = keccak256(stringToBytes(ATTESTATION_TYPE_STRING));
+export const QUOTE_TYPEHASH = keccak256(stringToBytes(QUOTE_TYPE_STRING));
+function encodeTypeString(name, fields) {
+    return `${name}(${fields.map((field) => `${field.type} ${field.name}`).join(",")})`;
+}
+/** Converts a validated attestation into the message shape viem signs. */
+export function attestationMessage(input) {
+    const a = Attestation.parse(input);
+    return {
+        agentId: BigInt(a.agentId),
+        score: a.score,
+        expectedLossBps: a.expectedLossBps,
+        reportHash: a.reportHash,
+        mandateHash: a.mandateHash,
+        codeHash: a.codeHash,
+        teeMeasurement: a.teeMeasurement,
+        modelFamily: MODEL_FAMILY_CODE[a.modelFamily],
+        issuedAt: BigInt(a.issuedAt),
+        expiresAt: BigInt(a.expiresAt),
+    };
+}
+/** Converts a validated quote into the message shape viem signs. */
+export function quoteMessage(input) {
+    const q = Quote.parse(input);
+    return {
+        agentId: BigInt(q.agentId),
+        vault: q.vault,
+        coverAmount: BigInt(q.coverAmount),
+        premiumRateBps: q.premiumRateBps,
+        score: q.score,
+        modelFamily: MODEL_FAMILY_CODE[q.modelFamily],
+        mandateHash: q.mandateHash,
+        reportHash: q.reportHash,
+        minBond: BigInt(q.minBond),
+        expiresAt: BigInt(q.expiresAt),
+        nonce: BigInt(q.nonce),
+    };
+}
+/** Full typed-data payload for signing or verifying an attestation with viem. */
+export function attestationTypedData(domain, attestation) {
+    return {
+        domain,
+        types: ATTESTATION_TYPES,
+        primaryType: "Attestation",
+        message: attestationMessage(attestation),
+    };
+}
+/** Full typed-data payload for signing or verifying a quote with viem. */
+export function quoteTypedData(domain, quote) {
+    return {
+        domain,
+        types: QUOTE_TYPES,
+        primaryType: "Quote",
+        message: quoteMessage(quote),
+    };
+}
+//# sourceMappingURL=attestation.js.map

package/dist/schemas/common.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+/** EVM address, normalised to its EIP-55 checksum form. */
+export declare const evmAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+/** Number of bytes a base58 string decodes to (each leading "1" is one zero byte). */
+export declare function base58DecodedLength(value: string): number;
+/** Solana address: base58 text that decodes to exactly 32 bytes. */
+export declare const solanaAddress: z.ZodString;
+/** 4-byte EVM function selector, e.g. 0xa9059cbb. Normalised to lowercase. */
+export declare const selector: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+/** 32-byte hex value (hashes, measurements). Normalised to lowercase. */
+export declare const bytes32: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+/** Unsigned integer carried as a decimal string (JSON-safe bigint). */
+export declare const uintString: z.ZodString;
+/** Unix timestamp in seconds. */
+export declare const unixSeconds: z.ZodNumber;
+/**
+ * Returns true when the list has no duplicates. Compares exactly, because Solana base58
+ * addresses are case-sensitive. Normalise values first (EVM addresses are checksummed and
+ * selectors lowercased by their schemas before this runs).
+ */
+export declare function isUnique(values: readonly string[]): boolean;
+//# sourceMappingURL=common.d.ts.map

package/dist/schemas/common.js

@@ -0,0 +1,53 @@
+import { getAddress, isAddress } from "viem";
+import { z } from "zod";
+/** EVM address, normalised to its EIP-55 checksum form. */
+export const evmAddress = z
+    .string()
+    .refine((value) => isAddress(value, { strict: false }), "invalid EVM address")
+    .transform((value) => getAddress(value));
+const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+/** Number of bytes a base58 string decodes to (each leading "1" is one zero byte). */
+export function base58DecodedLength(value) {
+    let number = 0n;
+    for (const char of value) {
+        const digit = BASE58_ALPHABET.indexOf(char);
+        if (digit === -1)
+            throw new Error(`invalid base58 character: ${char}`);
+        number = number * 58n + BigInt(digit);
+    }
+    const leadingZeros = value.length - value.replace(/^1+/, "").length;
+    const bodyLength = number === 0n ? 0 : Math.ceil(number.toString(16).length / 2);
+    return leadingZeros + bodyLength;
+}
+const BASE58_ADDRESS = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+/** Solana address: base58 text that decodes to exactly 32 bytes. */
+export const solanaAddress = z
+    .string()
+    .regex(BASE58_ADDRESS, "invalid Solana address")
+    // Zod runs every check, so guard the decode against text the regex already rejected.
+    .refine((value) => !BASE58_ADDRESS.test(value) || base58DecodedLength(value) === 32, "Solana address must decode to 32 bytes");
+/** 4-byte EVM function selector, e.g. 0xa9059cbb. Normalised to lowercase. */
+export const selector = z
+    .string()
+    .regex(/^0x[0-9a-fA-F]{8}$/, "selector must be 0x followed by 8 hex chars")
+    .transform((value) => value.toLowerCase());
+/** 32-byte hex value (hashes, measurements). Normalised to lowercase. */
+export const bytes32 = z
+    .string()
+    .regex(/^0x[0-9a-fA-F]{64}$/, "expected 0x followed by 64 hex chars")
+    .transform((value) => value.toLowerCase());
+/** Unsigned integer carried as a decimal string (JSON-safe bigint). */
+export const uintString = z
+    .string()
+    .regex(/^(0|[1-9][0-9]*)$/, "expected an unsigned integer as a decimal string");
+/** Unix timestamp in seconds. */
+export const unixSeconds = z.number().int().nonnegative();
+/**
+ * Returns true when the list has no duplicates. Compares exactly, because Solana base58
+ * addresses are case-sensitive. Normalise values first (EVM addresses are checksummed and
+ * selectors lowercased by their schemas before this runs).
+ */
+export function isUnique(values) {
+    return new Set(values).size === values.length;
+}
+//# sourceMappingURL=common.js.map

package/dist/schemas/mandate-commitment.d.ts

@@ -0,0 +1,13 @@
+import type { EvmMandateParams } from "./mandate.js";
+/**
+ * On-chain commitment to the rules a mandate enforces: keccak256 of the ABI-encoded params with
+ * `mandateHash` set to zero. Matches `BondedTypes.mandateCommitment` in Solidity.
+ *
+ * MandateModuleFactory refuses a module whose `mandateHash` isn't this value, so a module's
+ * mandate hash proves what it enforces. Ratings, quotes and cover for a module-protected agent
+ * use this commitment as the mandate hash (vaults still use the hash of the mandate JSON).
+ */
+export declare function mandateCommitment(params: EvmMandateParams): `0x${string}`;
+/** The params with `mandateHash` replaced by their commitment, ready for `createModule`. */
+export declare function withMandateCommitment(params: EvmMandateParams): EvmMandateParams;
+//# sourceMappingURL=mandate-commitment.d.ts.map

package/dist/schemas/mandate-commitment.js

@@ -0,0 +1,37 @@
+import { encodeAbiParameters, keccak256, zeroHash } from "viem";
+/** ABI type of the Solidity struct `BondedTypes.MandateParams`. */
+const MANDATE_PARAMS_ABI = [
+    {
+        type: "tuple",
+        components: [
+            { name: "mandateHash", type: "bytes32" },
+            { name: "mode", type: "uint8" },
+            { name: "baseAsset", type: "address" },
+            { name: "assets", type: "address[]" },
+            { name: "targets", type: "address[]" },
+            { name: "selectors", type: "bytes4[][]" },
+            { name: "destinations", type: "address[]" },
+            { name: "maxTxNotionalUsd6", type: "uint256" },
+            { name: "maxDailyNotionalUsd6", type: "uint256" },
+            { name: "maxDrawdownBps", type: "uint16" },
+            { name: "maxSlippageBps", type: "uint16" },
+            { name: "freezeOnBreach", type: "bool" },
+        ],
+    },
+];
+/**
+ * On-chain commitment to the rules a mandate enforces: keccak256 of the ABI-encoded params with
+ * `mandateHash` set to zero. Matches `BondedTypes.mandateCommitment` in Solidity.
+ *
+ * MandateModuleFactory refuses a module whose `mandateHash` isn't this value, so a module's
+ * mandate hash proves what it enforces. Ratings, quotes and cover for a module-protected agent
+ * use this commitment as the mandate hash (vaults still use the hash of the mandate JSON).
+ */
+export function mandateCommitment(params) {
+    return keccak256(encodeAbiParameters(MANDATE_PARAMS_ABI, [{ ...params, mandateHash: zeroHash }]));
+}
+/** The params with `mandateHash` replaced by their commitment, ready for `createModule`. */
+export function withMandateCommitment(params) {
+    return { ...params, mandateHash: mandateCommitment(params) };
+}
+//# sourceMappingURL=mandate-commitment.js.map