@wiimdy/openfunderse-sdk 0.1.1

package/dist/dist_bak_vercel_repro/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/dist_bak_vercel_repro/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/dist_bak_vercel_repro/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/dist_bak_vercel_repro/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/dist_bak_vercel_repro/nadfun-types.js

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

package/dist/dist_bak_vercel_repro/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/dist_bak_vercel_repro/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/dist_bak_vercel_repro/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/dist_bak_vercel_repro/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/dist_bak_vercel_repro/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/dist_bak_vercel_repro/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/dist_bak_vercel_repro/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/dist_bak_vercel_repro/types.js

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

package/dist/dist_bak_vercel_repro/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/dist_bak_vercel_repro/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/dist_bak_vercel_repro/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;

package/dist/dist_bak_vercel_repro/weighted-attestation.js

@@ -0,0 +1,62 @@
+function toKey(address) {
+    return address.toLowerCase();
+}
+export function buildValidatorWeightMap(entries, options = {}) {
+    const allowZeroWeight = options.allowZeroWeight ?? false;
+    const map = new Map();
+    for (const entry of entries) {
+        if (entry.weight < 0n) {
+            throw new Error("weight must be non-negative");
+        }
+        if (!allowZeroWeight && entry.weight === 0n) {
+            throw new Error("weight must be positive");
+        }
+        const key = toKey(entry.validator);
+        if (map.has(key)) {
+            throw new Error(`duplicate validator weight entry: ${entry.validator}`);
+        }
+        map.set(key, entry.weight);
+    }
+    return map;
+}
+export function totalValidatorWeight(weightMap) {
+    let total = 0n;
+    for (const weight of weightMap.values()) {
+        total += weight;
+    }
+    return total;
+}
+export function attestedWeight(attesters, weightMap) {
+    let total = 0n;
+    const seen = new Set();
+    for (const attester of attesters) {
+        const key = toKey(attester);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const weight = weightMap.get(key);
+        if (weight !== undefined) {
+            total += weight;
+        }
+    }
+    return total;
+}
+export function reachedWeightedThreshold(attesters, weightMap, thresholdWeight) {
+    if (thresholdWeight <= 0n) {
+        throw new Error("thresholdWeight must be positive");
+    }
+    return attestedWeight(attesters, weightMap) >= thresholdWeight;
+}
+export function weightedThresholdState(attesters, weightMap, thresholdWeight) {
+    if (thresholdWeight <= 0n) {
+        throw new Error("thresholdWeight must be positive");
+    }
+    const totalWeight = totalValidatorWeight(weightMap);
+    const reachedWeight = attestedWeight(attesters, weightMap);
+    return {
+        totalWeight,
+        attestedWeight: reachedWeight,
+        thresholdWeight,
+        met: reachedWeight >= thresholdWeight
+    };
+}

package/dist/eip712.d.ts

@@ -0,0 +1,112 @@
+import type { Address, Eip712DomainInput, Hex } from "./types.js";
+export declare const CLAIM_ATTESTATION_TYPES: {
+    readonly ClaimAttestation: readonly [{
+        readonly name: "claimHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "epochId";
+        readonly type: "uint64";
+    }, {
+        readonly name: "verifier";
+        readonly type: "address";
+    }, {
+        readonly name: "expiresAt";
+        readonly type: "uint64";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }];
+};
+export declare const INTENT_ATTESTATION_TYPES: {
+    readonly IntentAttestation: readonly [{
+        readonly name: "intentHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "verifier";
+        readonly type: "address";
+    }, {
+        readonly name: "expiresAt";
+        readonly type: "uint64";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }];
+};
+export interface ClaimAttestationMessage {
+    claimHash: Hex;
+    epochId: bigint;
+    verifier: Address;
+    expiresAt: bigint;
+    nonce: bigint;
+}
+export interface IntentAttestationMessage {
+    intentHash: Hex;
+    verifier: Address;
+    expiresAt: bigint;
+    nonce: bigint;
+}
+export declare function toEip712Domain(input: Eip712DomainInput): {
+    name: string;
+    version: string;
+    chainId: bigint;
+    verifyingContract: `0x${string}`;
+};
+export declare function claimAttestationTypedData(domain: Eip712DomainInput, message: ClaimAttestationMessage): {
+    domain: {
+        name: string;
+        version: string;
+        chainId: bigint;
+        verifyingContract: `0x${string}`;
+    };
+    types: {
+        readonly ClaimAttestation: readonly [{
+            readonly name: "claimHash";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "epochId";
+            readonly type: "uint64";
+        }, {
+            readonly name: "verifier";
+            readonly type: "address";
+        }, {
+            readonly name: "expiresAt";
+            readonly type: "uint64";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }];
+    };
+    primaryType: "ClaimAttestation";
+    message: ClaimAttestationMessage;
+};
+export declare function intentAttestationTypedData(domain: Eip712DomainInput, message: IntentAttestationMessage): {
+    domain: {
+        name: string;
+        version: string;
+        chainId: bigint;
+        verifyingContract: `0x${string}`;
+    };
+    types: {
+        readonly IntentAttestation: readonly [{
+            readonly name: "intentHash";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "verifier";
+            readonly type: "address";
+        }, {
+            readonly name: "expiresAt";
+            readonly type: "uint64";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }];
+    };
+    primaryType: "IntentAttestation";
+    message: IntentAttestationMessage;
+};
+export declare function claimAttestationDigest(domain: Eip712DomainInput, message: ClaimAttestationMessage): Hex;
+export declare function intentAttestationDigest(domain: Eip712DomainInput, message: IntentAttestationMessage): Hex;
+export declare function verifyClaimAttestation(domain: Eip712DomainInput, message: ClaimAttestationMessage, signature: Hex): Promise<boolean>;
+export declare function verifyIntentAttestation(domain: Eip712DomainInput, message: IntentAttestationMessage, signature: Hex): Promise<boolean>;
+export declare function recoverClaimAttester(domain: Eip712DomainInput, message: ClaimAttestationMessage, signature: Hex): Promise<Address>;
+export declare function recoverIntentAttester(domain: Eip712DomainInput, message: IntentAttestationMessage, signature: Hex): Promise<Address>;