@wiimdy/openfunderse-sdk 0.1.1 → 0.1.2

package/README.md

@@ -6,9 +6,9 @@ Claw의 공통 프로토콜 SDK (최소 범위):
 - Monorepo canonical utility layer shared by contracts tests, relayer, and agents.
 - Owns protocol hashing/typed-data rules so all components use identical verification logic.
 
-- canonical hashing (`claimHash`, `intentHash`, `snapshotHash`)
-- EIP-712 attestation typed data + verify/recover
-- weighted threshold 유틸
+- canonical hashing (`allocationClaimHash`, `intentHash`, `snapshotHash`)
+- EIP-712 intent attestation typed data + verify/recover
+- weighted threshold 유틸 (intent verifier set)
 - intent execution route 해시 유틸 (`intentExecutionAllowlistHash`, `intentExecutionCallHash`)
 - NadFun adapter 실행데이터 인코딩/디코딩 (`encodeNadfunExecutionDataV1`)
 

package/dist/attestation-verifier.d.ts

@@ -1,4 +1,4 @@
-import { type ClaimAttestationMessage, type IntentAttestationMessage } from "./eip712.js";
+import { type IntentAttestationMessage } from "./eip712.js";
 import type { Eip712DomainInput, Hex } from "./types.js";
 export interface VerificationResult {
     ok: boolean;
@@ -6,6 +6,5 @@ export interface VerificationResult {
     recovered?: `0x${string}`;
     error?: string;
 }
-export declare function verifyClaimAttestationEnvelope(domain: Eip712DomainInput, message: ClaimAttestationMessage, signature: Hex): Promise<VerificationResult>;
 export declare function verifyIntentAttestationEnvelope(domain: Eip712DomainInput, message: IntentAttestationMessage, signature: Hex): Promise<VerificationResult>;
 export declare function reachedThreshold(validCount: number, threshold: number): boolean;

package/dist/attestation-verifier.js

@@ -1,4 +1,4 @@
-import { claimAttestationDigest, intentAttestationDigest, recoverClaimAttester, recoverIntentAttester } from "./eip712.js";
+import { intentAttestationDigest, recoverIntentAttester } from "./eip712.js";
 import { assertNotExpired } from "./attestation.js";
 async function verifyEnvelope(verifier, computeDigest, recoverAddress) {
     try {
@@ -25,18 +25,6 @@ async function verifyEnvelope(verifier, computeDigest, recoverAddress) {
         };
     }
 }
-export async function verifyClaimAttestationEnvelope(domain, message, signature) {
-    try {
-        assertNotExpired(message.expiresAt);
-    }
-    catch (error) {
-        return {
-            ok: false,
-            error: error instanceof Error ? error.message : String(error)
-        };
-    }
-    return verifyEnvelope(message.verifier, () => claimAttestationDigest(domain, message), () => recoverClaimAttester(domain, message, signature));
-}
 export async function verifyIntentAttestationEnvelope(domain, message, signature) {
     try {
         assertNotExpired(message.expiresAt);

package/dist/canonical.d.ts

@@ -1,3 +1,3 @@
-import type { ClaimPayload, TradeIntent } from "./types.js";
-export declare function canonicalClaim(input: ClaimPayload): ClaimPayload;
+import type { AllocationClaimV1, TradeIntent } from "./types.js";
+export declare function canonicalAllocationClaim(input: AllocationClaimV1): AllocationClaimV1;
 export declare function canonicalIntent(input: TradeIntent): TradeIntent;

package/dist/canonical.js

@@ -5,19 +5,24 @@ function normalizeText(value) {
 function normalizeAddress(value) {
     return getAddress(value);
 }
-export function canonicalClaim(input) {
+function normalizeWeights(weights) {
+    return weights.map((weight) => {
+        if (weight < 0n) {
+            throw new Error("targetWeights must be non-negative");
+        }
+        return weight;
+    });
+}
+export function canonicalAllocationClaim(input) {
+    if (input.claimVersion !== "v1") {
+        throw new Error(`unsupported claimVersion: ${input.claimVersion}`);
+    }
     return {
         ...input,
-        schemaId: normalizeText(input.schemaId),
-        sourceType: normalizeText(input.sourceType),
-        sourceRef: normalizeText(input.sourceRef),
-        selector: normalizeText(input.selector),
-        extracted: normalizeText(input.extracted),
-        extractedType: normalizeText(input.extractedType),
-        evidenceType: normalizeText(input.evidenceType),
-        evidenceURI: normalizeText(input.evidenceURI),
-        crawler: normalizeAddress(input.crawler),
-        notes: input.notes === undefined ? undefined : normalizeText(input.notes)
+        claimVersion: "v1",
+        fundId: normalizeText(input.fundId),
+        participant: normalizeAddress(input.participant),
+        targetWeights: normalizeWeights(input.targetWeights)
     };
 }
 export function canonicalIntent(input) {

package/dist/eip712.d.ts

@@ -1,22 +1,4 @@
 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";
@@ -32,13 +14,6 @@ export declare const INTENT_ATTESTATION_TYPES: {
         readonly type: "uint256";
     }];
 };
-export interface ClaimAttestationMessage {
-    claimHash: Hex;
-    epochId: bigint;
-    verifier: Address;
-    expiresAt: bigint;
-    nonce: bigint;
-}
 export interface IntentAttestationMessage {
     intentHash: Hex;
     verifier: Address;
@@ -51,34 +26,6 @@ export declare function toEip712Domain(input: Eip712DomainInput): {
     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;
@@ -104,9 +51,6 @@ export declare function intentAttestationTypedData(domain: Eip712DomainInput, me
     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>;

package/dist/eip712.js

@@ -1,13 +1,4 @@
 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" },
@@ -24,14 +15,6 @@ export function toEip712Domain(input) {
         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),
@@ -40,19 +23,9 @@ export function intentAttestationTypedData(domain, message) {
         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),
@@ -60,12 +33,6 @@ export async function verifyIntentAttestation(domain, message, signature) {
         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),

package/dist/hash.d.ts

@@ -1,9 +1,11 @@
-import type { Address, ClaimPayload, Hex, TradeIntent } from "./types.js";
-export declare function claimHash(payload: ClaimPayload): Hex;
+import type { Address, AllocationClaimV1, Hex, TradeIntent } from "./types.js";
+export declare function allocationClaimHash(claim: AllocationClaimV1): 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 const epochStateHash: typeof snapshotHash;
+export declare const epochStateHashFromUnordered: typeof snapshotHashFromUnordered;
 export declare function reasonHash(reason: string): Hex;
 /**
  * Canonical allowlist hash for intent execution route.

package/dist/hash.js

@@ -1,23 +1,33 @@
 import { encodeAbiParameters, keccak256, parseAbiParameters, toHex } from "viem";
-import { canonicalClaim, canonicalIntent } from "./canonical.js";
+import { canonicalAllocationClaim, 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 ?? ""
+function assertUint256NonNegative(value, label) {
+    if (value < 0n) {
+        throw new Error(`${label} must be uint256`);
+    }
+}
+export function allocationClaimHash(claim) {
+    const v = canonicalAllocationClaim(claim);
+    assertUint64(v.epochId, "epochId");
+    assertUint64(v.horizonSec, "horizonSec");
+    assertUint64(v.submittedAt, "submittedAt");
+    assertUint256NonNegative(v.nonce, "nonce");
+    if (v.targetWeights.length === 0) {
+        throw new Error("targetWeights must not be empty");
+    }
+    v.targetWeights.forEach((weight, idx) => {
+        assertUint256NonNegative(weight, `targetWeights[${idx}]`);
+    });
+    return keccak256(encodeAbiParameters(parseAbiParameters("string claimVersion,string fundId,uint64 epochId,address participant,uint256[] targetWeights,uint64 horizonSec,uint256 nonce,uint64 submittedAt"), [
+        v.claimVersion,
+        v.fundId,
+        v.epochId,
+        v.participant,
+        v.targetWeights,
+        v.horizonSec,
+        v.nonce,
+        v.submittedAt
     ]));
 }
 export function intentHash(intent) {
@@ -49,6 +59,8 @@ export function snapshotHashFromUnordered(epochId, claimHashes) {
     const orderedClaimHashes = canonicalOrderedClaimHashes(claimHashes);
     return snapshotHash(epochId, orderedClaimHashes);
 }
+export const epochStateHash = snapshotHash;
+export const epochStateHashFromUnordered = snapshotHashFromUnordered;
 export function reasonHash(reason) {
     return keccak256(toHex(reason.normalize("NFC").trim()));
 }

package/dist/relayer-utils.d.ts

@@ -1,8 +1,7 @@
-import type { CanonicalClaimRecord, CanonicalIntentRecord, ClaimPayload, CoreExecutionRequestInput, Hex, IntentExecutionRouteInput, IntentConstraints, TradeIntent } from "./types.js";
-export declare function buildCanonicalClaimRecord(input: {
-    payload: ClaimPayload;
-    epochId: bigint;
-}): CanonicalClaimRecord;
+import type { AllocationClaimV1, CanonicalAllocationClaimRecord, CanonicalIntentRecord, CoreExecutionRequestInput, Hex, IntentExecutionRouteInput, IntentConstraints, TradeIntent } from "./types.js";
+export declare function buildCanonicalAllocationClaimRecord(input: {
+    claim: AllocationClaimV1;
+}): CanonicalAllocationClaimRecord;
 export declare function buildIntentConstraints(input: {
     allowlistHash: Hex;
     maxSlippageBps: bigint;
@@ -15,12 +14,12 @@ export declare function buildCanonicalIntentRecord(input: {
     maxNotional: bigint;
     now?: bigint;
 }): CanonicalIntentRecord;
-export declare function buildCanonicalSnapshotRecord(input: {
+export declare function buildEpochStateRecord(input: {
     epochId: bigint;
     claimHashes: Hex[];
 }): {
     epochId: bigint;
-    snapshotHash: `0x${string}`;
+    epochStateHash: `0x${string}`;
 };
 export declare function buildIntentAllowlistHashFromRoute(route: IntentExecutionRouteInput): Hex;
 export declare function buildCoreExecutionRequestFromIntent(input: {

package/dist/relayer-utils.js

@@ -1,6 +1,6 @@
 import { keccak256 } from "viem";
-import { canonicalClaim, canonicalIntent } from "./canonical.js";
-import { claimHash, intentExecutionAllowlistHash, intentHash, snapshotHashFromUnordered } from "./hash.js";
+import { canonicalAllocationClaim, canonicalIntent } from "./canonical.js";
+import { allocationClaimHash, intentExecutionAllowlistHash, intentHash, snapshotHashFromUnordered } from "./hash.js";
 import { assertUint16, assertUint64 } from "./validate.js";
 function assertPositive(value, label) {
     if (value <= 0n) {
@@ -12,15 +12,32 @@ function assertHex32(value, label) {
         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);
+function assertWeightsSumPositive(weights) {
+    const sum = weights.reduce((acc, w) => acc + w, 0n);
+    if (sum <= 0n) {
+        throw new Error("targetWeights sum must be positive");
+    }
+}
+export function buildCanonicalAllocationClaimRecord(input) {
+    assertUint64(input.claim.epochId, "epochId");
+    assertUint64(input.claim.horizonSec, "horizonSec");
+    assertUint64(input.claim.submittedAt, "submittedAt");
+    if (input.claim.nonce < 0n) {
+        throw new Error("nonce must be non-negative");
+    }
+    const claim = canonicalAllocationClaim(input.claim);
+    if (claim.targetWeights.length === 0) {
+        throw new Error("targetWeights must not be empty");
+    }
+    claim.targetWeights.forEach((weight, idx) => {
+        if (weight < 0n) {
+            throw new Error(`targetWeights[${idx}] must be non-negative`);
+        }
+    });
+    assertWeightsSumPositive(claim.targetWeights);
     return {
-        payload,
-        epochId: input.epochId,
-        claimHash: hash
+        claim,
+        claimHash: allocationClaimHash(claim)
     };
 }
 export function buildIntentConstraints(input) {
@@ -56,7 +73,7 @@ export function buildCanonicalIntentRecord(input) {
         constraints
     };
 }
-export function buildCanonicalSnapshotRecord(input) {
+export function buildEpochStateRecord(input) {
     assertUint64(input.epochId, "epochId");
     if (input.claimHashes.length === 0) {
         throw new Error("claimHashes must not be empty");
@@ -64,7 +81,7 @@ export function buildCanonicalSnapshotRecord(input) {
     const hash = snapshotHashFromUnordered(input.epochId, input.claimHashes);
     return {
         epochId: input.epochId,
-        snapshotHash: hash
+        epochStateHash: hash
     };
 }
 export function buildIntentAllowlistHashFromRoute(route) {

package/dist/types.d.ts

@@ -1,18 +1,14 @@
 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 AllocationClaimV1 {
+    claimVersion: "v1";
+    fundId: string;
+    epochId: bigint;
+    participant: Address;
+    targetWeights: bigint[];
+    horizonSec: bigint;
+    nonce: bigint;
+    submittedAt: bigint;
 }
 export interface TradeIntent {
     intentVersion: string;
@@ -38,16 +34,12 @@ export interface ProtocolScope {
     roomId: string;
     epochId: bigint;
 }
-export type SubjectType = "CLAIM" | "INTENT";
+export type SubjectType = "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;
 }
@@ -94,9 +86,8 @@ export interface CoreExecutionRequestInput {
     adapter: Address;
     adapterData: Hex;
 }
-export interface CanonicalClaimRecord {
-    payload: ClaimPayload;
-    epochId: bigint;
+export interface CanonicalAllocationClaimRecord {
+    claim: AllocationClaimV1;
     claimHash: Hex;
 }
 export interface CanonicalIntentRecord {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wiimdy/openfunderse-sdk",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Canonical hashing and EIP-712 helpers for Claw protocol components.",
   "license": "MIT",
   "type": "module",
@@ -17,11 +17,13 @@
     "README.md"
   ],
   "scripts": {
+    "prebuild": "npm run clean",
     "build": "tsc -p tsconfig.json",
     "clean": "rm -rf dist",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "npm run build && node --test test/**/*.test.mjs",
-    "intent:compute:nadfun": "npm run build && node scripts/compute-nadfun-intent.mjs"
+    "intent:compute:nadfun": "npm run build && node scripts/compute-nadfun-intent.mjs",
+    "prepublishOnly": "npm run build"
   },
   "dependencies": {
     "viem": "^2.38.2"

package/dist/dist_bak_vercel_repro/attestation-verifier.d.ts

@@ -1,11 +0,0 @@
-import { type ClaimAttestationMessage, type IntentAttestationMessage } from "./eip712.js";
-import type { Eip712DomainInput, Hex } from "./types.js";
-export interface VerificationResult {
-    ok: boolean;
-    digest?: Hex;
-    recovered?: `0x${string}`;
-    error?: string;
-}
-export declare function verifyClaimAttestationEnvelope(domain: Eip712DomainInput, message: ClaimAttestationMessage, signature: Hex): Promise<VerificationResult>;
-export declare function verifyIntentAttestationEnvelope(domain: Eip712DomainInput, message: IntentAttestationMessage, signature: Hex): Promise<VerificationResult>;
-export declare function reachedThreshold(validCount: number, threshold: number): boolean;

package/dist/dist_bak_vercel_repro/attestation-verifier.js

@@ -1,60 +0,0 @@
-import { claimAttestationDigest, intentAttestationDigest, recoverClaimAttester, recoverIntentAttester } from "./eip712.js";
-import { assertNotExpired } from "./attestation.js";
-async function verifyEnvelope(verifier, computeDigest, recoverAddress) {
-    try {
-        const digest = computeDigest();
-        const recovered = await recoverAddress();
-        if (recovered.toLowerCase() !== verifier.toLowerCase()) {
-            return {
-                ok: false,
-                digest,
-                recovered,
-                error: "signature does not recover claimed verifier"
-            };
-        }
-        return {
-            ok: true,
-            digest,
-            recovered
-        };
-    }
-    catch (error) {
-        return {
-            ok: false,
-            error: error instanceof Error ? error.message : String(error)
-        };
-    }
-}
-export async function verifyClaimAttestationEnvelope(domain, message, signature) {
-    try {
-        assertNotExpired(message.expiresAt);
-    }
-    catch (error) {
-        return {
-            ok: false,
-            error: error instanceof Error ? error.message : String(error)
-        };
-    }
-    return verifyEnvelope(message.verifier, () => claimAttestationDigest(domain, message), () => recoverClaimAttester(domain, message, signature));
-}
-export async function verifyIntentAttestationEnvelope(domain, message, signature) {
-    try {
-        assertNotExpired(message.expiresAt);
-    }
-    catch (error) {
-        return {
-            ok: false,
-            error: error instanceof Error ? error.message : String(error)
-        };
-    }
-    return verifyEnvelope(message.verifier, () => intentAttestationDigest(domain, message), () => recoverIntentAttester(domain, message, signature));
-}
-export function reachedThreshold(validCount, threshold) {
-    if (!Number.isInteger(validCount) || validCount < 0) {
-        throw new Error("validCount must be a non-negative integer");
-    }
-    if (!Number.isInteger(threshold) || threshold <= 0) {
-        throw new Error("threshold must be a positive integer");
-    }
-    return validCount >= threshold;
-}

package/dist/dist_bak_vercel_repro/attestation.d.ts

@@ -1,4 +0,0 @@
-export declare function unixNow(): bigint;
-export declare function isExpired(expiresAt: bigint, now?: bigint): boolean;
-export declare function assertNotExpired(expiresAt: bigint, now?: bigint): void;
-export declare function assertNonceStrictlyIncreases(lastNonce: bigint | null, incomingNonce: bigint): void;

package/dist/dist_bak_vercel_repro/attestation.js

@@ -1,16 +0,0 @@
-export function unixNow() {
-    return BigInt(Math.floor(Date.now() / 1000));
-}
-export function isExpired(expiresAt, now = unixNow()) {
-    return expiresAt <= now;
-}
-export function assertNotExpired(expiresAt, now = unixNow()) {
-    if (isExpired(expiresAt, now)) {
-        throw new Error(`signature expired: expiresAt=${expiresAt.toString(10)}, now=${now.toString(10)}`);
-    }
-}
-export function assertNonceStrictlyIncreases(lastNonce, incomingNonce) {
-    if (lastNonce !== null && incomingNonce <= lastNonce) {
-        throw new Error(`nonce must strictly increase: last=${lastNonce.toString(10)}, incoming=${incomingNonce.toString(10)}`);
-    }
-}

package/dist/dist_bak_vercel_repro/canonical.d.ts

@@ -1,3 +0,0 @@
-import type { ClaimPayload, TradeIntent } from "./types.js";
-export declare function canonicalClaim(input: ClaimPayload): ClaimPayload;
-export declare function canonicalIntent(input: TradeIntent): TradeIntent;

package/dist/dist_bak_vercel_repro/canonical.js

@@ -1,37 +0,0 @@
-import { getAddress } from "viem";
-function normalizeText(value) {
-    return value.normalize("NFC").trim();
-}
-function normalizeAddress(value) {
-    return getAddress(value);
-}
-export function canonicalClaim(input) {
-    return {
-        ...input,
-        schemaId: normalizeText(input.schemaId),
-        sourceType: normalizeText(input.sourceType),
-        sourceRef: normalizeText(input.sourceRef),
-        selector: normalizeText(input.selector),
-        extracted: normalizeText(input.extracted),
-        extractedType: normalizeText(input.extractedType),
-        evidenceType: normalizeText(input.evidenceType),
-        evidenceURI: normalizeText(input.evidenceURI),
-        crawler: normalizeAddress(input.crawler),
-        notes: input.notes === undefined ? undefined : normalizeText(input.notes)
-    };
-}
-export function canonicalIntent(input) {
-    const normalizedAction = normalizeText(input.action).toUpperCase();
-    if (normalizedAction !== "BUY" && normalizedAction !== "SELL") {
-        throw new Error(`invalid action: ${input.action}`);
-    }
-    return {
-        ...input,
-        intentVersion: normalizeText(input.intentVersion),
-        vault: normalizeAddress(input.vault),
-        action: normalizedAction,
-        tokenIn: normalizeAddress(input.tokenIn),
-        tokenOut: normalizeAddress(input.tokenOut),
-        reason: input.reason === undefined ? undefined : normalizeText(input.reason)
-    };
-}