@wiimdy/openfunderse-sdk 0.1.1

package/README.md

@@ -0,0 +1,43 @@
+# @claw/protocol-sdk
+
+Claw의 공통 프로토콜 SDK (최소 범위):
+
+## Role
+- 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 유틸
+- intent execution route 해시 유틸 (`intentExecutionAllowlistHash`, `intentExecutionCallHash`)
+- NadFun adapter 실행데이터 인코딩/디코딩 (`encodeNadfunExecutionDataV1`)
+
+## 목적
+
+다른 서비스(릴레이어/봇/프론트/컨트랙트 테스트)가 **동일한 intent 규격과 해시 규칙**을 공유하도록 강제.
+
+## 설치
+
+```bash
+npm install @claw/protocol-sdk
+```
+
+## 로컬 개발
+
+```bash
+cd /Users/ham-yunsig/Documents/github/claw-validation-market/packages/sdk
+npm install
+npm test
+```
+
+## 핵심 사용 예
+
+```ts
+import {
+  intentHash,
+  intentExecutionCallHash,
+  encodeNadfunExecutionDataV1,
+  intentAttestationTypedData,
+  verifyIntentAttestation
+} from "@claw/protocol-sdk";
+```

package/dist/attestation-verifier.d.ts

@@ -0,0 +1,11 @@
+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/attestation-verifier.js

@@ -0,0 +1,60 @@
+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/attestation.d.ts

@@ -0,0 +1,4 @@
+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/attestation.js

@@ -0,0 +1,16 @@
+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/canonical.d.ts

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

package/dist/canonical.js

@@ -0,0 +1,37 @@
+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)
+    };
+}

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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,37 @@
+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)
+    };
+}

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

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