@thru/thru-sdk 0.0.4

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

@@ -0,0 +1,340 @@
+import { create } from "@bufbuild/protobuf";
+import { sha256 } from "@noble/hashes/sha256";
+import { BlockHash, BlockHashSchema, Pubkey, PubkeySchema, Signature, SignatureSchema } from "../proto/thru/core/v1/types_pb";
+import { decodeBase64, ensureBytes, hexToBytes, isHexString, maskForBits } from "../utils/utils";
+
+const BASE64_URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+const BASE64_URL_MAP = new Int16Array(256).fill(-1);
+for (let i = 0; i < BASE64_URL_ALPHABET.length; i++) {
+    BASE64_URL_MAP[BASE64_URL_ALPHABET.charCodeAt(i)] = i;
+}
+
+export type BytesLike = string | Uint8Array;
+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 function encodeSignature(bytes: Uint8Array): string {
+    if (bytes.length !== 64) {
+        throw new Error("Expected 64-byte signature");
+    }
+    let checksum = 0;
+    let accumulator = 0;
+    let bitsCollected = 0;
+    const output: string[] = ["t", "s"];
+
+    for (let i = 0; i < 63; i++) {
+        const byte = bytes[i];
+        checksum += byte;
+        accumulator = ((accumulator << 8) | byte) >>> 0;
+        bitsCollected += 8;
+        while (bitsCollected >= 6) {
+            const index = (accumulator >> (bitsCollected - 6)) & 0x3f;
+            output.push(BASE64_URL_ALPHABET[index]);
+            bitsCollected -= 6;
+            accumulator &= maskForBits(bitsCollected);
+        }
+    }
+
+    const lastByte = bytes[63];
+    checksum += lastByte;
+    accumulator = ((accumulator << 8) | lastByte) >>> 0;
+    bitsCollected += 8;
+    accumulator = ((accumulator << 16) | (checksum & 0xffff)) >>> 0;
+    bitsCollected += 16;
+
+    while (bitsCollected >= 6) {
+        const index = (accumulator >> (bitsCollected - 6)) & 0x3f;
+        output.push(BASE64_URL_ALPHABET[index]);
+        bitsCollected -= 6;
+        accumulator &= maskForBits(bitsCollected);
+    }
+
+    return output.join("");
+}
+
+export function decodeSignature(value: string): Uint8Array {
+    if (value.length !== 90) {
+        throw new Error("Invalid signature length");
+    }
+    if (!value.startsWith("ts")) {
+        throw new Error('Signature must start with "ts"');
+    }
+
+    const output = new Uint8Array(64);
+    let checksum = 0;
+    let inIdx = 2;
+    let remaining = 84;
+    let outIdx = 0;
+
+    while (remaining > 0) {
+        const a = BASE64_URL_MAP[value.charCodeAt(inIdx)];
+        const b = BASE64_URL_MAP[value.charCodeAt(inIdx + 1)];
+        const c = BASE64_URL_MAP[value.charCodeAt(inIdx + 2)];
+        const d = BASE64_URL_MAP[value.charCodeAt(inIdx + 3)];
+        if (a < 0 || b < 0 || c < 0 || d < 0) {
+            throw new Error("Invalid signature encoding");
+        }
+        const triple = (a << 18) | (b << 12) | (c << 6) | d;
+        const byte1 = (triple >> 16) & 0xff;
+        const byte2 = (triple >> 8) & 0xff;
+        const byte3 = triple & 0xff;
+        checksum += byte1;
+        checksum += byte2;
+        checksum += byte3;
+        output[outIdx++] = byte1;
+        output[outIdx++] = byte2;
+        output[outIdx++] = byte3;
+        inIdx += 4;
+        remaining -= 4;
+    }
+
+    const a = BASE64_URL_MAP[value.charCodeAt(inIdx)];
+    const b = BASE64_URL_MAP[value.charCodeAt(inIdx + 1)];
+    const c = BASE64_URL_MAP[value.charCodeAt(inIdx + 2)];
+    const d = BASE64_URL_MAP[value.charCodeAt(inIdx + 3)];
+    if (a < 0 || b < 0 || c < 0 || d < 0) {
+        throw new Error("Invalid signature encoding");
+    }
+    const triple = (a << 18) | (b << 12) | (c << 6) | d;
+    const finalByte = (triple >> 16) & 0xff;
+    checksum += finalByte;
+    output[outIdx] = finalByte;
+
+    const incomingChecksum = triple & 0xffff;
+    checksum &= 0xffff;
+    if (checksum !== incomingChecksum) {
+        throw new Error("Signature checksum mismatch");
+    }
+
+    return output;
+}
+
+export function encodeAddress(bytes: Uint8Array): string {
+    if (bytes.length !== 32) {
+        throw new Error("Expected 32-byte address");
+    }
+    let checksum = 0;
+    let accumulator = 0;
+    let bitsCollected = 0;
+    const output: string[] = ["t", "a"];
+
+    for (let i = 0; i < 30; i++) {
+        const byte = bytes[i];
+        checksum += byte;
+        accumulator = ((accumulator << 8) | byte) >>> 0;
+        bitsCollected += 8;
+        while (bitsCollected >= 6) {
+            const index = (accumulator >> (bitsCollected - 6)) & 0x3f;
+            output.push(BASE64_URL_ALPHABET[index]);
+            bitsCollected -= 6;
+            accumulator &= maskForBits(bitsCollected);
+        }
+    }
+
+    const secondLast = bytes[30];
+    checksum += secondLast;
+    accumulator = ((accumulator << 8) | secondLast) >>> 0;
+    bitsCollected += 8;
+
+    const last = bytes[31];
+    checksum += last;
+    accumulator = ((accumulator << 8) | last) >>> 0;
+    bitsCollected += 8;
+
+    accumulator = ((accumulator << 8) | (checksum & 0xff)) >>> 0;
+    bitsCollected += 8;
+
+    while (bitsCollected >= 6) {
+        const index = (accumulator >> (bitsCollected - 6)) & 0x3f;
+        output.push(BASE64_URL_ALPHABET[index]);
+        bitsCollected -= 6;
+        accumulator &= maskForBits(bitsCollected);
+    }
+
+    return output.join("");
+}
+
+export function decodeAddress(value: string): Uint8Array {
+    if (value.length !== 46) {
+        throw new Error("Invalid address length");
+    }
+    if (!value.startsWith("ta")) {
+        throw new Error('Address must start with "ta"');
+    }
+
+    const output = new Uint8Array(32);
+    let checksum = 0;
+    let inIdx = 2;
+    let remaining = 40;
+    let outIdx = 0;
+
+    while (remaining >= 4) {
+        const a = BASE64_URL_MAP[value.charCodeAt(inIdx)];
+        const b = BASE64_URL_MAP[value.charCodeAt(inIdx + 1)];
+        const c = BASE64_URL_MAP[value.charCodeAt(inIdx + 2)];
+        const d = BASE64_URL_MAP[value.charCodeAt(inIdx + 3)];
+        if (a < 0 || b < 0 || c < 0 || d < 0) {
+            throw new Error("Invalid address encoding");
+        }
+        const triple = (a << 18) | (b << 12) | (c << 6) | d;
+        const byte1 = (triple >> 16) & 0xff;
+        const byte2 = (triple >> 8) & 0xff;
+        const byte3 = triple & 0xff;
+        checksum += byte1;
+        checksum += byte2;
+        checksum += byte3;
+        output[outIdx++] = byte1;
+        output[outIdx++] = byte2;
+        output[outIdx++] = byte3;
+        inIdx += 4;
+        remaining -= 4;
+    }
+
+    const a = BASE64_URL_MAP[value.charCodeAt(inIdx)];
+    const b = BASE64_URL_MAP[value.charCodeAt(inIdx + 1)];
+    const c = BASE64_URL_MAP[value.charCodeAt(inIdx + 2)];
+    const d = BASE64_URL_MAP[value.charCodeAt(inIdx + 3)];
+    if (a < 0 || b < 0 || c < 0 || d < 0) {
+        throw new Error("Invalid address encoding");
+    }
+
+    const triple = (a << 18) | (b << 12) | (c << 6) | d;
+    const byte1 = (triple >> 16) & 0xff;
+    const byte2 = (triple >> 8) & 0xff;
+    const incomingChecksum = triple & 0xff;
+
+    checksum += byte1;
+    checksum += byte2;
+    output[outIdx++] = byte1;
+    output[outIdx++] = byte2;
+
+    checksum &= 0xff;
+    if (checksum !== incomingChecksum) {
+        throw new Error("Address checksum mismatch");
+    }
+
+    return output;
+}
+
+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/proofs.ts

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

@@ -0,0 +1,34 @@
+import { create } from "@bufbuild/protobuf";
+
+import type { ThruClientContext } from "../core/client";
+import type { TrackTransactionResponse } from "../proto/thru/services/v1/streaming_service_pb";
+import { TrackTransactionRequestSchema } from "../proto/thru/services/v1/streaming_service_pb";
+import type { BytesLike } from "./helpers";
+import { toSignature as toSignatureMessage } from "./helpers";
+
+export interface TrackTransactionOptions {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+
+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,
+    });
+}

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

@@ -0,0 +1,274 @@
+import { create } from "@bufbuild/protobuf";
+
+import type { ThruClientContext } from "../core/client";
+import {
+    DEFAULT_COMPUTE_UNITS,
+    DEFAULT_EXPIRY_AFTER,
+    DEFAULT_FEE,
+    DEFAULT_MEMORY_UNITS,
+    DEFAULT_MIN_CONSENSUS,
+    DEFAULT_STATE_UNITS,
+    DEFAULT_TRANSACTION_VIEW,
+} from "../defaults";
+import type { ConsensusStatus, VersionContext } from "../proto/thru/common/v1/consensus_pb";
+import { AccountView } from "../proto/thru/core/v1/account_pb";
+import { Transaction as CoreTransaction, RawTransaction, TransactionView } from "../proto/thru/core/v1/transaction_pb";
+import { SendTransactionRequestSchema } from "../proto/thru/services/v1/command_service_pb";
+import {
+    GetRawTransactionRequestSchema,
+    GetTransactionRequestSchema,
+    GetTransactionStatusRequestSchema,
+    TransactionStatus,
+} from "../proto/thru/services/v1/query_service_pb";
+import {
+    Transaction as LocalTransaction,
+    TransactionBuilder,
+    type BuildTransactionParams,
+    type OptionalProofs,
+    type ProgramIdentifier,
+    type SignedTransactionResult,
+    type TransactionAccountsInput,
+    type TransactionContentInput,
+    type TransactionHeaderInput,
+} from "../transactions";
+import { parseAccountIdentifier, parseInstructionData } from "../transactions/utils";
+import type { BytesLike } from "./helpers";
+import { encodeSignature, toSignature as toSignatureMessage } from "./helpers";
+
+import { getAccount } from "./accounts";
+import { getBlockHeight } from "./height";
+
+export interface TransactionFeePayerConfig {
+    publicKey: BytesLike;
+    privateKey?: Uint8Array;
+}
+
+export interface TransactionAccountsConfig {
+    readWrite?: BytesLike[];
+    readOnly?: BytesLike[];
+}
+
+export interface TransactionContentConfig {
+    instructions?: BytesLike;
+    feePayerStateProof?: Uint8Array;
+    feePayerAccountMetaRaw?: Uint8Array;
+}
+
+export interface TransactionHeaderConfig {
+    fee?: bigint;
+    nonce?: bigint;
+    startSlot?: bigint;
+    expiryAfter?: number;
+    computeUnits?: number;
+    stateUnits?: number;
+    memoryUnits?: number;
+    flags?: number;
+}
+
+export interface BuildTransactionOptions {
+    feePayer: TransactionFeePayerConfig;
+    program: ProgramIdentifier;
+    header?: TransactionHeaderConfig;
+    accounts?: TransactionAccountsConfig;
+    content?: TransactionContentConfig;
+}
+
+export interface BuildAndSignTransactionOptions extends BuildTransactionOptions {
+    feePayer: TransactionFeePayerConfig & { privateKey: Uint8Array };
+}
+
+export interface TransactionQueryOptions {
+    view?: TransactionView;
+    versionContext?: VersionContext;
+    minConsensus?: ConsensusStatus;
+}
+
+export interface RawTransactionQueryOptions {
+    versionContext?: VersionContext;
+    minConsensus?: ConsensusStatus;
+}
+
+export async function getTransaction(
+    ctx: ThruClientContext,
+    signature: BytesLike,
+    options: TransactionQueryOptions = {},
+): Promise<CoreTransaction> {
+    const request = create(GetTransactionRequestSchema, {
+        signature: toSignatureMessage(signature),
+        view: options.view ?? DEFAULT_TRANSACTION_VIEW,
+        versionContext: options.versionContext,
+        minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS,
+    });
+    return ctx.query.getTransaction(request);
+}
+
+export async function getRawTransaction(
+    ctx: ThruClientContext,
+    signature: BytesLike,
+    options: RawTransactionQueryOptions = {},
+): Promise<RawTransaction> {
+    const request = create(GetRawTransactionRequestSchema, {
+        signature: toSignatureMessage(signature),
+        versionContext: options.versionContext,
+        minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS,
+    });
+    return ctx.query.getRawTransaction(request);
+}
+
+export async function getTransactionStatus(ctx: ThruClientContext, signature: BytesLike): Promise<TransactionStatus> {
+    const request = create(GetTransactionStatusRequestSchema, {
+        signature: toSignatureMessage(signature),
+    });
+    return ctx.query.getTransactionStatus(request);
+}
+
+export async function buildTransaction(
+    ctx: ThruClientContext,
+    options: BuildTransactionOptions,
+): Promise<LocalTransaction> {
+    const builder = createTransactionBuilder();
+    const params = await createBuildParams(ctx, options);
+    return builder.build(params);
+}
+
+export async function buildAndSignTransaction(
+    ctx: ThruClientContext,
+    options: BuildAndSignTransactionOptions,
+): Promise<SignedTransactionResult> {
+    const builder = createTransactionBuilder();
+    const params = await createBuildParams(ctx, options);
+    if (!params.feePayer.privateKey) {
+        throw new Error("Fee payer private key is required to sign the transaction");
+    }
+    return builder.buildAndSign(params);
+}
+
+export async function sendTransaction(
+    ctx: ThruClientContext,
+    transaction: LocalTransaction | Uint8Array,
+): Promise<string> {
+    const raw = transaction instanceof Uint8Array ? transaction : transaction.toWire();
+    return sendRawTransaction(ctx, raw);
+}
+
+async function sendRawTransaction(ctx: ThruClientContext, rawTransaction: Uint8Array): Promise<string> {
+    const request = create(SendTransactionRequestSchema, { rawTransaction });
+    const response = await ctx.command.sendTransaction(request);
+    if (!response.signature?.value) {
+        throw new Error("No signature returned from sendTransaction");
+    }
+    return encodeSignature(response.signature.value);
+}
+
+function createTransactionBuilder(): TransactionBuilder {
+    return new TransactionBuilder();
+}
+
+async function createBuildParams(
+    ctx: ThruClientContext,
+    options: BuildTransactionOptions,
+): Promise<BuildTransactionParams> {
+    const feePayerPublicKey = parseAccountIdentifier(options.feePayer.publicKey, "feePayer.publicKey");
+    const header = await createTransactionHeader(ctx, options.header ?? {}, feePayerPublicKey);
+    const accounts = parseAccounts(options.accounts);
+    const content = createContent(options.content);
+
+    return {
+        feePayer: {
+            publicKey: feePayerPublicKey,
+            privateKey: options.feePayer.privateKey,
+        },
+        program: options.program,
+        header,
+        accounts,
+        content,
+    };
+}
+
+async function createTransactionHeader(
+    ctx: ThruClientContext,
+    header: TransactionHeaderConfig,
+    feePayerPublicKey: Uint8Array,
+): Promise<TransactionHeaderInput> {
+    const nonce = header.nonce ?? (await fetchFeePayerNonce(ctx, feePayerPublicKey));
+    const startSlot = header.startSlot ?? (await fetchFinalizedSlot(ctx));
+    return {
+        fee: header.fee ?? DEFAULT_FEE,
+        nonce,
+        startSlot,
+        expiryAfter: header.expiryAfter ?? DEFAULT_EXPIRY_AFTER,
+        computeUnits: header.computeUnits ?? DEFAULT_COMPUTE_UNITS,
+        stateUnits: header.stateUnits ?? DEFAULT_STATE_UNITS,
+        memoryUnits: header.memoryUnits ?? DEFAULT_MEMORY_UNITS,
+        flags: header.flags,
+    };
+}
+
+function parseAccounts(accounts?: TransactionAccountsConfig): TransactionAccountsInput | undefined {
+    if (!accounts) {
+        return undefined;
+    }
+    const readWrite = accounts.readWrite?.map((value, index) =>
+        parseAccountIdentifier(value, `accounts.readWrite[${index}]`),
+    );
+    const readOnly = accounts.readOnly?.map((value, index) =>
+        parseAccountIdentifier(value, `accounts.readOnly[${index}]`),
+    );
+
+    const result: TransactionAccountsInput = {};
+    if (readWrite && readWrite.length > 0) {
+        result.readWriteAccounts = readWrite;
+    }
+    if (readOnly && readOnly.length > 0) {
+        result.readOnlyAccounts = readOnly;
+    }
+
+    if (!result.readWriteAccounts && !result.readOnlyAccounts) {
+        return undefined;
+    }
+
+    return result;
+}
+
+function createContent(content?: TransactionContentConfig): TransactionContentInput | undefined {
+    if (!content) {
+        return undefined;
+    }
+
+    const instructions = parseInstructionData(content.instructions);
+    const proofs: OptionalProofs = {};
+    if (content.feePayerStateProof) {
+        proofs.feePayerStateProof = new Uint8Array(content.feePayerStateProof);
+    }
+    if (content.feePayerAccountMetaRaw) {
+        proofs.feePayerAccountMetaRaw = new Uint8Array(content.feePayerAccountMetaRaw);
+    }
+    const hasProofs = Boolean(proofs.feePayerStateProof || proofs.feePayerAccountMetaRaw);
+
+    if (!instructions && !hasProofs) {
+        return undefined;
+    }
+
+    const result: TransactionContentInput = {};
+    if (instructions) {
+        result.instructions = instructions;
+    }
+    if (hasProofs) {
+        result.proofs = proofs;
+    }
+    return result;
+}
+
+async function fetchFeePayerNonce(ctx: ThruClientContext, feePayer: Uint8Array): Promise<bigint> {
+    const account = await getAccount(ctx, feePayer, { view: AccountView.FULL });
+    const nonce = account.meta?.nonce;
+    if (nonce === undefined) {
+        throw new Error("Fee payer account nonce is unavailable");
+    }
+    return nonce;
+}
+
+async function fetchFinalizedSlot(ctx: ThruClientContext): Promise<bigint> {
+    const height = await getBlockHeight(ctx);
+    return height.finalized;
+}