@wiimdy/openfunderse-sdk 0.1.1

package/dist/eip712.js

@@ -0,0 +1,74 @@
+import { hashTypedData, recoverTypedDataAddress, verifyTypedData } from "viem";
+export const CLAIM_ATTESTATION_TYPES = {
+    ClaimAttestation: [
+        { name: "claimHash", type: "bytes32" },
+        { name: "epochId", type: "uint64" },
+        { name: "verifier", type: "address" },
+        { name: "expiresAt", type: "uint64" },
+        { name: "nonce", type: "uint256" }
+    ]
+};
+export const INTENT_ATTESTATION_TYPES = {
+    IntentAttestation: [
+        { name: "intentHash", type: "bytes32" },
+        { name: "verifier", type: "address" },
+        { name: "expiresAt", type: "uint64" },
+        { name: "nonce", type: "uint256" }
+    ]
+};
+export function toEip712Domain(input) {
+    return {
+        name: input.name,
+        version: input.version,
+        chainId: input.chainId,
+        verifyingContract: input.verifyingContract
+    };
+}
+export function claimAttestationTypedData(domain, message) {
+    return {
+        domain: toEip712Domain(domain),
+        types: CLAIM_ATTESTATION_TYPES,
+        primaryType: "ClaimAttestation",
+        message
+    };
+}
+export function intentAttestationTypedData(domain, message) {
+    return {
+        domain: toEip712Domain(domain),
+        types: INTENT_ATTESTATION_TYPES,
+        primaryType: "IntentAttestation",
+        message
+    };
+}
+export function claimAttestationDigest(domain, message) {
+    return hashTypedData(claimAttestationTypedData(domain, message));
+}
+export function intentAttestationDigest(domain, message) {
+    return hashTypedData(intentAttestationTypedData(domain, message));
+}
+export async function verifyClaimAttestation(domain, message, signature) {
+    return verifyTypedData({
+        ...claimAttestationTypedData(domain, message),
+        address: message.verifier,
+        signature
+    });
+}
+export async function verifyIntentAttestation(domain, message, signature) {
+    return verifyTypedData({
+        ...intentAttestationTypedData(domain, message),
+        address: message.verifier,
+        signature
+    });
+}
+export async function recoverClaimAttester(domain, message, signature) {
+    return recoverTypedDataAddress({
+        ...claimAttestationTypedData(domain, message),
+        signature
+    });
+}
+export async function recoverIntentAttester(domain, message, signature) {
+    return recoverTypedDataAddress({
+        ...intentAttestationTypedData(domain, message),
+        signature
+    });
+}

package/dist/erc1271.d.ts

@@ -0,0 +1,4 @@
+import type { Hex } from "./types.js";
+export declare const ERC1271_MAGIC_VALUE = "0x1626ba7e";
+export declare function encodeErc1271IsValidSignatureCall(hash: Hex, signature: Hex): Hex;
+export declare function isValidErc1271Result(result: Hex): boolean;

package/dist/erc1271.js

@@ -0,0 +1,24 @@
+import { encodeFunctionData } from "viem";
+export const ERC1271_MAGIC_VALUE = "0x1626ba7e";
+const ERC1271_ABI = [
+    {
+        type: "function",
+        name: "isValidSignature",
+        stateMutability: "view",
+        inputs: [
+            { name: "hash", type: "bytes32" },
+            { name: "signature", type: "bytes" }
+        ],
+        outputs: [{ name: "magicValue", type: "bytes4" }]
+    }
+];
+export function encodeErc1271IsValidSignatureCall(hash, signature) {
+    return encodeFunctionData({
+        abi: ERC1271_ABI,
+        functionName: "isValidSignature",
+        args: [hash, signature]
+    });
+}
+export function isValidErc1271Result(result) {
+    return result.slice(0, 10).toLowerCase() === ERC1271_MAGIC_VALUE;
+}

package/dist/execution-data.d.ts

@@ -0,0 +1,3 @@
+import type { Hex, NadfunExecutionDataV1 } from "./types.js";
+export declare function encodeNadfunExecutionDataV1(data: NadfunExecutionDataV1): Hex;
+export declare function decodeNadfunExecutionDataV1(raw: Hex): NadfunExecutionDataV1;

package/dist/execution-data.js

@@ -0,0 +1,66 @@
+import { decodeAbiParameters, encodeAbiParameters, parseAbiParameters } from "viem";
+import { assertUint64 } from "./validate.js";
+const NADFUN_V1_ABI = parseAbiParameters("uint8 version,uint8 action,uint8 venue,address router,address recipient,address token,uint64 deadline,uint256 amountOutMin,bytes extra");
+const ACTION_TO_ID = {
+    BUY: 1,
+    SELL: 2
+};
+const VENUE_TO_ID = {
+    NADFUN_BONDING_CURVE: 1,
+    NADFUN_DEX: 2
+};
+const ID_TO_ACTION = {
+    1: "BUY",
+    2: "SELL"
+};
+const ID_TO_VENUE = {
+    1: "NADFUN_BONDING_CURVE",
+    2: "NADFUN_DEX"
+};
+function assertVersion(version) {
+    if (version !== 1) {
+        throw new Error(`unsupported execution-data version: ${version}`);
+    }
+}
+function assertKnownAction(actionId) {
+    const action = ID_TO_ACTION[actionId];
+    if (!action)
+        throw new Error(`unsupported action id: ${actionId}`);
+    return action;
+}
+function assertKnownVenue(venueId) {
+    const venue = ID_TO_VENUE[venueId];
+    if (!venue)
+        throw new Error(`unsupported venue id: ${venueId}`);
+    return venue;
+}
+export function encodeNadfunExecutionDataV1(data) {
+    assertUint64(data.deadline, "deadline");
+    return encodeAbiParameters(NADFUN_V1_ABI, [
+        data.version,
+        ACTION_TO_ID[data.action],
+        VENUE_TO_ID[data.venue],
+        data.router,
+        data.recipient,
+        data.token,
+        data.deadline,
+        data.amountOutMin,
+        data.extra
+    ]);
+}
+export function decodeNadfunExecutionDataV1(raw) {
+    const [version, actionId, venueId, router, recipient, token, deadline, amountOutMin, extra] = decodeAbiParameters(NADFUN_V1_ABI, raw);
+    const v = Number(version);
+    assertVersion(v);
+    return {
+        version: 1,
+        action: assertKnownAction(Number(actionId)),
+        venue: assertKnownVenue(Number(venueId)),
+        router,
+        recipient,
+        token,
+        deadline,
+        amountOutMin,
+        extra
+    };
+}

package/dist/hash.d.ts

@@ -0,0 +1,16 @@
+import type { Address, ClaimPayload, Hex, TradeIntent } from "./types.js";
+export declare function claimHash(payload: ClaimPayload): Hex;
+export declare function intentHash(intent: TradeIntent): Hex;
+export declare function snapshotHash(epochId: bigint, orderedClaimHashes: Hex[]): Hex;
+export declare function canonicalOrderedClaimHashes(claimHashes: Hex[]): Hex[];
+export declare function snapshotHashFromUnordered(epochId: bigint, claimHashes: Hex[]): Hex;
+export declare function reasonHash(reason: string): Hex;
+/**
+ * Canonical allowlist hash for intent execution route.
+ * Must match ClawCore allowlist verification logic.
+ */
+export declare function intentExecutionAllowlistHash(tokenIn: Address, tokenOut: Address, quoteAmountOut: bigint, minAmountOut: bigint, adapter: Address, adapterDataHash: Hex): Hex;
+/**
+ * Helper that hashes raw adapter calldata before building the allowlist hash.
+ */
+export declare function intentExecutionCallHash(tokenIn: Address, tokenOut: Address, quoteAmountOut: bigint, minAmountOut: bigint, adapter: Address, adapterData: Hex): Hex;

package/dist/hash.js

@@ -0,0 +1,67 @@
+import { encodeAbiParameters, keccak256, parseAbiParameters, toHex } from "viem";
+import { canonicalClaim, canonicalIntent } from "./canonical.js";
+import { assertStrictlySortedHex, uniqueSortedBytes32Hex } from "./ordering.js";
+import { assertUint16, assertUint64 } from "./validate.js";
+export function claimHash(payload) {
+    const v = canonicalClaim(payload);
+    assertUint64(v.timestamp, "timestamp");
+    return keccak256(encodeAbiParameters(parseAbiParameters("string schemaId,string sourceType,string sourceRef,string selector,string extracted,string extractedType,uint64 timestamp,bytes32 responseHash,string evidenceType,string evidenceURI,address crawler,string notes"), [
+        v.schemaId,
+        v.sourceType,
+        v.sourceRef,
+        v.selector,
+        v.extracted,
+        v.extractedType,
+        v.timestamp,
+        v.responseHash,
+        v.evidenceType,
+        v.evidenceURI,
+        v.crawler,
+        v.notes ?? ""
+    ]));
+}
+export function intentHash(intent) {
+    const v = canonicalIntent(intent);
+    assertUint64(v.deadline, "deadline");
+    assertUint16(v.maxSlippageBps, "maxSlippageBps");
+    return keccak256(encodeAbiParameters(parseAbiParameters("string intentVersion,address vault,string action,address tokenIn,address tokenOut,uint256 amountIn,uint256 minAmountOut,uint64 deadline,uint16 maxSlippageBps,bytes32 snapshotHash"), [
+        v.intentVersion,
+        v.vault,
+        v.action,
+        v.tokenIn,
+        v.tokenOut,
+        v.amountIn,
+        v.minAmountOut,
+        v.deadline,
+        Number(v.maxSlippageBps),
+        v.snapshotHash
+    ]));
+}
+export function snapshotHash(epochId, orderedClaimHashes) {
+    assertUint64(epochId, "epochId");
+    assertStrictlySortedHex(orderedClaimHashes);
+    return keccak256(encodeAbiParameters(parseAbiParameters("uint64 epochId,bytes32[] orderedClaimHashes"), [epochId, orderedClaimHashes]));
+}
+export function canonicalOrderedClaimHashes(claimHashes) {
+    return uniqueSortedBytes32Hex(claimHashes);
+}
+export function snapshotHashFromUnordered(epochId, claimHashes) {
+    const orderedClaimHashes = canonicalOrderedClaimHashes(claimHashes);
+    return snapshotHash(epochId, orderedClaimHashes);
+}
+export function reasonHash(reason) {
+    return keccak256(toHex(reason.normalize("NFC").trim()));
+}
+/**
+ * Canonical allowlist hash for intent execution route.
+ * Must match ClawCore allowlist verification logic.
+ */
+export function intentExecutionAllowlistHash(tokenIn, tokenOut, quoteAmountOut, minAmountOut, adapter, adapterDataHash) {
+    return keccak256(encodeAbiParameters(parseAbiParameters("address tokenIn,address tokenOut,uint256 quoteAmountOut,uint256 minAmountOut,address adapter,bytes32 adapterDataHash"), [tokenIn, tokenOut, quoteAmountOut, minAmountOut, adapter, adapterDataHash]));
+}
+/**
+ * Helper that hashes raw adapter calldata before building the allowlist hash.
+ */
+export function intentExecutionCallHash(tokenIn, tokenOut, quoteAmountOut, minAmountOut, adapter, adapterData) {
+    return intentExecutionAllowlistHash(tokenIn, tokenOut, quoteAmountOut, minAmountOut, adapter, keccak256(adapterData));
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./types.js";
+export * from "./nadfun-types.js";
+export * from "./canonical.js";
+export * from "./hash.js";
+export * from "./eip712.js";
+export * from "./erc1271.js";
+export * from "./ordering.js";
+export * from "./scope.js";
+export * from "./attestation.js";
+export * from "./validate.js";
+export * from "./attestation-verifier.js";
+export * from "./weighted-attestation.js";
+export * from "./execution-data.js";
+export * from "./relayer-utils.js";

package/dist/index.js

@@ -0,0 +1,14 @@
+export * from "./types.js";
+export * from "./nadfun-types.js";
+export * from "./canonical.js";
+export * from "./hash.js";
+export * from "./eip712.js";
+export * from "./erc1271.js";
+export * from "./ordering.js";
+export * from "./scope.js";
+export * from "./attestation.js";
+export * from "./validate.js";
+export * from "./attestation-verifier.js";
+export * from "./weighted-attestation.js";
+export * from "./execution-data.js";
+export * from "./relayer-utils.js";

package/dist/nadfun-types.d.ts

@@ -0,0 +1,29 @@
+import { Address, TradeIntent } from "./types.js";
+/**
+ * NadFun-specific metadata for offchain intent context.
+ * These fields are NOT included in intentHash computation.
+ * They provide additional context for strategy/verifier agents.
+ */
+export interface NadFunIntentMeta {
+    /** Token symbol (e.g., "ABC") */
+    tokenSymbol: string;
+    /** Bonding curve state: BONDING (pre-graduation) or GRADUATED (post-graduation) */
+    curveState: "BONDING" | "GRADUATED";
+    /** Bonding curve contract address (valid when curveState === "BONDING") */
+    curveAddress: Address;
+    /** DEX pool address (valid when curveState === "GRADUATED") */
+    dexPoolAddress: Address;
+    /** NadFun platform token ID */
+    nadfunTokenId: string;
+    /** Graduation progress in basis points (0-10000) */
+    graduationProgress: bigint;
+}
+/**
+ * Extended trade intent combining canonical TradeIntent with NadFun metadata.
+ * The intentHash is computed only from TradeIntent fields.
+ * Metadata fields are for offchain context and agent decision-making.
+ */
+export interface NadFunTradeIntent extends TradeIntent {
+    /** NadFun-specific metadata (not included in hash) */
+    nadfunMeta: NadFunIntentMeta;
+}

package/dist/nadfun-types.js

@@ -0,0 +1 @@
+export {};

package/dist/ordering.d.ts

@@ -0,0 +1,5 @@
+import type { Hex } from "./types.js";
+export declare function sortBytes32Hex(values: Hex[]): Hex[];
+export declare function uniqueSortedBytes32Hex(values: Hex[]): Hex[];
+export declare function isStrictlySortedHex(values: Hex[]): boolean;
+export declare function assertStrictlySortedHex(values: Hex[], label?: string): void;

package/dist/ordering.js

@@ -0,0 +1,22 @@
+function normalizeHex(value) {
+    return value.toLowerCase();
+}
+export function sortBytes32Hex(values) {
+    return [...values].map(normalizeHex).sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+}
+export function uniqueSortedBytes32Hex(values) {
+    return [...new Set(sortBytes32Hex(values))];
+}
+export function isStrictlySortedHex(values) {
+    for (let i = 1; i < values.length; i += 1) {
+        if (values[i - 1].toLowerCase() >= values[i].toLowerCase()) {
+            return false;
+        }
+    }
+    return true;
+}
+export function assertStrictlySortedHex(values, label = "orderedClaimHashes") {
+    if (!isStrictlySortedHex(values)) {
+        throw new Error(`${label} must be strictly sorted ascending with no duplicates`);
+    }
+}

package/dist/relayer-utils.d.ts

@@ -0,0 +1,29 @@
+import type { CanonicalClaimRecord, CanonicalIntentRecord, ClaimPayload, CoreExecutionRequestInput, Hex, IntentExecutionRouteInput, IntentConstraints, TradeIntent } from "./types.js";
+export declare function buildCanonicalClaimRecord(input: {
+    payload: ClaimPayload;
+    epochId: bigint;
+}): CanonicalClaimRecord;
+export declare function buildIntentConstraints(input: {
+    allowlistHash: Hex;
+    maxSlippageBps: bigint;
+    maxNotional: bigint;
+    deadline: bigint;
+}): IntentConstraints;
+export declare function buildCanonicalIntentRecord(input: {
+    intent: TradeIntent;
+    allowlistHash: Hex;
+    maxNotional: bigint;
+    now?: bigint;
+}): CanonicalIntentRecord;
+export declare function buildCanonicalSnapshotRecord(input: {
+    epochId: bigint;
+    claimHashes: Hex[];
+}): {
+    epochId: bigint;
+    snapshotHash: `0x${string}`;
+};
+export declare function buildIntentAllowlistHashFromRoute(route: IntentExecutionRouteInput): Hex;
+export declare function buildCoreExecutionRequestFromIntent(input: {
+    intent: TradeIntent;
+    executionRoute: IntentExecutionRouteInput;
+}): CoreExecutionRequestInput;

package/dist/relayer-utils.js

@@ -0,0 +1,108 @@
+import { keccak256 } from "viem";
+import { canonicalClaim, canonicalIntent } from "./canonical.js";
+import { claimHash, intentExecutionAllowlistHash, intentHash, snapshotHashFromUnordered } from "./hash.js";
+import { assertUint16, assertUint64 } from "./validate.js";
+function assertPositive(value, label) {
+    if (value <= 0n) {
+        throw new Error(`${label} must be positive`);
+    }
+}
+function assertHex32(value, label) {
+    if (!/^0x[0-9a-fA-F]{64}$/.test(value)) {
+        throw new Error(`${label} must be 0x-prefixed 32-byte hex`);
+    }
+}
+export function buildCanonicalClaimRecord(input) {
+    assertUint64(input.epochId, "epochId");
+    assertUint64(input.payload.timestamp, "timestamp");
+    const payload = canonicalClaim(input.payload);
+    const hash = claimHash(payload);
+    return {
+        payload,
+        epochId: input.epochId,
+        claimHash: hash
+    };
+}
+export function buildIntentConstraints(input) {
+    assertHex32(input.allowlistHash, "allowlistHash");
+    assertUint16(input.maxSlippageBps, "maxSlippageBps");
+    assertUint64(input.deadline, "deadline");
+    assertPositive(input.maxNotional, "maxNotional");
+    return {
+        allowlistHash: input.allowlistHash,
+        maxSlippageBps: input.maxSlippageBps,
+        maxNotional: input.maxNotional,
+        deadline: input.deadline
+    };
+}
+export function buildCanonicalIntentRecord(input) {
+    const intent = canonicalIntent(input.intent);
+    assertUint64(intent.deadline, "deadline");
+    assertUint16(intent.maxSlippageBps, "maxSlippageBps");
+    assertPositive(intent.amountIn, "amountIn");
+    assertPositive(intent.minAmountOut, "minAmountOut");
+    if (intent.deadline <= (input.now ?? BigInt(Math.floor(Date.now() / 1000)))) {
+        throw new Error("intent deadline is expired");
+    }
+    const constraints = buildIntentConstraints({
+        allowlistHash: input.allowlistHash,
+        maxSlippageBps: intent.maxSlippageBps,
+        maxNotional: input.maxNotional,
+        deadline: intent.deadline
+    });
+    return {
+        intent,
+        intentHash: intentHash(intent),
+        constraints
+    };
+}
+export function buildCanonicalSnapshotRecord(input) {
+    assertUint64(input.epochId, "epochId");
+    if (input.claimHashes.length === 0) {
+        throw new Error("claimHashes must not be empty");
+    }
+    const hash = snapshotHashFromUnordered(input.epochId, input.claimHashes);
+    return {
+        epochId: input.epochId,
+        snapshotHash: hash
+    };
+}
+export function buildIntentAllowlistHashFromRoute(route) {
+    assertPositive(route.quoteAmountOut, "quoteAmountOut");
+    assertPositive(route.minAmountOut, "minAmountOut");
+    const adapterDataHash = route.adapterDataHash ??
+        (route.adapterData ? keccak256(route.adapterData) : undefined);
+    if (!adapterDataHash) {
+        throw new Error("adapterData or adapterDataHash is required");
+    }
+    assertHex32(adapterDataHash, "adapterDataHash");
+    return intentExecutionAllowlistHash(route.tokenIn, route.tokenOut, route.quoteAmountOut, route.minAmountOut, route.adapter, adapterDataHash);
+}
+export function buildCoreExecutionRequestFromIntent(input) {
+    const { intent, executionRoute } = input;
+    assertPositive(intent.amountIn, "amountIn");
+    assertPositive(intent.minAmountOut, "minAmountOut");
+    assertPositive(executionRoute.quoteAmountOut, "quoteAmountOut");
+    assertPositive(executionRoute.minAmountOut, "route.minAmountOut");
+    if (executionRoute.tokenIn.toLowerCase() !== intent.tokenIn.toLowerCase()) {
+        throw new Error("executionRoute.tokenIn must match intent.tokenIn");
+    }
+    if (executionRoute.tokenOut.toLowerCase() !== intent.tokenOut.toLowerCase()) {
+        throw new Error("executionRoute.tokenOut must match intent.tokenOut");
+    }
+    if (executionRoute.minAmountOut !== intent.minAmountOut) {
+        throw new Error("executionRoute.minAmountOut must match intent.minAmountOut");
+    }
+    if (!executionRoute.adapterData) {
+        throw new Error("executionRoute.adapterData is required for execution");
+    }
+    return {
+        tokenIn: executionRoute.tokenIn,
+        tokenOut: executionRoute.tokenOut,
+        amountIn: intent.amountIn,
+        quoteAmountOut: executionRoute.quoteAmountOut,
+        minAmountOut: executionRoute.minAmountOut,
+        adapter: executionRoute.adapter,
+        adapterData: executionRoute.adapterData
+    };
+}

package/dist/scope.d.ts

@@ -0,0 +1,5 @@
+import type { Hex, ProtocolScope } from "./types.js";
+export declare function canonicalScope(input: ProtocolScope): ProtocolScope;
+export declare function scopeKey(input: ProtocolScope): string;
+export declare function assertSameScope(expected: ProtocolScope, received: ProtocolScope): void;
+export declare function scopedSnapshotHash(scope: ProtocolScope, snapshotHash: Hex): Hex;

package/dist/scope.js

@@ -0,0 +1,26 @@
+import { encodeAbiParameters, keccak256, parseAbiParameters } from "viem";
+function normalizeScopeText(value) {
+    return value.normalize("NFC").trim();
+}
+export function canonicalScope(input) {
+    return {
+        fundId: normalizeScopeText(input.fundId),
+        roomId: normalizeScopeText(input.roomId),
+        epochId: input.epochId
+    };
+}
+export function scopeKey(input) {
+    const v = canonicalScope(input);
+    return `${v.fundId}:${v.roomId}:${v.epochId.toString(10)}`;
+}
+export function assertSameScope(expected, received) {
+    const left = scopeKey(expected);
+    const right = scopeKey(received);
+    if (left !== right) {
+        throw new Error(`scope mismatch: expected=${left}, received=${right}`);
+    }
+}
+export function scopedSnapshotHash(scope, snapshotHash) {
+    const v = canonicalScope(scope);
+    return keccak256(encodeAbiParameters(parseAbiParameters("string fundId,string roomId,uint64 epochId,bytes32 snapshotHash"), [v.fundId, v.roomId, v.epochId, snapshotHash]));
+}

package/dist/types.d.ts

@@ -0,0 +1,106 @@
+export type Hex = `0x${string}`;
+export type Address = `0x${string}`;
+export interface ClaimPayload {
+    schemaId: string;
+    sourceType: string;
+    sourceRef: string;
+    selector: string;
+    extracted: string;
+    extractedType: string;
+    timestamp: bigint;
+    responseHash: Hex;
+    evidenceType: string;
+    evidenceURI: string;
+    crawler: Address;
+    notes?: string;
+}
+export interface TradeIntent {
+    intentVersion: string;
+    vault: Address;
+    action: "BUY" | "SELL";
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: bigint;
+    minAmountOut: bigint;
+    deadline: bigint;
+    maxSlippageBps: bigint;
+    snapshotHash: Hex;
+    reason?: string;
+}
+export interface Eip712DomainInput {
+    name: string;
+    version: string;
+    chainId: bigint;
+    verifyingContract: Address;
+}
+export interface ProtocolScope {
+    fundId: string;
+    roomId: string;
+    epochId: bigint;
+}
+export type SubjectType = "CLAIM" | "INTENT";
+export interface AttestationMeta {
+    verifier: Address;
+    expiresAt: bigint;
+    nonce: bigint;
+}
+export interface ClaimAttestationDraft extends AttestationMeta {
+    claimHash: Hex;
+    epochId: bigint;
+}
+export interface IntentAttestationDraft extends AttestationMeta {
+    intentHash: Hex;
+}
+export interface SignedAttestation<TSubject extends SubjectType, TMessage> {
+    subjectType: TSubject;
+    subjectHash: Hex;
+    message: TMessage;
+    signature: Hex;
+}
+export type ExecutionAction = "BUY" | "SELL";
+export type ExecutionVenue = "NADFUN_BONDING_CURVE" | "NADFUN_DEX";
+export interface NadfunExecutionDataV1 {
+    version: 1;
+    action: ExecutionAction;
+    venue: ExecutionVenue;
+    router: Address;
+    recipient: Address;
+    token: Address;
+    deadline: bigint;
+    amountOutMin: bigint;
+    extra: Hex;
+}
+export interface IntentConstraints {
+    allowlistHash: Hex;
+    maxSlippageBps: bigint;
+    maxNotional: bigint;
+    deadline: bigint;
+}
+export interface IntentExecutionRouteInput {
+    tokenIn: Address;
+    tokenOut: Address;
+    quoteAmountOut: bigint;
+    minAmountOut: bigint;
+    adapter: Address;
+    adapterData?: Hex;
+    adapterDataHash?: Hex;
+}
+export interface CoreExecutionRequestInput {
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: bigint;
+    quoteAmountOut: bigint;
+    minAmountOut: bigint;
+    adapter: Address;
+    adapterData: Hex;
+}
+export interface CanonicalClaimRecord {
+    payload: ClaimPayload;
+    epochId: bigint;
+    claimHash: Hex;
+}
+export interface CanonicalIntentRecord {
+    intent: TradeIntent;
+    intentHash: Hex;
+    constraints: IntentConstraints;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/validate.d.ts

@@ -0,0 +1,2 @@
+export declare function assertUint16(value: bigint, label: string): void;
+export declare function assertUint64(value: bigint, label: string): void;

package/dist/validate.js

@@ -0,0 +1,12 @@
+const UINT16_MAX = (1n << 16n) - 1n;
+const UINT64_MAX = (1n << 64n) - 1n;
+export function assertUint16(value, label) {
+    if (value < 0n || value > UINT16_MAX) {
+        throw new Error(`${label} must be uint16`);
+    }
+}
+export function assertUint64(value, label) {
+    if (value < 0n || value > UINT64_MAX) {
+        throw new Error(`${label} must be uint64`);
+    }
+}

package/dist/weighted-attestation.d.ts

@@ -0,0 +1,19 @@
+import type { Address } from "./types.js";
+export interface ValidatorWeight {
+    validator: Address;
+    weight: bigint;
+}
+export interface WeightMapOptions {
+    allowZeroWeight?: boolean;
+}
+export interface WeightedThresholdState {
+    totalWeight: bigint;
+    attestedWeight: bigint;
+    thresholdWeight: bigint;
+    met: boolean;
+}
+export declare function buildValidatorWeightMap(entries: ValidatorWeight[], options?: WeightMapOptions): Map<string, bigint>;
+export declare function totalValidatorWeight(weightMap: Map<string, bigint>): bigint;
+export declare function attestedWeight(attesters: Address[], weightMap: Map<string, bigint>): bigint;
+export declare function reachedWeightedThreshold(attesters: Address[], weightMap: Map<string, bigint>, thresholdWeight: bigint): boolean;
+export declare function weightedThresholdState(attesters: Address[], weightMap: Map<string, bigint>, thresholdWeight: bigint): WeightedThresholdState;