@thru/thru-sdk 0.1.19 → 0.1.21

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

@@ -1,40 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createMockContext } from "../../__tests__/helpers/test-utils";
-import { getVersion } from "../version";
-
-describe("version", () => {
-  describe("getVersion", () => {
-    it("should return version response", async () => {
-      const ctx = createMockContext();
-      const mockResponse = {
-        versions: {
-          "component1": "1.0.0",
-          "component2": "2.1.0",
-        },
-      };
-      vi.spyOn(ctx.query, "getVersion").mockResolvedValue(mockResponse as any);
-      
-      const result = await getVersion(ctx);
-      
-      expect(result).toBe(mockResponse);
-      expect(result.versions).toEqual({
-        "component1": "1.0.0",
-        "component2": "2.1.0",
-      });
-      expect(ctx.query.getVersion).toHaveBeenCalledTimes(1);
-    });
-
-    it("should create empty request", async () => {
-      const ctx = createMockContext();
-      const mockResponse = { versions: {} };
-      vi.spyOn(ctx.query, "getVersion").mockResolvedValue(mockResponse as any);
-      
-      await getVersion(ctx);
-      
-      const callArgs = (ctx.query.getVersion as any).mock.calls[0][0];
-      // Request should be created (empty GetVersionRequest)
-      expect(callArgs).toBeDefined();
-    });
-  });
-});
-

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

@@ -1,141 +0,0 @@
-import { create } from "@bufbuild/protobuf";
-
-import { BytesLike } from "@thru/helpers";
-import type { ThruClientContext } from "../core/client";
-import { DEFAULT_ACCOUNT_VIEW, DEFAULT_MIN_CONSENSUS, DEFAULT_VERSION_CONTEXT } from "../defaults";
-import { ConsensusStatus, VersionContext } from "../proto/thru/common/v1/consensus_pb";
-import { type Filter } from "../proto/thru/common/v1/filters_pb";
-import type { PageRequest } from "../proto/thru/common/v1/pagination_pb";
-import { Account, AccountView, DataSlice, RawAccount } from "../proto/thru/core/v1/account_pb";
-import { StateProofType } from "../proto/thru/core/v1/state_pb";
-import {
-    GetAccountRequestSchema,
-    GetRawAccountRequestSchema,
-    ListAccountsRequestSchema,
-    type ListAccountsResponse,
-} from "../proto/thru/services/v1/query_service_pb";
-import type { Transaction } from "../transactions/Transaction";
-import { TransactionBuilder } from "../transactions/TransactionBuilder";
-import type { TransactionHeaderInput } from "../transactions/types";
-import { mergeTransactionHeader } from "../utils/utils";
-import { getBlockHeight } from "./height";
-import { toPubkey } from "./helpers";
-import { generateStateProof } from "./proofs";
-
-export interface CreateAccountOptions {
-    /** The new account's public key (fee payer). */
-    publicKey: BytesLike;
-    /** Optional overrides for the transaction header. */
-    header?: Partial<TransactionHeaderInput>;
-}
-
-
-export interface AccountQueryOptions {
-    view?: AccountView;
-    versionContext?: VersionContext;
-    minConsensus?: ConsensusStatus;
-    dataSlice?: DataSlice;
-}
-
-export interface RawAccountQueryOptions {
-    view?: AccountView;
-    versionContext?: VersionContext;
-    minConsensus?: ConsensusStatus;
-}
-
-export interface ListAccountsOptions {
-    view?: AccountView;
-    versionContext?: VersionContext;
-    filter?: Filter;
-    page?: PageRequest;
-    minConsensus?: ConsensusStatus;
-}
-
-export function getAccount(
-    ctx: ThruClientContext,
-    address: BytesLike,
-    options: AccountQueryOptions = {},
-): Promise<Account> {
-    const request = create(GetAccountRequestSchema, {
-        address: toPubkey(address, "address"),
-        view: options.view ?? DEFAULT_ACCOUNT_VIEW,
-        versionContext: options.versionContext ?? DEFAULT_VERSION_CONTEXT,
-        minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS,
-        dataSlice: options.dataSlice,
-    });
-    return ctx.query.getAccount(request);
-}
-
-export function getRawAccount(
-    ctx: ThruClientContext,
-    address: BytesLike,
-    options: RawAccountQueryOptions = {},
-): Promise<RawAccount> {
-    const request = create(GetRawAccountRequestSchema, {
-        address: toPubkey(address, "address"),
-        view: options.view ?? DEFAULT_ACCOUNT_VIEW,
-        versionContext: options.versionContext ?? DEFAULT_VERSION_CONTEXT,
-        minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS,
-    });
-    return ctx.query.getRawAccount(request);
-}
-
-export function listAccounts(
-    ctx: ThruClientContext,
-    options: ListAccountsOptions,
-): Promise<ListAccountsResponse> {
-    const request = create(ListAccountsRequestSchema, {
-        view: options.view ?? DEFAULT_ACCOUNT_VIEW,
-        versionContext: options.versionContext ?? DEFAULT_VERSION_CONTEXT,
-        filter: options.filter,
-        page: options.page,
-        minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS,
-    });
-    return ctx.query.listAccounts(request);
-}
-
-export async function createAccount(
-    ctx: ThruClientContext,
-    options: CreateAccountOptions,
-): Promise<Transaction> {
-    const feePayer = toPubkey(options.publicKey, "publicKey").value;
-
-    const height = await getBlockHeight(ctx);
-    const startSlot = height.finalized;
-
-    const proofResponse = await generateStateProof(ctx, {
-        address: options.publicKey,
-        proofType: StateProofType.CREATING,
-        targetSlot: startSlot,
-    });
-
-    const proofBytes = proofResponse.proof?.proof;
-    if (!proofBytes || proofBytes.length === 0) {
-        throw new Error("State proof generation returned empty proof");
-    }
-
-    const program = new Uint8Array(32);
-    program[31] = 0x02;
-
-    const builder = new TransactionBuilder();
-    const headerDefaults: TransactionHeaderInput = {
-        fee: 0n,
-        nonce: 0n,
-        startSlot,
-        expiryAfter: 100,
-        computeUnits: 10_000,
-        memoryUnits: 10_000,
-        stateUnits: 10_000,
-    };
-
-    const header = mergeTransactionHeader(headerDefaults, options.header);
-
-    const transaction = builder.build({
-        feePayer: { publicKey: feePayer },
-        program,
-        header,
-        proofs: { feePayerStateProof: proofBytes }
-    });
-
-    return transaction;
-}

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

@@ -1,75 +0,0 @@
-import { create } from "@bufbuild/protobuf";
-
-import type { ThruClientContext } from "../core/client";
-import { DEFAULT_BLOCK_VIEW, DEFAULT_MIN_CONSENSUS } from "../defaults";
-import { ConsensusStatus } from "../proto/thru/common/v1/consensus_pb";
-import type { Filter } from "../proto/thru/common/v1/filters_pb";
-import type { PageRequest } from "../proto/thru/common/v1/pagination_pb";
-import { Block, BlockView, RawBlock } from "../proto/thru/core/v1/block_pb";
-import {
-    GetBlockRequestSchema,
-    GetRawBlockRequestSchema,
-    ListBlocksRequestSchema,
-    ListBlocksResponse,
-} from "../proto/thru/services/v1/query_service_pb";
-import { isSlotSelector } from "../utils/utils";
-import type { BlockSelector } from "./helpers";
-import { toBlockHash } from "./helpers";
-
-export interface BlockQueryOptions {
-    view?: BlockView;
-    minConsensus?: ConsensusStatus;
-}
-
-export interface RawBlockQueryOptions {
-    minConsensus?: ConsensusStatus;
-}
-
-export interface ListBlocksOptions {
-    filter?: Filter;
-    page?: PageRequest;
-    view?: BlockView;
-    minConsensus?: ConsensusStatus;
-}
-
-export function getBlock(
-    ctx: ThruClientContext,
-    selector: BlockSelector,
-    options: BlockQueryOptions = {},
-): Promise<Block> {
-    const request = create(GetBlockRequestSchema, {
-        selector: isSlotSelector(selector)
-            ? { case: "slot", value: typeof selector.slot === "bigint" ? selector.slot : BigInt(selector.slot) }
-            : { case: "blockHash", value: toBlockHash(selector.blockHash) },
-        view: options.view ?? DEFAULT_BLOCK_VIEW,
-        minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS,
-    });
-    return ctx.query.getBlock(request);
-}
-
-export function getRawBlock(
-    ctx: ThruClientContext,
-    selector: BlockSelector,
-    options: RawBlockQueryOptions = {},
-): Promise<RawBlock> {
-    const request = create(GetRawBlockRequestSchema, {
-        selector: isSlotSelector(selector)
-            ? { case: "slot", value: typeof selector.slot === "bigint" ? selector.slot : BigInt(selector.slot) }
-            : { case: "blockHash", value: toBlockHash(selector.blockHash) },
-        minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS,
-    });
-    return ctx.query.getRawBlock(request);
-}
-
-export function listBlocks(
-    ctx: ThruClientContext,
-    options: ListBlocksOptions = {},
-): Promise<ListBlocksResponse> {
-    const request = create(ListBlocksRequestSchema, {
-        filter: options.filter,
-        page: options.page,
-        view: options.view ?? DEFAULT_BLOCK_VIEW,
-        minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS,
-    });
-    return ctx.query.listBlocks(request);
-}

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

@@ -1,20 +0,0 @@
-import { create } from "@bufbuild/protobuf";
-
-import type { ThruClientContext } from "../core/client";
-import type { VersionContext } from "../proto/thru/common/v1/consensus_pb";
-import { Event, GetEventRequestSchema } from "../proto/thru/services/v1/query_service_pb";
-
-export interface GetEventOptions {
-    versionContext?: VersionContext;
-}
-
-export function getEvent(ctx: ThruClientContext, eventId: string, options: GetEventOptions = {}): Promise<Event> {
-    if (!eventId) {
-        throw new Error("eventId is required");
-    }
-    const request = create(GetEventRequestSchema, {
-        eventId,
-        versionContext: options.versionContext,
-    });
-    return ctx.query.getEvent(request);
-}

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

@@ -1,9 +0,0 @@
-import { create } from "@bufbuild/protobuf";
-
-import type { ThruClientContext } from "../core/client";
-import { GetHeightRequestSchema, GetHeightResponse } from "../proto/thru/services/v1/query_service_pb";
-
-export function getBlockHeight(ctx: ThruClientContext): Promise<GetHeightResponse> {
-    const request = create(GetHeightRequestSchema);
-    return ctx.query.getHeight(request);
-}

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

@@ -1,131 +0,0 @@
-import { create } from "@bufbuild/protobuf";
-import { sha256 } from "@noble/hashes/sha2";
-import { BytesLike, decodeAddress, decodeBase64, decodeSignature, encodeAddress, ensureBytes, hexToBytes, isHexString } from "@thru/helpers";
-
-import { BlockHash, BlockHashSchema, Pubkey, PubkeySchema, Signature, SignatureSchema } from "../proto/thru/core/v1/types_pb";
-
-export type BlockSelector = { slot: number | bigint } | { blockHash: BytesLike };
-
-export function toSignature(value: BytesLike): Signature {
-    let bytes: Uint8Array;
-    if (value instanceof Uint8Array) {
-        if (value.length !== 64) {
-            throw new Error("signature must contain 64 bytes");
-        }
-        bytes = value;
-    } else if (typeof value === "string") {
-        bytes = value.startsWith("ts") ? decodeSignature(value) : decodeBase64(value);
-    } else {
-        throw new Error("signature is required");
-    }
-    if (bytes.length !== 64) {
-        throw new Error("signature must contain 64 bytes");
-    }
-    return create(SignatureSchema, { value: bytes });
-}
-
-export function toPubkey(value: BytesLike, field: string): Pubkey {
-    let bytes: Uint8Array;
-    if (value instanceof Uint8Array) {
-        bytes = value;
-    } else if (typeof value === "string") {
-        bytes = value.startsWith("ta") ? decodeAddress(value) : decodeBase64(value);
-    } else {
-        throw new Error(`${field} is required`);
-    }
-    if (bytes.length !== 32) {
-        throw new Error(`${field} must contain 32 bytes`);
-    }
-    return create(PubkeySchema, { value: bytes });
-}
-
-export function toBlockHash(value: BytesLike): BlockHash {
-    return create(BlockHashSchema, { value: ensureBytes(value, "blockHash") });
-}
-
-export interface DeriveProgramAddressOptions {
-    programAddress: BytesLike;
-    seed: BytesLike;
-    ephemeral?: boolean;
-}
-
-export interface DeriveProgramAddressResult {
-    bytes: Uint8Array;
-    address: string;
-}
-
-export function deriveProgramAddress(options: DeriveProgramAddressOptions): DeriveProgramAddressResult {
-    const programAddress = normalizeProgramAddress(options.programAddress);
-    const seed = normalizeSeed(options.seed);
-    const ephemeral = options.ephemeral === true;
-
-    const derivationInput = new Uint8Array(programAddress.length + 1 + seed.length);
-    derivationInput.set(programAddress, 0);
-    derivationInput[programAddress.length] = ephemeral ? 1 : 0;
-    derivationInput.set(seed, programAddress.length + 1);
-
-    const hash = sha256(derivationInput);
-    const derivedBytes = new Uint8Array(hash.slice(0, 32));
-
-    return {
-        bytes: derivedBytes,
-        address: encodeAddress(derivedBytes),
-    };
-}
-
-function normalizeProgramAddress(value: BytesLike): Uint8Array {
-    if (value instanceof Uint8Array) {
-        if (value.length !== 32) {
-            throw new Error("Program address must contain 32 bytes");
-        }
-        return new Uint8Array(value);
-    }
-    if (typeof value === "string") {
-        if (value.startsWith("ta") && value.length === 46) {
-            return decodeAddress(value);
-        }
-        if (isHexString(value)) {
-            const bytes = hexToBytes(value);
-            if (bytes.length !== 32) {
-                throw new Error("Program address hex string must decode to 32 bytes");
-            }
-            return bytes;
-        }
-    }
-    throw new Error("Program address must be a 32-byte value, ta-address, or 64-character hex string");
-}
-
-function normalizeSeed(value: BytesLike | string): Uint8Array {
-    if (value instanceof Uint8Array) {
-        if (value.length === 0) {
-            throw new Error("Seed cannot be empty");
-        }
-        if (value.length > 32) {
-            throw new Error("Seed cannot exceed 32 bytes");
-        }
-        const seed = new Uint8Array(32);
-        seed.set(value);
-        return seed;
-    }
-    if (typeof value === "string") {
-        if (value.length === 0) {
-            throw new Error("Seed cannot be empty");
-        }
-        if (isHexString(value)) {
-            const bytes = hexToBytes(value);
-            if (bytes.length !== 32) {
-                throw new Error(`Hex seed must decode to 32 bytes, got ${bytes.length}`);
-            }
-            return bytes;
-        }
-        const encoder = new TextEncoder();
-        const utf8 = encoder.encode(value);
-        if (utf8.length > 32) {
-            throw new Error(`UTF-8 seed too long: ${utf8.length} bytes (max 32)`);
-        }
-        const seed = new Uint8Array(32);
-        seed.set(utf8);
-        return seed;
-    }
-    throw new Error("Seed must be provided as Uint8Array or string");
-}

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

@@ -1,29 +0,0 @@
-import { getWebCrypto, ThruHDWallet } from "@thru/crypto";
-
-export interface GeneratedKeyPair {
-    address: string;
-    publicKey: Uint8Array;
-    privateKey: Uint8Array;
-}
-
-/**
- * Generates a new Ed25519 keypair using the same HD wallet pipeline as the Thru wallet.
- */
-export async function generateKeyPair(): Promise<GeneratedKeyPair> {
-    const seed = generateSeed();
-    const account = await ThruHDWallet.getAccount(seed, 0);
-    seed.fill(0);
-
-    return {
-        address: account.address,
-        publicKey: account.publicKey,
-        privateKey: account.privateKey,
-    };
-}
-
-function generateSeed(): Uint8Array {
-    const cryptoObj = getWebCrypto();
-    const bytes = new Uint8Array(64);
-    cryptoObj.getRandomValues(bytes);
-    return bytes;
-}

package/thru-ts-client-sdk/modules/proofs.ts

@@ -1,20 +0,0 @@
-import { create } from "@bufbuild/protobuf";
-
-import type { ThruClientContext } from "../core/client";
-import { StateProofRequestSchema } from "../proto/thru/core/v1/state_pb";
-import { GenerateStateProofRequestSchema, GenerateStateProofResponse } from "../proto/thru/services/v1/query_service_pb";
-import { GenerateStateProofOptions } from "../types/types";
-import { toPubkey } from "./helpers";
-
-export function generateStateProof(
-    ctx: ThruClientContext,
-    options: GenerateStateProofOptions,
-): Promise<GenerateStateProofResponse> {
-    const request = create(StateProofRequestSchema, {
-        address: options.address ? toPubkey(options.address, "address") : undefined,
-        proofType: options.proofType,
-        targetSlot: options.targetSlot,
-    });
-    const schemaRequest = create(GenerateStateProofRequestSchema, { request });
-    return ctx.query.generateStateProof(schemaRequest);
-}

package/thru-ts-client-sdk/modules/streaming.ts

@@ -1,133 +0,0 @@
-import { create } from "@bufbuild/protobuf";
-
-import { BytesLike } from "@thru/helpers";
-import type { ThruClientContext } from "../core/client";
-import { DEFAULT_ACCOUNT_VIEW, DEFAULT_BLOCK_VIEW, DEFAULT_MIN_CONSENSUS } from "../defaults";
-import type { ConsensusStatus } from "../proto/thru/common/v1/consensus_pb";
-import type { Filter } from "../proto/thru/common/v1/filters_pb";
-import type { AccountView } from "../proto/thru/core/v1/account_pb";
-import type { BlockView } from "../proto/thru/core/v1/block_pb";
-import {
-    StreamAccountUpdatesRequestSchema,
-    type StreamAccountUpdatesResponse,
-    StreamBlocksRequestSchema,
-    type StreamBlocksResponse,
-    StreamEventsRequestSchema,
-    type StreamEventsResponse,
-    StreamTransactionsRequestSchema,
-    type StreamTransactionsResponse,
-    TrackTransactionRequestSchema,
-    type TrackTransactionResponse,
-} from "../proto/thru/services/v1/streaming_service_pb";
-import { toPubkey, toSignature as toSignatureMessage } from "./helpers";
-
-export interface TrackTransactionOptions {
-    timeoutMs?: number;
-    signal?: AbortSignal;
-}
-
-export interface StreamBlocksOptions {
-    startSlot?: bigint;
-    filter?: Filter;
-    view?: BlockView;
-    minConsensus?: ConsensusStatus;
-    signal?: AbortSignal;
-}
-
-export function streamBlocks(
-    ctx: ThruClientContext,
-    options: StreamBlocksOptions = {},
-): AsyncIterable<StreamBlocksResponse> {
-    const request = create(StreamBlocksRequestSchema, {
-        startSlot: options.startSlot,
-        filter: options.filter,
-        view: options.view ?? DEFAULT_BLOCK_VIEW,
-        minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS,
-    });
-
-    return ctx.streaming.streamBlocks(request, {
-        signal: options.signal,
-    });
-}
-
-export interface StreamAccountUpdatesOptions {
-    view?: AccountView;
-    filter?: Filter;
-    signal?: AbortSignal;
-}
-
-export function streamAccountUpdates(
-    ctx: ThruClientContext,
-    address: BytesLike,
-    options: StreamAccountUpdatesOptions = {},
-): AsyncIterable<StreamAccountUpdatesResponse> {
-    const request = create(StreamAccountUpdatesRequestSchema, {
-        address: toPubkey(address, "address"),
-        view: options.view ?? DEFAULT_ACCOUNT_VIEW,
-        filter: options.filter,
-    });
-
-    return ctx.streaming.streamAccountUpdates(request, {
-        signal: options.signal,
-    });
-}
-
-export interface StreamTransactionsOptions {
-    filter?: Filter;
-    minConsensus?: ConsensusStatus;
-    signal?: AbortSignal;
-}
-
-export function streamTransactions(
-    ctx: ThruClientContext,
-    options: StreamTransactionsOptions = {},
-): AsyncIterable<StreamTransactionsResponse> {
-    const request = create(StreamTransactionsRequestSchema, {
-        filter: options.filter,
-        minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS,
-    });
-
-    return ctx.streaming.streamTransactions(request, {
-        signal: options.signal,
-    });
-}
-
-export interface StreamEventsOptions {
-    filter?: Filter;
-    signal?: AbortSignal;
-}
-
-export function streamEvents(
-    ctx: ThruClientContext,
-    options: StreamEventsOptions = {},
-): AsyncIterable<StreamEventsResponse> {
-    const request = create(StreamEventsRequestSchema, {
-        filter: options.filter,
-    });
-
-    return ctx.streaming.streamEvents(request, {
-        signal: options.signal,
-    });
-}
-
-export function trackTransaction(
-    ctx: ThruClientContext,
-    signature: BytesLike,
-    options: TrackTransactionOptions = {},
-): AsyncIterable<TrackTransactionResponse> {
-    const timeoutMs = options.timeoutMs;
-    const request = create(TrackTransactionRequestSchema, {
-        signature: toSignatureMessage(signature),
-        timeout:
-            timeoutMs != null
-                ? {
-                    seconds: BigInt(Math.floor(timeoutMs / 1000)),
-                    nanos: (timeoutMs % 1000) * 1_000_000,
-                }
-                : undefined,
-    });
-
-    return ctx.streaming.trackTransaction(request, {
-        signal: options.signal,
-    });
-}