@thru/thru-sdk 0.1.19 → 0.1.21

package/thru-ts-client-sdk/modules/__tests__/blocks.test.ts

@@ -1,199 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createMockBlock, createMockContext, createMockListBlocksResponse } from "../../__tests__/helpers/test-utils";
-import { ConsensusStatus } from "../../proto/thru/common/v1/consensus_pb";
-import { BlockView } from "../../proto/thru/core/v1/block_pb";
-import { getBlock, getRawBlock, listBlocks } from "../blocks";
-
-describe("blocks", () => {
-  describe("getBlock", () => {
-    it("should get block by slot (number)", async () => {
-      const ctx = createMockContext();
-      const mockBlock = createMockBlock({ header: { slot: 1000n } });
-      vi.spyOn(ctx.query, "getBlock").mockResolvedValue(mockBlock);
-      
-      const result = await getBlock(ctx, { slot: 1000 });
-      
-      expect(result).toBe(mockBlock);
-      expect(ctx.query.getBlock).toHaveBeenCalledTimes(1);
-      const callArgs = (ctx.query.getBlock as any).mock.calls[0][0];
-      expect(callArgs.selector.case).toBe("slot");
-      expect(callArgs.selector.value).toBe(1000n);
-    });
-
-    it("should get block by slot (bigint)", async () => {
-      const ctx = createMockContext();
-      const mockBlock = createMockBlock({ header: { slot: 1000n } });
-      vi.spyOn(ctx.query, "getBlock").mockResolvedValue(mockBlock);
-      
-      const result = await getBlock(ctx, { slot: 1000n });
-      
-      expect(result).toBe(mockBlock);
-      const callArgs = (ctx.query.getBlock as any).mock.calls[0][0];
-      expect(callArgs.selector.case).toBe("slot");
-      expect(callArgs.selector.value).toBe(1000n);
-    });
-
-    it("should get block by blockHash", async () => {
-      const ctx = createMockContext();
-      const mockBlock = createMockBlock();
-      const blockHash = new Uint8Array(32);
-      blockHash.fill(0x42);
-      vi.spyOn(ctx.query, "getBlock").mockResolvedValue(mockBlock);
-      
-      const result = await getBlock(ctx, { blockHash });
-      
-      expect(result).toBe(mockBlock);
-      const callArgs = (ctx.query.getBlock as any).mock.calls[0][0];
-      expect(callArgs.selector.case).toBe("blockHash");
-      expect(callArgs.selector.value.value).toEqual(blockHash);
-    });
-
-    it("should use default view when not provided", async () => {
-      const ctx = createMockContext();
-      const mockBlock = createMockBlock();
-      vi.spyOn(ctx.query, "getBlock").mockResolvedValue(mockBlock);
-      
-      await getBlock(ctx, { slot: 1000 });
-      
-      const callArgs = (ctx.query.getBlock as any).mock.calls[0][0];
-      expect(callArgs.view).toBe(BlockView.FULL);
-    });
-
-    it("should use custom view when provided", async () => {
-      const ctx = createMockContext();
-      const mockBlock = createMockBlock();
-      vi.spyOn(ctx.query, "getBlock").mockResolvedValue(mockBlock);
-      
-      await getBlock(ctx, { slot: 1000 }, { view: BlockView.HEADER_ONLY });
-      
-      const callArgs = (ctx.query.getBlock as any).mock.calls[0][0];
-      expect(callArgs.view).toBe(BlockView.HEADER_ONLY);
-    });
-
-    it("should use default minConsensus when not provided", async () => {
-      const ctx = createMockContext();
-      const mockBlock = createMockBlock();
-      vi.spyOn(ctx.query, "getBlock").mockResolvedValue(mockBlock);
-      
-      await getBlock(ctx, { slot: 1000 });
-      
-      const callArgs = (ctx.query.getBlock as any).mock.calls[0][0];
-      expect(callArgs.minConsensus).toBe(ConsensusStatus.UNSPECIFIED);
-    });
-
-    it("should use custom minConsensus when provided", async () => {
-      const ctx = createMockContext();
-      const mockBlock = createMockBlock();
-      vi.spyOn(ctx.query, "getBlock").mockResolvedValue(mockBlock);
-      
-      await getBlock(ctx, { slot: 1000 }, { minConsensus: ConsensusStatus.FINALIZED });
-      
-      const callArgs = (ctx.query.getBlock as any).mock.calls[0][0];
-      expect(callArgs.minConsensus).toBe(ConsensusStatus.FINALIZED);
-    });
-  });
-
-  describe("getRawBlock", () => {
-    it("should get raw block by slot", async () => {
-      const ctx = createMockContext();
-      const mockRawBlock = { slot: 1000n, rawBlock: new Uint8Array([1, 2, 3]) };
-      vi.spyOn(ctx.query, "getRawBlock").mockResolvedValue(mockRawBlock as any);
-      
-      const result = await getRawBlock(ctx, { slot: 1000 });
-      
-      expect(result).toBe(mockRawBlock);
-      expect(ctx.query.getRawBlock).toHaveBeenCalledTimes(1);
-    });
-
-    it("should get raw block by blockHash", async () => {
-      const ctx = createMockContext();
-      const blockHash = new Uint8Array(32);
-      blockHash.fill(0x42);
-      const mockRawBlock = { slot: 1000n, rawBlock: new Uint8Array([1, 2, 3]) };
-      vi.spyOn(ctx.query, "getRawBlock").mockResolvedValue(mockRawBlock as any);
-      
-      const result = await getRawBlock(ctx, { blockHash });
-      
-      expect(result).toBe(mockRawBlock);
-      const callArgs = (ctx.query.getRawBlock as any).mock.calls[0][0];
-      expect(callArgs.selector.case).toBe("blockHash");
-    });
-
-    it("should use default minConsensus", async () => {
-      const ctx = createMockContext();
-      const mockRawBlock = { slot: 1000n, rawBlock: new Uint8Array() };
-      vi.spyOn(ctx.query, "getRawBlock").mockResolvedValue(mockRawBlock as any);
-      
-      await getRawBlock(ctx, { slot: 1000 });
-      
-      const callArgs = (ctx.query.getRawBlock as any).mock.calls[0][0];
-      expect(callArgs.minConsensus).toBe(ConsensusStatus.UNSPECIFIED);
-    });
-  });
-
-  describe("listBlocks", () => {
-    it("should list blocks with default options", async () => {
-      const ctx = createMockContext();
-      const mockResponse = createMockListBlocksResponse();
-      vi.spyOn(ctx.query, "listBlocks").mockResolvedValue(mockResponse);
-      
-      const result = await listBlocks(ctx);
-      
-      expect(result).toBe(mockResponse);
-      expect(ctx.query.listBlocks).toHaveBeenCalledTimes(1);
-      const callArgs = (ctx.query.listBlocks as any).mock.calls[0][0];
-      expect(callArgs.view).toBe(BlockView.FULL);
-      expect(callArgs.minConsensus).toBe(ConsensusStatus.UNSPECIFIED);
-    });
-
-    it("should list blocks with custom view", async () => {
-      const ctx = createMockContext();
-      const mockResponse = createMockListBlocksResponse();
-      vi.spyOn(ctx.query, "listBlocks").mockResolvedValue(mockResponse);
-      
-      await listBlocks(ctx, { view: BlockView.HEADER_ONLY });
-      
-      const callArgs = (ctx.query.listBlocks as any).mock.calls[0][0];
-      expect(callArgs.view).toBe(BlockView.HEADER_ONLY);
-    });
-
-    it("should list blocks with filter", async () => {
-      const ctx = createMockContext();
-      const mockResponse = createMockListBlocksResponse();
-      const filter = { expression: "slot > 1000" };
-      vi.spyOn(ctx.query, "listBlocks").mockResolvedValue(mockResponse);
-      
-      await listBlocks(ctx, { filter: filter as any });
-      
-      const callArgs = (ctx.query.listBlocks as any).mock.calls[0][0];
-      expect(callArgs.filter).toBeDefined();
-      expect(callArgs.filter.expression).toBe("slot > 1000");
-    });
-
-    it("should list blocks with pagination", async () => {
-      const ctx = createMockContext();
-      const mockResponse = createMockListBlocksResponse();
-      const page = { pageSize: 10, pageToken: "token" };
-      vi.spyOn(ctx.query, "listBlocks").mockResolvedValue(mockResponse);
-      
-      await listBlocks(ctx, { page: page as any });
-      
-      const callArgs = (ctx.query.listBlocks as any).mock.calls[0][0];
-      expect(callArgs.page).toBeDefined();
-      expect(callArgs.page.pageSize).toBe(10);
-      expect(callArgs.page.pageToken).toBe("token");
-    });
-
-    it("should list blocks with custom minConsensus", async () => {
-      const ctx = createMockContext();
-      const mockResponse = createMockListBlocksResponse();
-      vi.spyOn(ctx.query, "listBlocks").mockResolvedValue(mockResponse);
-      
-      await listBlocks(ctx, { minConsensus: ConsensusStatus.FINALIZED });
-      
-      const callArgs = (ctx.query.listBlocks as any).mock.calls[0][0];
-      expect(callArgs.minConsensus).toBe(ConsensusStatus.FINALIZED);
-    });
-  });
-});
-

package/thru-ts-client-sdk/modules/__tests__/events.test.ts

@@ -1,74 +0,0 @@
-import { create } from "@bufbuild/protobuf";
-import { describe, expect, it, vi } from "vitest";
-import { createMockContext } from "../../__tests__/helpers/test-utils";
-import { CurrentVersionSchema, VersionContextSchema } from "../../proto/thru/common/v1/consensus_pb";
-import { EventSchema } from "../../proto/thru/services/v1/query_service_pb";
-import { getEvent } from "../events";
-
-describe("events", () => {
-  describe("getEvent", () => {
-    it("should return event with valid eventId", async () => {
-      const ctx = createMockContext();
-      const mockEvent = create(EventSchema, {
-        eventId: "test-event-id",
-        slot: 1000n,
-      });
-      
-      vi.spyOn(ctx.query, "getEvent").mockResolvedValue(mockEvent);
-      
-      const result = await getEvent(ctx, "test-event-id");
-      
-      expect(result).toBe(mockEvent);
-      expect(result.eventId).toBe("test-event-id");
-      expect(ctx.query.getEvent).toHaveBeenCalledTimes(1);
-    });
-
-    it("should include eventId in request", async () => {
-      const ctx = createMockContext();
-      const mockEvent = create(EventSchema, { eventId: "test-event-id" });
-      vi.spyOn(ctx.query, "getEvent").mockResolvedValue(mockEvent);
-      
-      await getEvent(ctx, "test-event-id");
-      
-      const callArgs = (ctx.query.getEvent as any).mock.calls[0][0];
-      expect(callArgs.eventId).toBe("test-event-id");
-    });
-
-    it("should include version context when provided", async () => {
-      const ctx = createMockContext();
-      const mockEvent = create(EventSchema, { eventId: "test-event-id" });
-      vi.spyOn(ctx.query, "getEvent").mockResolvedValue(mockEvent);
-      
-      const versionContext = create(VersionContextSchema, {
-        version: {
-          case: "current",
-          value: create(CurrentVersionSchema, {}),
-        },
-      });
-      
-      await getEvent(ctx, "test-event-id", { versionContext });
-      
-      const callArgs = (ctx.query.getEvent as any).mock.calls[0][0];
-      expect(callArgs.versionContext).toBeDefined();
-      expect(callArgs.versionContext.version?.case).toBe("current");
-    });
-
-    it("should throw error for empty eventId", () => {
-      const ctx = createMockContext();
-      
-      expect(() => getEvent(ctx, "")).toThrow("eventId is required");
-    });
-
-    it("should not include version context when not provided", async () => {
-      const ctx = createMockContext();
-      const mockEvent = create(EventSchema, { eventId: "test-event-id" });
-      vi.spyOn(ctx.query, "getEvent").mockResolvedValue(mockEvent);
-      
-      await getEvent(ctx, "test-event-id");
-      
-      const callArgs = (ctx.query.getEvent as any).mock.calls[0][0];
-      expect(callArgs.versionContext).toBeUndefined();
-    });
-  });
-});
-

package/thru-ts-client-sdk/modules/__tests__/height.test.ts

@@ -1,39 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createMockContext, createMockHeightResponse } from "../../__tests__/helpers/test-utils";
-import { getBlockHeight } from "../height";
-
-describe("height", () => {
-  describe("getBlockHeight", () => {
-    it("should return height response", async () => {
-      const ctx = createMockContext();
-      const mockResponse = createMockHeightResponse({
-        finalized: 1000n,
-        locallyExecuted: 1001n,
-        clusterExecuted: 1002n,
-      });
-      
-      vi.spyOn(ctx.query, "getHeight").mockResolvedValue(mockResponse);
-      
-      const result = await getBlockHeight(ctx);
-      
-      expect(result).toBe(mockResponse);
-      expect(result.finalized).toBe(1000n);
-      expect(result.locallyExecuted).toBe(1001n);
-      expect(result.clusterExecuted).toBe(1002n);
-      expect(ctx.query.getHeight).toHaveBeenCalledTimes(1);
-    });
-
-    it("should create empty request", async () => {
-      const ctx = createMockContext();
-      const mockResponse = createMockHeightResponse();
-      vi.spyOn(ctx.query, "getHeight").mockResolvedValue(mockResponse);
-      
-      await getBlockHeight(ctx);
-      
-      const callArgs = (ctx.query.getHeight as any).mock.calls[0][0];
-      // Request should be created (empty GetHeightRequest)
-      expect(callArgs).toBeDefined();
-    });
-  });
-});
-

package/thru-ts-client-sdk/modules/__tests__/helpers.test.ts

@@ -1,288 +0,0 @@
-import { decodeAddress, decodeSignature } from "@thru/helpers";
-import { describe, expect, it } from "vitest";
-import { generateTestAddress, generateTestPubkey, generateTestSignature, generateTestSignatureString } from "../../__tests__/helpers/test-utils";
-import {
-    deriveProgramAddress,
-    toBlockHash,
-    toPubkey,
-    toSignature,
-} from "../helpers";
-
-describe("helpers", () => {
-  describe("toSignature", () => {
-    it("should accept Uint8Array with 64 bytes", () => {
-      const sigBytes = generateTestSignature();
-      const result = toSignature(sigBytes);
-      
-      expect(result.value).toEqual(sigBytes);
-      expect(result.value.length).toBe(64);
-    });
-
-    it("should accept ts- prefixed signature string", () => {
-      const sigString = generateTestSignatureString();
-      const result = toSignature(sigString);
-      
-      expect(result.value.length).toBe(64);
-      // Verify it decodes correctly
-      const decoded = decodeSignature(sigString);
-      expect(result.value).toEqual(decoded);
-    });
-
-    it("should accept base64 signature string", () => {
-      const sigBytes = generateTestSignature();
-      const base64 = btoa(String.fromCharCode(...sigBytes));
-      const result = toSignature(base64);
-      
-      expect(result.value.length).toBe(64);
-      expect(result.value).toEqual(sigBytes);
-    });
-
-    it("should throw error for Uint8Array with wrong length", () => {
-      const invalidSig = new Uint8Array(32); // Should be 64
-      
-      expect(() => toSignature(invalidSig)).toThrow("signature must contain 64 bytes");
-    });
-
-    it("should throw error for invalid input type", () => {
-      expect(() => toSignature(null as any)).toThrow("signature is required");
-      expect(() => toSignature(undefined as any)).toThrow("signature is required");
-    });
-  });
-
-  describe("toPubkey", () => {
-    it("should accept Uint8Array with 32 bytes", () => {
-      const pubkeyBytes = generateTestPubkey();
-      const result = toPubkey(pubkeyBytes, "testField");
-      
-      expect(result.value).toEqual(pubkeyBytes);
-      expect(result.value.length).toBe(32);
-    });
-
-    it("should accept ta- prefixed address string", () => {
-      const address = generateTestAddress();
-      const result = toPubkey(address, "testField");
-      
-      expect(result.value.length).toBe(32);
-      // Verify it decodes correctly
-      const decoded = decodeAddress(address);
-      expect(result.value).toEqual(decoded);
-    });
-
-    it("should accept base64 pubkey string", () => {
-      const pubkeyBytes = generateTestPubkey();
-      const base64 = btoa(String.fromCharCode(...pubkeyBytes));
-      const result = toPubkey(base64, "testField");
-      
-      expect(result.value.length).toBe(32);
-      expect(result.value).toEqual(pubkeyBytes);
-    });
-
-    it("should throw error for Uint8Array with wrong length", () => {
-      const invalidPubkey = new Uint8Array(64); // Should be 32
-      
-      expect(() => toPubkey(invalidPubkey, "testField")).toThrow("testField must contain 32 bytes");
-    });
-
-    it("should throw error for invalid input type", () => {
-      expect(() => toPubkey(null as any, "testField")).toThrow("testField is required");
-      expect(() => toPubkey(undefined as any, "testField")).toThrow("testField is required");
-    });
-
-    it("should include field name in error message", () => {
-      const invalidPubkey = new Uint8Array(64);
-      
-      expect(() => toPubkey(invalidPubkey, "myCustomField")).toThrow("myCustomField must contain 32 bytes");
-    });
-  });
-
-  describe("toBlockHash", () => {
-    it("should accept Uint8Array", () => {
-      const hashBytes = new Uint8Array([1, 2, 3, 4]);
-      const result = toBlockHash(hashBytes);
-      
-      expect(result.value).toEqual(hashBytes);
-    });
-
-    it("should accept base64 string", () => {
-      const hashBytes = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
-      const base64 = btoa(String.fromCharCode(...hashBytes));
-      const result = toBlockHash(base64);
-      
-      expect(result.value).toBeInstanceOf(Uint8Array);
-      expect(result.value).toEqual(hashBytes);
-    });
-
-    it("should accept hex string", () => {
-      const hashBytes = new Uint8Array([0x01, 0x02, 0x03, 0x04]);
-      const hexString = Array.from(hashBytes)
-        .map(b => b.toString(16).padStart(2, "0"))
-        .join("");
-      const result = toBlockHash(hexString);
-      
-      expect(result.value).toBeInstanceOf(Uint8Array);
-      // Note: ensureBytes may handle hex differently, so we just verify it works
-      expect(result.value.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe("deriveProgramAddress", () => {
-    it("should derive address from program address and seed (Uint8Array)", () => {
-      const programAddress = generateTestPubkey(0x01);
-      const seed = new Uint8Array([0x02, 0x03]);
-      
-      const result = deriveProgramAddress({
-        programAddress,
-        seed,
-      });
-      
-      expect(result.bytes).toBeInstanceOf(Uint8Array);
-      expect(result.bytes.length).toBe(32);
-      expect(result.address).toBeTruthy();
-      expect(result.address.startsWith("ta")).toBe(true);
-    });
-
-    it("should derive address with ephemeral flag set", () => {
-      const programAddress = generateTestPubkey(0x01);
-      const seed = new Uint8Array([0x02, 0x03]);
-      
-      const resultEphemeral = deriveProgramAddress({
-        programAddress,
-        seed,
-        ephemeral: true,
-      });
-      
-      const resultNonEphemeral = deriveProgramAddress({
-        programAddress,
-        seed,
-        ephemeral: false,
-      });
-      
-      // Ephemeral and non-ephemeral should produce different addresses
-      expect(resultEphemeral.bytes).not.toEqual(resultNonEphemeral.bytes);
-      expect(resultEphemeral.address).not.toBe(resultNonEphemeral.address);
-    });
-
-    it("should be deterministic for same inputs", () => {
-      const programAddress = generateTestPubkey(0x01);
-      const seed = new Uint8Array([0x02, 0x03]);
-      
-      const result1 = deriveProgramAddress({
-        programAddress,
-        seed,
-      });
-      
-      const result2 = deriveProgramAddress({
-        programAddress,
-        seed,
-      });
-      
-      expect(result1.bytes).toEqual(result2.bytes);
-      expect(result1.address).toBe(result2.address);
-    });
-
-    it("should accept program address as ta- prefixed string", () => {
-      const programAddress = generateTestAddress(0x01);
-      const seed = new Uint8Array([0x02, 0x03]);
-      
-      const result = deriveProgramAddress({
-        programAddress,
-        seed,
-      });
-      
-      expect(result.bytes.length).toBe(32);
-      expect(result.address).toBeTruthy();
-    });
-
-    it("should accept program address as hex string", () => {
-      const programAddressBytes = generateTestPubkey(0x01);
-      const programAddressHex = Array.from(programAddressBytes)
-        .map(b => b.toString(16).padStart(2, "0"))
-        .join("");
-      
-      const seed = new Uint8Array([0x02, 0x03]);
-      
-      const result = deriveProgramAddress({
-        programAddress: programAddressHex,
-        seed,
-      });
-      
-      expect(result.bytes.length).toBe(32);
-      expect(result.address).toBeTruthy();
-    });
-
-    it("should accept seed as string", () => {
-      const programAddress = generateTestPubkey(0x01);
-      const seed = "my-seed-string";
-      
-      const result = deriveProgramAddress({
-        programAddress,
-        seed,
-      });
-      
-      expect(result.bytes.length).toBe(32);
-      expect(result.address).toBeTruthy();
-    });
-
-    it("should accept seed as hex string", () => {
-      const programAddress = generateTestPubkey(0x01);
-      const seedBytes = new Uint8Array(32);
-      seedBytes.fill(0x42);
-      const seedHex = Array.from(seedBytes)
-        .map(b => b.toString(16).padStart(2, "0"))
-        .join("");
-      
-      const result = deriveProgramAddress({
-        programAddress,
-        seed: seedHex,
-      });
-      
-      expect(result.bytes.length).toBe(32);
-      expect(result.address).toBeTruthy();
-    });
-
-    it("should throw error for invalid program address length", () => {
-      const invalidProgramAddress = new Uint8Array(31); // Should be 32
-      const seed = new Uint8Array([0x02]);
-      
-      expect(() => deriveProgramAddress({
-        programAddress: invalidProgramAddress,
-        seed,
-      })).toThrow("Program address must contain 32 bytes");
-    });
-
-    it("should throw error for empty seed", () => {
-      const programAddress = generateTestPubkey(0x01);
-      
-      expect(() => deriveProgramAddress({
-        programAddress,
-        seed: "",
-      })).toThrow("Seed cannot be empty");
-      
-      expect(() => deriveProgramAddress({
-        programAddress,
-        seed: new Uint8Array(0),
-      })).toThrow("Seed cannot be empty");
-    });
-
-    it("should throw error for seed too long", () => {
-      const programAddress = generateTestPubkey(0x01);
-      const longSeed = new Uint8Array(33); // Max is 32
-      
-      expect(() => deriveProgramAddress({
-        programAddress,
-        seed: longSeed,
-      })).toThrow("Seed cannot exceed 32 bytes");
-    });
-
-    it("should throw error for invalid program address format", () => {
-      const invalidProgramAddress = "invalid-format";
-      const seed = new Uint8Array([0x02]);
-      
-      expect(() => deriveProgramAddress({
-        programAddress: invalidProgramAddress,
-        seed,
-      })).toThrow("Program address must be a 32-byte value, ta-address, or 64-character hex string");
-    });
-  });
-});
-

package/thru-ts-client-sdk/modules/__tests__/keys.test.ts

@@ -1,55 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { generateKeyPair } from "../keys";
-
-describe("keys", () => {
-  describe("generateKeyPair", () => {
-    it("should generate valid keypair", async () => {
-      const result = await generateKeyPair();
-      
-      expect(result).toBeDefined();
-      expect(result.address).toBeTruthy();
-      expect(result.publicKey).toBeInstanceOf(Uint8Array);
-      expect(result.privateKey).toBeInstanceOf(Uint8Array);
-    });
-
-    it("should generate 32-byte public key", async () => {
-      const result = await generateKeyPair();
-      
-      expect(result.publicKey.length).toBe(32);
-    });
-
-    it("should generate 32-byte private key (Ed25519 seed)", async () => {
-      const result = await generateKeyPair();
-      
-      expect(result.privateKey.length).toBe(32);
-    });
-
-    it("should generate address starting with 'ta'", async () => {
-      const result = await generateKeyPair();
-      
-      expect(result.address.startsWith("ta")).toBe(true);
-    });
-
-    it("should generate different keypairs on each call", async () => {
-      const result1 = await generateKeyPair();
-      const result2 = await generateKeyPair();
-      
-      // All fields should be different (very unlikely to be same)
-      expect(result1.address).not.toBe(result2.address);
-      expect(result1.publicKey).not.toEqual(result2.publicKey);
-      expect(result1.privateKey).not.toEqual(result2.privateKey);
-    });
-
-    it("should generate valid Ed25519 keypair format", async () => {
-      const result = await generateKeyPair();
-      
-      // Public key should be 32 bytes
-      expect(result.publicKey.length).toBe(32);
-      // Private key should be 32 bytes (Ed25519 seed)
-      expect(result.privateKey.length).toBe(32);
-      // Address should be valid format
-      expect(result.address.length).toBeGreaterThan(0);
-    });
-  });
-});
-