@thru/thru-sdk 0.1.19 → 0.1.21

package/thru-ts-client-sdk/core/bound-client.ts

@@ -1,156 +0,0 @@
-import type { ThruClientContext } from "./client";
-
-import { decodeAddress, decodeSignature, encodeAddress, encodeSignature } from "@thru/helpers";
-import * as accountsModule from "../modules/accounts";
-import * as blocksModule from "../modules/blocks";
-import * as eventsModule from "../modules/events";
-import * as heightModule from "../modules/height";
-import {
-    deriveProgramAddress,
-    toBlockHash,
-    toPubkey,
-    toSignature,
-    type DeriveProgramAddressOptions,
-    type DeriveProgramAddressResult,
-} from "../modules/helpers";
-import * as keysModule from "../modules/keys";
-import * as proofsModule from "../modules/proofs";
-import * as streamingModule from "../modules/streaming";
-import * as transactionsModule from "../modules/transactions";
-import * as versionModule from "../modules/version";
-import { BlockHash, Pubkey, Signature } from "../proto/thru/core/v1/types_pb";
-
-type ContextualParameters<F> = F extends (ctx: ThruClientContext, ...args: infer P) => any ? P : never;
-
-type BoundFunction<F> = F extends (ctx: ThruClientContext, ...args: infer P) => infer R ? (...args: P) => R : never;
-
-function bind<F extends (ctx: ThruClientContext, ...args: any[]) => any>(
-    ctx: ThruClientContext,
-    fn: F,
-): BoundFunction<F> {
-    return ((...args: ContextualParameters<F>) => fn(ctx, ...args)) as BoundFunction<F>;
-}
-
-interface BoundBlocks {
-    get: BoundFunction<typeof blocksModule.getBlock>;
-    getRaw: BoundFunction<typeof blocksModule.getRawBlock>;
-    list: BoundFunction<typeof blocksModule.listBlocks>;
-    stream: BoundFunction<typeof streamingModule.streamBlocks>;
-    getBlockHeight: BoundFunction<typeof heightModule.getBlockHeight>;
-}
-
-interface BoundAccounts {
-    get: BoundFunction<typeof accountsModule.getAccount>;
-    getRaw: BoundFunction<typeof accountsModule.getRawAccount>;
-    list: BoundFunction<typeof accountsModule.listAccounts>;
-    stream: BoundFunction<typeof streamingModule.streamAccountUpdates>;
-    create: BoundFunction<typeof accountsModule.createAccount>;
-}
-
-interface BoundTransactions {
-    get: BoundFunction<typeof transactionsModule.getTransaction>;
-    getRaw: BoundFunction<typeof transactionsModule.getRawTransaction>;
-    getStatus: BoundFunction<typeof transactionsModule.getTransactionStatus>;
-    listForAccount: BoundFunction<typeof transactionsModule.listTransactionsForAccount>;
-    stream: BoundFunction<typeof streamingModule.streamTransactions>;
-    build: BoundFunction<typeof transactionsModule.buildTransaction>;
-    buildAndSign: BoundFunction<typeof transactionsModule.buildAndSignTransaction>;
-    send: BoundFunction<typeof transactionsModule.sendTransaction>;
-    batchSend: BoundFunction<typeof transactionsModule.batchSendTransactions>;
-    track: BoundFunction<typeof streamingModule.trackTransaction>;
-}
-
-interface BoundEvents {
-    get: BoundFunction<typeof eventsModule.getEvent>;
-    stream: BoundFunction<typeof streamingModule.streamEvents>;
-}
-
-interface BoundProofs {
-    generate: BoundFunction<typeof proofsModule.generateStateProof>;
-}
-
-interface BoundKeys {
-    generateKeyPair: typeof keysModule.generateKeyPair;
-}
-
-interface BoundVersion {
-    get: BoundFunction<typeof versionModule.getVersion>;
-}
-
-interface Helpers {
-    toSignature(value: Uint8Array | string): Signature;
-    toPubkey(value: Uint8Array | string, field: string): Pubkey;
-    toBlockHash(value: Uint8Array | string): BlockHash;
-    encodeSignature(bytes: Uint8Array): string;
-    decodeSignature(value: string): Uint8Array;
-    encodeAddress(bytes: Uint8Array): string;
-    decodeAddress(value: string): Uint8Array;
-    deriveProgramAddress(options: DeriveProgramAddressOptions): DeriveProgramAddressResult;
-}
-
-export interface Thru {
-    ctx: ThruClientContext;
-    blocks: BoundBlocks;
-    accounts: BoundAccounts;
-    transactions: BoundTransactions;
-    events: BoundEvents;
-    proofs: BoundProofs;
-    keys: BoundKeys;
-    version: BoundVersion;
-    helpers: Helpers;
-}
-
-export function createBoundThruClient(ctx: ThruClientContext): Thru {
-    return {
-        ctx,
-        blocks: {
-            get: bind(ctx, blocksModule.getBlock),
-            getRaw: bind(ctx, blocksModule.getRawBlock),
-            list: bind(ctx, blocksModule.listBlocks),
-            stream: bind(ctx, streamingModule.streamBlocks),
-            getBlockHeight: bind(ctx, heightModule.getBlockHeight),
-        },
-        accounts: {
-            get: bind(ctx, accountsModule.getAccount),
-            getRaw: bind(ctx, accountsModule.getRawAccount),
-            list: bind(ctx, accountsModule.listAccounts),
-            stream: bind(ctx, streamingModule.streamAccountUpdates),
-            create: bind(ctx, accountsModule.createAccount),
-        },
-        transactions: {
-            get: bind(ctx, transactionsModule.getTransaction),
-            getRaw: bind(ctx, transactionsModule.getRawTransaction),
-            getStatus: bind(ctx, transactionsModule.getTransactionStatus),
-            listForAccount: bind(ctx, transactionsModule.listTransactionsForAccount),
-            stream: bind(ctx, streamingModule.streamTransactions),
-            build: bind(ctx, transactionsModule.buildTransaction),
-            buildAndSign: bind(ctx, transactionsModule.buildAndSignTransaction),
-            send: bind(ctx, transactionsModule.sendTransaction),
-            batchSend: bind(ctx, transactionsModule.batchSendTransactions),
-            track: bind(ctx, streamingModule.trackTransaction),
-        },
-        helpers: {
-            toSignature,
-            toPubkey,
-            toBlockHash,
-            encodeSignature,
-            decodeSignature,
-            encodeAddress,
-            decodeAddress,
-            deriveProgramAddress,
-        },
-        keys: {
-            generateKeyPair: keysModule.generateKeyPair,
-        },
-        events: {
-            get: bind(ctx, eventsModule.getEvent),
-            stream: bind(ctx, streamingModule.streamEvents),
-        },
-        proofs: {
-            generate: bind(ctx, proofsModule.generateStateProof),
-        },
-        version: {
-            get: bind(ctx, versionModule.getVersion),
-        },
-    };
-}

package/thru-ts-client-sdk/core/client.ts

@@ -1,38 +0,0 @@
-import { createClient } from "@connectrpc/connect";
-import { createGrpcWebTransport } from "@connectrpc/connect-web";
-
-import { DEFAULT_HOST } from "../defaults";
-import { CommandService } from "../proto/thru/services/v1/command_service_pb";
-import { QueryService } from "../proto/thru/services/v1/query_service_pb";
-import { StreamingService } from "../proto/thru/services/v1/streaming_service_pb";
-
-export interface ThruClientConfig {
-    baseUrl?: string;
-}
-
-type QueryClient = ReturnType<typeof createClient<typeof QueryService>>;
-type CommandClient = ReturnType<typeof createClient<typeof CommandService>>;
-type StreamingClient = ReturnType<typeof createClient<typeof StreamingService>>;
-
-export interface ThruClientContext {
-    baseUrl: string;
-    transport: ReturnType<typeof createGrpcWebTransport>;
-    query: QueryClient;
-    command: CommandClient;
-    streaming: StreamingClient;
-}
-
-export function createThruClientContext(config: ThruClientConfig = {}): ThruClientContext {
-    const baseUrl = config.baseUrl ?? DEFAULT_HOST;
-    const transport = createGrpcWebTransport({
-        baseUrl,
-    });
-
-    return {
-        baseUrl,
-        transport,
-        query: createClient(QueryService, transport),
-        command: createClient(CommandService, transport),
-        streaming: createClient(StreamingService, transport),
-    };
-}

package/thru-ts-client-sdk/defaults.ts

@@ -1,26 +0,0 @@
-import { create } from "@bufbuild/protobuf";
-import { ConsensusStatus, CurrentVersionSchema, VersionContextSchema } from "./proto/thru/common/v1/consensus_pb";
-import { AccountView } from "./proto/thru/core/v1/account_pb";
-import { BlockView } from "./proto/thru/core/v1/block_pb";
-import { TransactionView } from "./proto/thru/core/v1/transaction_pb";
-
-export const DEFAULT_HOST = "https://grpc-web.alphanet.thruput.org";
-
-export const DEFAULT_ACCOUNT_VIEW = AccountView.FULL;
-export const DEFAULT_BLOCK_VIEW = BlockView.FULL;
-export const DEFAULT_TRANSACTION_VIEW = TransactionView.FULL;
-export const DEFAULT_MIN_CONSENSUS = ConsensusStatus.UNSPECIFIED;
-
-// Default version context requests the latest version available at request time
-export const DEFAULT_VERSION_CONTEXT = create(VersionContextSchema, {
-    version: {
-        case: "current",
-        value: create(CurrentVersionSchema, {}),
-    },
-});
-
-export const DEFAULT_FEE = 1n;
-export const DEFAULT_COMPUTE_UNITS = 300_000_000;
-export const DEFAULT_STATE_UNITS = 10_000;
-export const DEFAULT_MEMORY_UNITS = 10_000;
-export const DEFAULT_EXPIRY_AFTER = 100;

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

@@ -1,406 +0,0 @@
-import { create } from "@bufbuild/protobuf";
-import { describe, expect, it, vi } from "vitest";
-import { createMockAccount, createMockContext, createMockHeightResponse, generateTestAddress, generateTestPubkey } from "../../__tests__/helpers/test-utils";
-import { ConsensusStatus, CurrentVersionSchema, VersionContextSchema } from "../../proto/thru/common/v1/consensus_pb";
-import { FilterParamValueSchema, FilterSchema } from "../../proto/thru/common/v1/filters_pb";
-import { AccountView } from "../../proto/thru/core/v1/account_pb";
-import { GenerateStateProofResponseSchema, ListAccountsResponseSchema } from "../../proto/thru/services/v1/query_service_pb";
-import { createAccount, getAccount, getRawAccount, listAccounts } from "../accounts";
-import { toPubkey } from "../helpers";
-
-describe("accounts", () => {
-  describe("getAccount", () => {
-    it("should return account with valid address", async () => {
-      const ctx = createMockContext();
-      const mockAccount = createMockAccount();
-      vi.spyOn(ctx.query, "getAccount").mockResolvedValue(mockAccount);
-      
-      const address = generateTestPubkey(0x01);
-      const result = await getAccount(ctx, address);
-      
-      expect(result).toBe(mockAccount);
-      expect(ctx.query.getAccount).toHaveBeenCalledTimes(1);
-    });
-
-    it("should accept address as Uint8Array", async () => {
-      const ctx = createMockContext();
-      const mockAccount = createMockAccount();
-      vi.spyOn(ctx.query, "getAccount").mockResolvedValue(mockAccount);
-      
-      const address = generateTestPubkey(0x01);
-      await getAccount(ctx, address);
-      
-      const callArgs = (ctx.query.getAccount as any).mock.calls[0][0];
-      expect(callArgs.address.value).toEqual(address);
-    });
-
-    it("should accept address as string", async () => {
-      const ctx = createMockContext();
-      const mockAccount = createMockAccount();
-      vi.spyOn(ctx.query, "getAccount").mockResolvedValue(mockAccount);
-      
-      const address = generateTestAddress(0x01);
-      await getAccount(ctx, address);
-      
-      const callArgs = (ctx.query.getAccount as any).mock.calls[0][0];
-      expect(callArgs.address.value.length).toBe(32);
-    });
-
-    it("should use default view when not provided", async () => {
-      const ctx = createMockContext();
-      const mockAccount = createMockAccount();
-      vi.spyOn(ctx.query, "getAccount").mockResolvedValue(mockAccount);
-      
-      await getAccount(ctx, generateTestPubkey(0x01));
-      
-      const callArgs = (ctx.query.getAccount as any).mock.calls[0][0];
-      expect(callArgs.view).toBe(AccountView.FULL);
-    });
-
-    it("should use custom view when provided", async () => {
-      const ctx = createMockContext();
-      const mockAccount = createMockAccount();
-      vi.spyOn(ctx.query, "getAccount").mockResolvedValue(mockAccount);
-      
-      await getAccount(ctx, generateTestPubkey(0x01), { view: AccountView.META_ONLY });
-      
-      const callArgs = (ctx.query.getAccount as any).mock.calls[0][0];
-      expect(callArgs.view).toBe(AccountView.META_ONLY);
-    });
-
-    it("should use default minConsensus when not provided", async () => {
-      const ctx = createMockContext();
-      const mockAccount = createMockAccount();
-      vi.spyOn(ctx.query, "getAccount").mockResolvedValue(mockAccount);
-      
-      await getAccount(ctx, generateTestPubkey(0x01));
-      
-      const callArgs = (ctx.query.getAccount as any).mock.calls[0][0];
-      expect(callArgs.minConsensus).toBe(ConsensusStatus.UNSPECIFIED);
-    });
-
-    it("should use custom minConsensus when provided", async () => {
-      const ctx = createMockContext();
-      const mockAccount = createMockAccount();
-      vi.spyOn(ctx.query, "getAccount").mockResolvedValue(mockAccount);
-      
-      await getAccount(ctx, generateTestPubkey(0x01), { minConsensus: ConsensusStatus.FINALIZED });
-      
-      const callArgs = (ctx.query.getAccount as any).mock.calls[0][0];
-      expect(callArgs.minConsensus).toBe(ConsensusStatus.FINALIZED);
-    });
-
-    it("should include dataSlice when provided", async () => {
-      const ctx = createMockContext();
-      const mockAccount = createMockAccount();
-      vi.spyOn(ctx.query, "getAccount").mockResolvedValue(mockAccount);
-      
-      const dataSlice = { offset: 0, length: 100 };
-      await getAccount(ctx, generateTestPubkey(0x01), { dataSlice: dataSlice as any });
-      
-      const callArgs = (ctx.query.getAccount as any).mock.calls[0][0];
-      expect(callArgs.dataSlice).toBeDefined();
-      expect(callArgs.dataSlice.offset).toBe(0);
-      expect(callArgs.dataSlice.length).toBe(100);
-    });
-
-    it("should include version context when provided", async () => {
-      const ctx = createMockContext();
-      const mockAccount = createMockAccount();
-      vi.spyOn(ctx.query, "getAccount").mockResolvedValue(mockAccount);
-      
-      const versionContext = create(VersionContextSchema, {
-        version: {
-          case: "current",
-          value: create(CurrentVersionSchema, {}),
-        },
-      });
-      
-      await getAccount(ctx, generateTestPubkey(0x01), { versionContext });
-      
-      const callArgs = (ctx.query.getAccount as any).mock.calls[0][0];
-      expect(callArgs.versionContext).toBeDefined();
-      expect(callArgs.versionContext.version?.case).toBe("current");
-    });
-  });
-
-  describe("getRawAccount", () => {
-    it("should return raw account", async () => {
-      const ctx = createMockContext();
-      const mockRawAccount = {
-        address: { value: generateTestPubkey(0x01) },
-        rawMeta: new Uint8Array([1, 2, 3]),
-        rawData: new Uint8Array([4, 5, 6]),
-      };
-      vi.spyOn(ctx.query, "getRawAccount").mockResolvedValue(mockRawAccount as any);
-      
-      const address = generateTestPubkey(0x01);
-      const result = await getRawAccount(ctx, address);
-      
-      expect(result).toBe(mockRawAccount);
-      expect(ctx.query.getRawAccount).toHaveBeenCalledTimes(1);
-    });
-
-    it("should use default view and minConsensus", async () => {
-      const ctx = createMockContext();
-      const mockRawAccount = { address: { value: generateTestPubkey(0x01) } };
-      vi.spyOn(ctx.query, "getRawAccount").mockResolvedValue(mockRawAccount as any);
-      
-      await getRawAccount(ctx, generateTestPubkey(0x01));
-      
-      const callArgs = (ctx.query.getRawAccount as any).mock.calls[0][0];
-      expect(callArgs.view).toBe(AccountView.FULL);
-      expect(callArgs.minConsensus).toBe(ConsensusStatus.UNSPECIFIED);
-    });
-  });
-
-  describe("listAccounts", () => {
-    it("should list owned accounts", async () => {
-      const ctx = createMockContext();
-      const mockResponse = create(ListAccountsResponseSchema, {
-        accounts: [createMockAccount()],
-      });
-      vi.spyOn(ctx.query, "listAccounts").mockResolvedValue(mockResponse);
-      
-      const owner = generateTestPubkey(0x01);
-      const ownerPubkey = toPubkey(owner, "owner");
-      const ownerFilterParamValue = create(FilterParamValueSchema, {
-        kind: {
-          case: "bytesValue",
-          value: ownerPubkey.value,
-        },
-      });
-      const ownerFilter = create(FilterSchema, {
-        expression: "meta.owner.value == params.owner_bytes",
-        params: {
-          owner_bytes: ownerFilterParamValue,
-        },
-      });
-      
-      const result = await listAccounts(ctx, { filter: ownerFilter });
-      
-      expect(result).toBe(mockResponse);
-      expect(ctx.query.listAccounts).toHaveBeenCalledTimes(1);
-    });
-
-    it("should create owner filter", async () => {
-      const ctx = createMockContext();
-      const mockResponse = create(ListAccountsResponseSchema, { accounts: [] });
-      vi.spyOn(ctx.query, "listAccounts").mockResolvedValue(mockResponse);
-      
-      const owner = generateTestPubkey(0x01);
-      const ownerPubkey = toPubkey(owner, "owner");
-      const ownerFilterParamValue = create(FilterParamValueSchema, {
-        kind: {
-          case: "bytesValue",
-          value: ownerPubkey.value,
-        },
-      });
-      const ownerFilter = create(FilterSchema, {
-        expression: "meta.owner.value == params.owner_bytes",
-        params: {
-          owner_bytes: ownerFilterParamValue,
-        },
-      });
-      
-      await listAccounts(ctx, { filter: ownerFilter });
-      
-      const callArgs = (ctx.query.listAccounts as any).mock.calls[0][0];
-      expect(callArgs.filter).toBeDefined();
-      expect(callArgs.filter.expression).toBe("meta.owner.value == params.owner_bytes");
-      expect(callArgs.filter.params.owner_bytes.kind.case).toBe("bytesValue");
-      expect(callArgs.filter.params.owner_bytes.kind.value).toEqual(ownerPubkey.value);
-    });
-
-    it("should use custom filter when provided", async () => {
-      const ctx = createMockContext();
-      const mockResponse = create(ListAccountsResponseSchema, { accounts: [] });
-      const customFilter = create(FilterSchema, {
-        expression: "custom expression",
-      });
-      vi.spyOn(ctx.query, "listAccounts").mockResolvedValue(mockResponse);
-      
-      await listAccounts(ctx, { filter: customFilter });
-      
-      const callArgs = (ctx.query.listAccounts as any).mock.calls[0][0];
-      expect(callArgs.filter.expression).toBe("custom expression");
-    });
-
-    it("should use default view and minConsensus", async () => {
-      const ctx = createMockContext();
-      const mockResponse = create(ListAccountsResponseSchema, { accounts: [] });
-      vi.spyOn(ctx.query, "listAccounts").mockResolvedValue(mockResponse);
-      
-      const owner = generateTestPubkey(0x01);
-      const ownerPubkey = toPubkey(owner, "owner");
-      const ownerFilterParamValue = create(FilterParamValueSchema, {
-        kind: {
-          case: "bytesValue",
-          value: ownerPubkey.value,
-        },
-      });
-      const ownerFilter = create(FilterSchema, {
-        expression: "meta.owner.value == params.owner_bytes",
-        params: {
-          owner_bytes: ownerFilterParamValue,
-        },
-      });
-      
-      await listAccounts(ctx, { filter: ownerFilter });
-      
-      const callArgs = (ctx.query.listAccounts as any).mock.calls[0][0];
-      expect(callArgs.view).toBe(AccountView.FULL);
-      expect(callArgs.minConsensus).toBe(ConsensusStatus.UNSPECIFIED);
-    });
-  });
-
-  describe("createAccount", () => {
-    it("should create account transaction", async () => {
-      const ctx = createMockContext();
-      const mockHeight = createMockHeightResponse({ finalized: 1000n });
-      const mockProof = create(GenerateStateProofResponseSchema, {
-        proof: {
-          proof: new Uint8Array(64).fill(0x42),
-        },
-      });
-      
-      vi.spyOn(ctx.query, "getHeight").mockResolvedValue(mockHeight);
-      vi.spyOn(ctx.query, "generateStateProof").mockResolvedValue(mockProof);
-      
-      const publicKey = generateTestPubkey(0x01);
-      const transaction = await createAccount(ctx, { publicKey });
-      
-      expect(transaction).toBeDefined();
-      expect(transaction.feePayer).toEqual(publicKey);
-      expect(transaction.feePayerStateProof).toBeDefined();
-      expect(ctx.query.getHeight).toHaveBeenCalledTimes(1);
-      expect(ctx.query.generateStateProof).toHaveBeenCalledTimes(1);
-    });
-
-    it("should use finalized slot from height", async () => {
-      const ctx = createMockContext();
-      const mockHeight = createMockHeightResponse({ finalized: 2000n });
-      const mockProof = create(GenerateStateProofResponseSchema, {
-        proof: {
-          proof: new Uint8Array(64).fill(0x42),
-        },
-      });
-      
-      vi.spyOn(ctx.query, "getHeight").mockResolvedValue(mockHeight);
-      vi.spyOn(ctx.query, "generateStateProof").mockResolvedValue(mockProof);
-      
-      const publicKey = generateTestPubkey(0x01);
-      const transaction = await createAccount(ctx, { publicKey });
-      
-      expect(transaction.startSlot).toBe(2000n);
-      // Verify generateStateProof was called (we can't easily check nested properties)
-      expect(ctx.query.generateStateProof).toHaveBeenCalledTimes(1);
-    });
-
-    it("should generate CREATING proof type", async () => {
-      const ctx = createMockContext();
-      const mockHeight = createMockHeightResponse();
-      const mockProof = create(GenerateStateProofResponseSchema, {
-        proof: {
-          proof: new Uint8Array(64).fill(0x42),
-        },
-      });
-      
-      vi.spyOn(ctx.query, "getHeight").mockResolvedValue(mockHeight);
-      vi.spyOn(ctx.query, "generateStateProof").mockResolvedValue(mockProof);
-      
-      const publicKey = generateTestPubkey(0x01);
-      await createAccount(ctx, { publicKey });
-      
-      // Verify generateStateProof was called with correct address
-      expect(ctx.query.generateStateProof).toHaveBeenCalledTimes(1);
-      const proofCallArgs = (ctx.query.generateStateProof as any).mock.calls[0][0];
-      expect(proofCallArgs.request).toBeDefined();
-    });
-
-    it("should throw error when proof is empty", async () => {
-      const ctx = createMockContext();
-      const mockHeight = createMockHeightResponse();
-      const mockProof = create(GenerateStateProofResponseSchema, {
-        proof: {
-          proof: new Uint8Array(0), // Empty proof
-        },
-      });
-      
-      vi.spyOn(ctx.query, "getHeight").mockResolvedValue(mockHeight);
-      vi.spyOn(ctx.query, "generateStateProof").mockResolvedValue(mockProof);
-      
-      const publicKey = generateTestPubkey(0x01);
-      
-      await expect(createAccount(ctx, { publicKey })).rejects.toThrow(
-        "State proof generation returned empty proof"
-      );
-    });
-
-    it("should throw error when proof is missing", async () => {
-      const ctx = createMockContext();
-      const mockHeight = createMockHeightResponse();
-      const mockProof = create(GenerateStateProofResponseSchema, {
-        // No proof field
-      });
-      
-      vi.spyOn(ctx.query, "getHeight").mockResolvedValue(mockHeight);
-      vi.spyOn(ctx.query, "generateStateProof").mockResolvedValue(mockProof);
-      
-      const publicKey = generateTestPubkey(0x01);
-      
-      await expect(createAccount(ctx, { publicKey })).rejects.toThrow(
-        "State proof generation returned empty proof"
-      );
-    });
-
-    it("should apply header overrides", async () => {
-      const ctx = createMockContext();
-      const mockHeight = createMockHeightResponse({ finalized: 1000n });
-      const mockProof = create(GenerateStateProofResponseSchema, {
-        proof: {
-          proof: new Uint8Array(64).fill(0x42),
-        },
-      });
-      
-      vi.spyOn(ctx.query, "getHeight").mockResolvedValue(mockHeight);
-      vi.spyOn(ctx.query, "generateStateProof").mockResolvedValue(mockProof);
-      
-      const publicKey = generateTestPubkey(0x01);
-      const transaction = await createAccount(ctx, {
-        publicKey,
-        header: {
-          fee: 100n,
-          computeUnits: 20_000,
-        },
-      });
-      
-      expect(transaction.fee).toBe(100n);
-      expect(transaction.requestedComputeUnits).toBe(20_000);
-    });
-
-    it("should use default header values", async () => {
-      const ctx = createMockContext();
-      const mockHeight = createMockHeightResponse({ finalized: 1000n });
-      const mockProof = create(GenerateStateProofResponseSchema, {
-        proof: {
-          proof: new Uint8Array(64).fill(0x42),
-        },
-      });
-      
-      vi.spyOn(ctx.query, "getHeight").mockResolvedValue(mockHeight);
-      vi.spyOn(ctx.query, "generateStateProof").mockResolvedValue(mockProof);
-      
-      const publicKey = generateTestPubkey(0x01);
-      const transaction = await createAccount(ctx, { publicKey });
-      
-      expect(transaction.fee).toBe(0n);
-      expect(transaction.nonce).toBe(0n);
-      expect(transaction.expiryAfter).toBe(100);
-      expect(transaction.requestedComputeUnits).toBe(10_000);
-      expect(transaction.requestedStateUnits).toBe(10_000);
-      expect(transaction.requestedMemoryUnits).toBe(10_000);
-    });
-  });
-});
-