@iam-protocol/pulse-sdk 0.1.0

package/src/submit/relayer.ts

@@ -0,0 +1,58 @@
+import type { SolanaProof } from "../proof/types";
+import type { SubmissionResult } from "./types";
+
+/**
+ * Submit a proof via the IAM relayer API (walletless mode).
+ * The relayer submits the on-chain transaction using the integrator's funded account.
+ * The user needs no wallet, no SOL, no crypto knowledge.
+ *
+ * In Phase 3, the relayer endpoint is configurable (stub until executor-node in Phase 4).
+ */
+export async function submitViaRelayer(
+  proof: SolanaProof,
+  commitment: Uint8Array,
+  options: {
+    relayerUrl: string;
+    apiKey?: string;
+    isFirstVerification: boolean;
+  }
+): Promise<SubmissionResult> {
+  try {
+    const body = {
+      proof_bytes: Array.from(proof.proofBytes),
+      public_inputs: proof.publicInputs.map((pi) => Array.from(pi)),
+      commitment: Array.from(commitment),
+      is_first_verification: options.isFirstVerification,
+    };
+
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+    };
+
+    if (options.apiKey) {
+      headers["X-API-Key"] = options.apiKey;
+    }
+
+    const response = await fetch(options.relayerUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return { success: false, error: `Relayer error: ${response.status} ${errorText}` };
+    }
+
+    const result = (await response.json()) as {
+      success?: boolean;
+      tx_signature?: string;
+    };
+    return {
+      success: result.success ?? true,
+      txSignature: result.tx_signature,
+    };
+  } catch (err: any) {
+    return { success: false, error: err.message ?? String(err) };
+  }
+}

package/src/submit/types.ts

@@ -0,0 +1,15 @@
+/** Result of a verification submission */
+export interface SubmissionResult {
+  success: boolean;
+  txSignature?: string;
+  error?: string;
+}
+
+/** Result of a full Pulse verification */
+export interface VerificationResult {
+  success: boolean;
+  commitment: Uint8Array;
+  txSignature?: string;
+  isFirstVerification: boolean;
+  error?: string;
+}

package/src/submit/wallet.ts

@@ -0,0 +1,167 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// Anchor program interactions use runtime IDL fetching, requiring dynamic typing.
+import type { SolanaProof } from "../proof/types";
+import type { SubmissionResult } from "./types";
+import { PROGRAM_IDS } from "../config";
+
+/**
+ * Submit a proof on-chain via a connected wallet (wallet-connected mode).
+ * Uses Anchor SDK to construct and send the transaction.
+ *
+ * Flow: create_challenge → verify_proof → update_anchor (or mint_anchor for first time)
+ */
+export async function submitViaWallet(
+  proof: SolanaProof,
+  commitment: Uint8Array,
+  options: {
+    wallet: any; // WalletAdapter
+    connection: any; // Connection
+    isFirstVerification: boolean;
+    trustScore?: number;
+  }
+): Promise<SubmissionResult> {
+  try {
+    const anchor = await import("@coral-xyz/anchor");
+    const { PublicKey, SystemProgram } = await import("@solana/web3.js");
+
+    const provider = new anchor.AnchorProvider(
+      options.connection,
+      options.wallet,
+      { commitment: "confirmed" }
+    );
+
+    const verifierProgramId = new PublicKey(PROGRAM_IDS.iamVerifier);
+    const anchorProgramId = new PublicKey(PROGRAM_IDS.iamAnchor);
+
+    // Generate nonce for challenge
+    const nonce = Array.from(crypto.getRandomValues(new Uint8Array(32)));
+
+    // Derive PDAs
+    const [challengePda] = PublicKey.findProgramAddressSync(
+      [
+        Buffer.from("challenge"),
+        provider.wallet.publicKey.toBuffer(),
+        Buffer.from(nonce),
+      ],
+      verifierProgramId
+    );
+
+    const [verificationPda] = PublicKey.findProgramAddressSync(
+      [
+        Buffer.from("verification"),
+        provider.wallet.publicKey.toBuffer(),
+        Buffer.from(nonce),
+      ],
+      verifierProgramId
+    );
+
+    // Build and send create_challenge + verify_proof transactions
+    // These use the raw Anchor program interface
+    const verifierIdl = await anchor.Program.fetchIdl(
+      verifierProgramId,
+      provider
+    );
+    if (!verifierIdl) {
+      return { success: false, error: "Failed to fetch verifier IDL" };
+    }
+
+    const verifierProgram: any = new anchor.Program(
+      verifierIdl,
+      provider
+    );
+
+    // 1. Create challenge
+    await verifierProgram.methods
+      .createChallenge(nonce)
+      .accounts({
+        challenger: provider.wallet.publicKey,
+        challenge: challengePda,
+        systemProgram: SystemProgram.programId,
+      })
+      .rpc();
+
+    // 2. Verify proof
+    const txSig = await verifierProgram.methods
+      .verifyProof(
+        Buffer.from(proof.proofBytes),
+        proof.publicInputs.map((pi) => Array.from(pi)),
+        nonce
+      )
+      .accounts({
+        verifier: provider.wallet.publicKey,
+        challenge: challengePda,
+        verificationResult: verificationPda,
+        systemProgram: SystemProgram.programId,
+      })
+      .rpc();
+
+    // 3. Mint or update anchor
+    const anchorIdl = await anchor.Program.fetchIdl(anchorProgramId, provider);
+    if (anchorIdl) {
+      const anchorProgram: any = new anchor.Program(anchorIdl, provider);
+
+      if (options.isFirstVerification) {
+        const [identityPda] = PublicKey.findProgramAddressSync(
+          [Buffer.from("identity"), provider.wallet.publicKey.toBuffer()],
+          anchorProgramId
+        );
+        const [mintPda] = PublicKey.findProgramAddressSync(
+          [Buffer.from("mint"), provider.wallet.publicKey.toBuffer()],
+          anchorProgramId
+        );
+        const [mintAuthority] = PublicKey.findProgramAddressSync(
+          [Buffer.from("mint_authority")],
+          anchorProgramId
+        );
+
+        // Token-2022 program ID
+        const TOKEN_2022_PROGRAM_ID = new PublicKey(
+          "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+        );
+
+        const { getAssociatedTokenAddressSync } = await import(
+          "@solana/spl-token"
+        );
+        const ata = getAssociatedTokenAddressSync(
+          mintPda,
+          provider.wallet.publicKey,
+          false,
+          TOKEN_2022_PROGRAM_ID
+        );
+
+        await anchorProgram.methods
+          .mintAnchor(Array.from(commitment))
+          .accounts({
+            user: provider.wallet.publicKey,
+            identityState: identityPda,
+            mint: mintPda,
+            mintAuthority,
+            tokenAccount: ata,
+            associatedTokenProgram: new PublicKey(
+              "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+            ),
+            tokenProgram: TOKEN_2022_PROGRAM_ID,
+            systemProgram: SystemProgram.programId,
+          })
+          .rpc();
+      } else {
+        const [identityPda] = PublicKey.findProgramAddressSync(
+          [Buffer.from("identity"), provider.wallet.publicKey.toBuffer()],
+          anchorProgramId
+        );
+
+        await anchorProgram.methods
+          .updateAnchor(Array.from(commitment), options.trustScore ?? 0)
+          .accounts({
+            authority: provider.wallet.publicKey,
+            identityState: identityPda,
+          })
+          .rpc();
+      }
+    }
+
+    return { success: true, txSignature: txSig };
+  } catch (err: any) {
+    return { success: false, error: err.message ?? String(err) };
+  }
+}

package/src/types.d.ts

@@ -0,0 +1,14 @@
+declare module "snarkjs" {
+  export const groth16: {
+    fullProve(
+      input: any,
+      wasmPath: string,
+      zkeyPath: string
+    ): Promise<{ proof: any; publicSignals: string[] }>;
+    verify(vk: any, publicSignals: string[], proof: any): Promise<boolean>;
+  };
+}
+
+declare module "circomlibjs" {
+  export function buildPoseidon(): Promise<any>;
+}

package/test/integration.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect } from "vitest";
+import * as path from "path";
+import * as fs from "fs";
+import { simhash, hammingDistance } from "../src/hashing/simhash";
+import { generateTBH, computeCommitment } from "../src/hashing/poseidon";
+import { prepareCircuitInput, generateProof } from "../src/proof/prover";
+import { serializeProof } from "../src/proof/serializer";
+import { TOTAL_PROOF_SIZE, NUM_PUBLIC_INPUTS } from "../src/config";
+
+// Circuit artifacts from adjacent circuits repo
+const WASM_PATH = path.resolve(
+  __dirname,
+  "../../circuits/build/iam_hamming_js/iam_hamming.wasm"
+);
+const ZKEY_PATH = path.resolve(
+  __dirname,
+  "../../circuits/build/iam_hamming_final.zkey"
+);
+const VK_PATH = path.resolve(
+  __dirname,
+  "../../circuits/keys/verification_key.json"
+);
+
+// Skip tests if circuit artifacts aren't built
+const circuitArtifactsExist =
+  fs.existsSync(WASM_PATH) && fs.existsSync(ZKEY_PATH) && fs.existsSync(VK_PATH);
+
+describe.skipIf(!circuitArtifactsExist)(
+  "integration: full crypto pipeline",
+  () => {
+    it("generates a valid proof from mock features end-to-end", async () => {
+      // 1. Create mock feature vector (~236 random values)
+      const features = Array.from({ length: 236 }, (_, i) =>
+        Math.sin(i * 0.3) * Math.cos(i * 0.7)
+      );
+
+      // 2. SimHash → 256-bit fingerprint
+      const fpNew = simhash(features);
+      expect(fpNew.length).toBe(256);
+
+      // 3. Create "previous" fingerprint by flipping 10 bits
+      const fpPrev = [...fpNew];
+      for (let i = 0; i < 10; i++) {
+        fpPrev[i * 25] = fpPrev[i * 25] === 1 ? 0 : 1;
+      }
+      expect(hammingDistance(fpNew, fpPrev)).toBe(10);
+
+      // 4. Generate TBHs with Poseidon commitments
+      const tbhNew = await generateTBH(fpNew);
+      const tbhPrev = await generateTBH(fpPrev);
+
+      expect(tbhNew.commitment).toBeGreaterThan(BigInt(0));
+      expect(tbhPrev.commitment).toBeGreaterThan(BigInt(0));
+
+      // 5. Prepare circuit input
+      const input = prepareCircuitInput(tbhNew, tbhPrev, 30);
+      expect(input.ft_new.length).toBe(256);
+      expect(input.threshold).toBe("30");
+
+      // 6. Generate Groth16 proof
+      const { proof, publicSignals } = await generateProof(
+        input,
+        WASM_PATH,
+        ZKEY_PATH
+      );
+      expect(publicSignals.length).toBe(NUM_PUBLIC_INPUTS);
+
+      // 7. Serialize for Solana
+      const { proofBytes, publicInputs } = serializeProof(
+        proof,
+        publicSignals
+      );
+      expect(proofBytes.length).toBe(TOTAL_PROOF_SIZE);
+      expect(publicInputs.length).toBe(NUM_PUBLIC_INPUTS);
+      for (const input of publicInputs) {
+        expect(input.length).toBe(32);
+      }
+
+      // 8. Verify locally
+      const snarkjs = await import("snarkjs");
+      const vk = JSON.parse(fs.readFileSync(VK_PATH, "utf-8"));
+      const valid = await snarkjs.groth16.verify(vk, publicSignals, proof);
+      expect(valid).toBe(true);
+    });
+
+    it("fails proof generation when distance exceeds threshold", async () => {
+      // Create fingerprints with ~200 bits different
+      const fpNew = Array.from({ length: 256 }, () =>
+        Math.random() > 0.5 ? 1 : 0
+      );
+      const fpPrev = fpNew.map((b) => (Math.random() > 0.2 ? 1 - b : b));
+
+      const tbhNew = await generateTBH(fpNew);
+      const tbhPrev = await generateTBH(fpPrev);
+      const input = prepareCircuitInput(tbhNew, tbhPrev, 30);
+
+      await expect(
+        generateProof(input, WASM_PATH, ZKEY_PATH)
+      ).rejects.toThrow();
+    });
+  }
+);

package/test/poseidon.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect } from "vitest";
+import {
+  computeCommitment,
+  generateSalt,
+  packBits,
+  bigintToBytes32,
+  generateTBH,
+} from "../src/hashing/poseidon";
+import { FINGERPRINT_BITS } from "../src/config";
+
+describe("poseidon", () => {
+  const testFingerprint = Array.from({ length: FINGERPRINT_BITS }, (_, i) =>
+    i % 3 === 0 ? 1 : 0
+  );
+  const testSalt = BigInt("12345678901234567890");
+
+  it("packs bits into two 128-bit field elements (little-endian)", () => {
+    const bits = new Array(FINGERPRINT_BITS).fill(0);
+    bits[0] = 1; // bit 0 → lo = 1
+    bits[128] = 1; // bit 128 → hi = 1
+
+    const { lo, hi } = packBits(bits);
+    expect(lo).toBe(BigInt(1));
+    expect(hi).toBe(BigInt(1));
+  });
+
+  it("packs complex bit patterns correctly", () => {
+    const bits = new Array(FINGERPRINT_BITS).fill(0);
+    bits[0] = 1;
+    bits[1] = 1;
+    bits[7] = 1;
+    // lo should be 1 + 2 + 128 = 131
+    const { lo } = packBits(bits);
+    expect(lo).toBe(BigInt(131));
+  });
+
+  it("computes deterministic commitment", async () => {
+    const c1 = await computeCommitment(testFingerprint, testSalt);
+    const c2 = await computeCommitment(testFingerprint, testSalt);
+    expect(c1).toBe(c2);
+  });
+
+  it("different salts produce different commitments", async () => {
+    const c1 = await computeCommitment(testFingerprint, testSalt);
+    const c2 = await computeCommitment(testFingerprint, testSalt + BigInt(1));
+    expect(c1).not.toBe(c2);
+  });
+
+  it("different fingerprints produce different commitments", async () => {
+    const fp2 = [...testFingerprint];
+    fp2[0] = fp2[0] === 1 ? 0 : 1;
+    const c1 = await computeCommitment(testFingerprint, testSalt);
+    const c2 = await computeCommitment(fp2, testSalt);
+    expect(c1).not.toBe(c2);
+  });
+
+  it("generates salt within BN254 scalar field", () => {
+    const salt = generateSalt();
+    expect(salt).toBeGreaterThan(BigInt(0));
+    expect(salt).toBeLessThan(
+      BigInt(
+        "21888242871839275222246405745257275088548364400416034343698204186575808495617"
+      )
+    );
+  });
+
+  it("converts bigint to 32-byte big-endian", () => {
+    const bytes = bigintToBytes32(BigInt(256));
+    expect(bytes[30]).toBe(1);
+    expect(bytes[31]).toBe(0);
+    expect(bytes.length).toBe(32);
+  });
+
+  it("generates complete TBH", async () => {
+    const tbh = await generateTBH(testFingerprint);
+    expect(tbh.fingerprint).toEqual(testFingerprint);
+    expect(tbh.salt).toBeGreaterThan(BigInt(0));
+    expect(tbh.commitment).toBeGreaterThan(BigInt(0));
+    expect(tbh.commitmentBytes.length).toBe(32);
+  });
+});

package/test/serializer.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect } from "vitest";
+import { serializeProof, toBigEndian32 } from "../src/proof/serializer";
+import { TOTAL_PROOF_SIZE, NUM_PUBLIC_INPUTS, BN254_BASE_FIELD } from "../src/config";
+
+// Mock proof matching snarkjs output format
+const mockProof = {
+  pi_a: [
+    "12345678901234567890123456789012345678901234567890",
+    "98765432109876543210987654321098765432109876543210",
+    "1",
+  ],
+  pi_b: [
+    [
+      "11111111111111111111111111111111111111111111111111",
+      "22222222222222222222222222222222222222222222222222",
+    ],
+    [
+      "33333333333333333333333333333333333333333333333333",
+      "44444444444444444444444444444444444444444444444444",
+    ],
+  ],
+  pi_c: [
+    "55555555555555555555555555555555555555555555555555",
+    "66666666666666666666666666666666666666666666666666",
+  ],
+  protocol: "groth16",
+  curve: "bn128",
+};
+
+const mockPublicSignals = [
+  "111111111111111111111",
+  "222222222222222222222",
+  "30",
+];
+
+describe("serializer", () => {
+  it("toBigEndian32 converts decimal string to 32 bytes", () => {
+    const bytes = toBigEndian32("256");
+    expect(bytes.length).toBe(32);
+    expect(bytes[30]).toBe(1);
+    expect(bytes[31]).toBe(0);
+  });
+
+  it("toBigEndian32 handles zero", () => {
+    const bytes = toBigEndian32("0");
+    expect(bytes.every((b) => b === 0)).toBe(true);
+  });
+
+  it("produces 256-byte proof output", () => {
+    const { proofBytes } = serializeProof(mockProof as any, mockPublicSignals);
+    expect(proofBytes.length).toBe(TOTAL_PROOF_SIZE);
+  });
+
+  it("produces correct number of public inputs", () => {
+    const { publicInputs } = serializeProof(mockProof as any, mockPublicSignals);
+    expect(publicInputs.length).toBe(NUM_PUBLIC_INPUTS);
+    for (const input of publicInputs) {
+      expect(input.length).toBe(32);
+    }
+  });
+
+  it("negates proof_a y-coordinate", () => {
+    const { proofBytes } = serializeProof(mockProof as any, mockPublicSignals);
+
+    // Extract the y-coordinate from proof_a (bytes 32-63)
+    let yFromProof = BigInt(0);
+    for (let i = 32; i < 64; i++) {
+      yFromProof = (yFromProof << BigInt(8)) + BigInt(proofBytes[i]!);
+    }
+
+    // The original y
+    const yOriginal = BigInt(mockProof.pi_a[1]!);
+    const yExpected = (BN254_BASE_FIELD - yOriginal) % BN254_BASE_FIELD;
+
+    expect(yFromProof).toBe(yExpected);
+  });
+
+  it("reverses G2 coordinate ordering in proof_b", () => {
+    const { proofBytes } = serializeProof(mockProof as any, mockPublicSignals);
+
+    // First 32 bytes of proof_b should be pi_b[0][1] (c1), not pi_b[0][0] (c0)
+    const expectedFirst = toBigEndian32(mockProof.pi_b[0]![1]!);
+    const actualFirst = proofBytes.slice(64, 96);
+    expect(Array.from(actualFirst)).toEqual(Array.from(expectedFirst));
+  });
+});

package/test/simhash.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from "vitest";
+import { simhash, hammingDistance } from "../src/hashing/simhash";
+import { FINGERPRINT_BITS } from "../src/config";
+
+describe("simhash", () => {
+  const featureA = Array.from({ length: 100 }, (_, i) => Math.sin(i * 0.1));
+
+  it("produces a 256-bit binary fingerprint", () => {
+    const fp = simhash(featureA);
+    expect(fp.length).toBe(FINGERPRINT_BITS);
+    for (const bit of fp) {
+      expect(bit === 0 || bit === 1).toBe(true);
+    }
+  });
+
+  it("is deterministic", () => {
+    const fp1 = simhash(featureA);
+    const fp2 = simhash(featureA);
+    expect(fp1).toEqual(fp2);
+  });
+
+  it("similar vectors produce low Hamming distance", () => {
+    // Slightly perturbed version of featureA
+    const featureB = featureA.map((v) => v + (Math.random() - 0.5) * 0.01);
+    const fpA = simhash(featureA);
+    const fpB = simhash(featureB);
+    const dist = hammingDistance(fpA, fpB);
+    // Small perturbation should produce distance well below 128 (random chance)
+    expect(dist).toBeLessThan(64);
+  });
+
+  it("dissimilar vectors produce high Hamming distance", () => {
+    const featureC = Array.from({ length: 100 }, (_, i) => -Math.cos(i * 3.7));
+    const fpA = simhash(featureA);
+    const fpC = simhash(featureC);
+    const dist = hammingDistance(fpA, fpC);
+    // Different vectors should have distance closer to 128 (random)
+    expect(dist).toBeGreaterThan(50);
+  });
+
+  it("empty feature vector returns all zeros", () => {
+    const fp = simhash([]);
+    expect(fp.length).toBe(FINGERPRINT_BITS);
+    expect(fp.every((b) => b === 0)).toBe(true);
+  });
+
+  it("hamming distance is symmetric", () => {
+    const fpA = simhash(featureA);
+    const fpB = simhash(featureA.map((v) => v + 0.5));
+    expect(hammingDistance(fpA, fpB)).toBe(hammingDistance(fpB, fpA));
+  });
+
+  it("hamming distance of identical fingerprints is zero", () => {
+    const fp = simhash(featureA);
+    expect(hammingDistance(fp, fp)).toBe(0);
+  });
+});

package/test/statistics.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect } from "vitest";
+import { mean, variance, skewness, kurtosis, condense } from "../src/extraction/statistics";
+
+describe("statistics", () => {
+  it("computes mean correctly", () => {
+    expect(mean([1, 2, 3, 4, 5])).toBe(3);
+    expect(mean([10])).toBe(10);
+    expect(mean([])).toBe(0);
+  });
+
+  it("computes variance correctly", () => {
+    // Sample variance of [2, 4, 4, 4, 5, 5, 7, 9]
+    const v = variance([2, 4, 4, 4, 5, 5, 7, 9]);
+    expect(v).toBeCloseTo(4.571, 2);
+  });
+
+  it("returns zero variance for constant array", () => {
+    expect(variance([5, 5, 5, 5])).toBe(0);
+  });
+
+  it("computes skewness correctly", () => {
+    // Symmetric distribution has ~0 skewness
+    const s = skewness([1, 2, 3, 4, 5]);
+    expect(Math.abs(s)).toBeLessThan(0.01);
+  });
+
+  it("computes positive skewness for right-skewed data", () => {
+    const s = skewness([1, 1, 1, 1, 1, 1, 1, 10]);
+    expect(s).toBeGreaterThan(0);
+  });
+
+  it("computes kurtosis for normal-like data", () => {
+    // Excess kurtosis near 0 for normal-like data
+    const k = kurtosis([2, 3, 4, 4, 5, 5, 5, 6, 6, 7, 7, 8]);
+    expect(Math.abs(k)).toBeLessThan(2);
+  });
+
+  it("condense returns all four stats", () => {
+    const result = condense([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+    expect(result.mean).toBeCloseTo(5.5);
+    expect(result.variance).toBeGreaterThan(0);
+    expect(typeof result.skewness).toBe("number");
+    expect(typeof result.kurtosis).toBe("number");
+  });
+
+  it("handles edge cases", () => {
+    expect(variance([1])).toBe(0);
+    expect(skewness([1, 2])).toBe(0);
+    expect(kurtosis([1, 2, 3])).toBe(0);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2020", "DOM"],
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitReturns": true,
+    "forceConsistentCasingInFileNames": true,
+    "esModuleInterop": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "test"]
+}

package/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["esm", "cjs"],
+  dts: true,
+  splitting: false,
+  sourcemap: true,
+  clean: true,
+});

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    testTimeout: 60000,
+  },
+});