@thru/thru-sdk 0.1.19 → 0.1.21

package/thru-ts-client-sdk/transactions/__tests__/utils.test.ts

@@ -1,214 +0,0 @@
-import { decodeAddress } from "@thru/helpers";
-import { describe, expect, it } from "vitest";
-import { generateTestAddress, generateTestPubkey } from "../../__tests__/helpers/test-utils";
-import {
-    normalizeAccountList,
-    parseAccountIdentifier,
-    parseInstructionData,
-    resolveProgramIdentifier,
-} from "../utils";
-
-describe("transaction utils", () => {
-  describe("normalizeAccountList", () => {
-    it("should return empty array for empty input", () => {
-      const result = normalizeAccountList([]);
-      expect(result).toEqual([]);
-    });
-
-    it("should return single account unchanged", () => {
-      const account = generateTestPubkey(0x01);
-      const result = normalizeAccountList([account]);
-      
-      expect(result).toHaveLength(1);
-      expect(result[0]).toEqual(account);
-    });
-
-    it("should deduplicate accounts", () => {
-      const account1 = generateTestPubkey(0x01);
-      const account2 = generateTestPubkey(0x02);
-      const account1Duplicate = new Uint8Array(account1);
-      
-      const result = normalizeAccountList([account1, account2, account1Duplicate]);
-      
-      expect(result).toHaveLength(2);
-      expect(result[0]).toEqual(account1);
-      expect(result[1]).toEqual(account2);
-    });
-
-    it("should sort accounts", () => {
-      const account1 = generateTestPubkey(0x02);
-      const account2 = generateTestPubkey(0x01);
-      const account3 = generateTestPubkey(0x03);
-      
-      const result = normalizeAccountList([account1, account2, account3]);
-      
-      expect(result).toHaveLength(3);
-      // Should be sorted
-      expect(result[0]).toEqual(account2); // 0x01
-      expect(result[1]).toEqual(account1); // 0x02
-      expect(result[2]).toEqual(account3); // 0x03
-    });
-
-    it("should throw error for too many accounts", () => {
-      const accounts = Array.from({ length: 1025 }, () => generateTestPubkey());
-      
-      expect(() => normalizeAccountList(accounts)).toThrow("Too many accounts provided: 1025 (max 1024)");
-    });
-
-    it("should throw error for invalid account length", () => {
-      const invalidAccount = new Uint8Array(31); // Should be 32
-      
-      expect(() => normalizeAccountList([invalidAccount])).toThrow("Account addresses must contain 32 bytes");
-    });
-  });
-
-  describe("resolveProgramIdentifier", () => {
-    it("should accept Uint8Array with 32 bytes", () => {
-      const program = generateTestPubkey(0x01);
-      const result = resolveProgramIdentifier(program);
-      
-      expect(result).toEqual(program);
-      expect(result).not.toBe(program); // Should be a copy
-    });
-
-    it("should accept ta- prefixed address string", () => {
-      const address = generateTestAddress(0x01);
-      const result = resolveProgramIdentifier(address);
-      
-      expect(result.length).toBe(32);
-      const decoded = decodeAddress(address);
-      expect(result).toEqual(decoded);
-    });
-
-    it("should accept hex string", () => {
-      const programBytes = generateTestPubkey(0x01);
-      const hexString = Array.from(programBytes)
-        .map(b => b.toString(16).padStart(2, "0"))
-        .join("");
-      
-      const result = resolveProgramIdentifier(hexString);
-      
-      expect(result.length).toBe(32);
-      expect(result).toEqual(programBytes);
-    });
-
-    it("should throw error for Uint8Array with wrong length", () => {
-      const invalidProgram = new Uint8Array(31);
-      
-      expect(() => resolveProgramIdentifier(invalidProgram)).toThrow("Program public key must contain 32 bytes");
-    });
-
-    it("should throw error for invalid string format", () => {
-      expect(() => resolveProgramIdentifier("invalid-format")).toThrow("Unsupported program identifier format");
-    });
-
-    it("should throw error for hex string with wrong length", () => {
-      const shortHex = "0123"; // Too short
-      
-      expect(() => resolveProgramIdentifier(shortHex)).toThrow("Hex-encoded program key must contain 32 bytes");
-    });
-  });
-
-  describe("parseAccountIdentifier", () => {
-    it("should accept Uint8Array with 32 bytes", () => {
-      const account = generateTestPubkey(0x01);
-      const result = parseAccountIdentifier(account, "testField");
-      
-      expect(result).toEqual(account);
-      expect(result).not.toBe(account); // Should be a copy
-    });
-
-    it("should accept ta- prefixed address string", () => {
-      const address = generateTestAddress(0x01);
-      const result = parseAccountIdentifier(address, "testField");
-      
-      expect(result.length).toBe(32);
-      const decoded = decodeAddress(address);
-      expect(result).toEqual(decoded);
-    });
-
-    it("should accept hex string", () => {
-      const accountBytes = generateTestPubkey(0x01);
-      const hexString = Array.from(accountBytes)
-        .map(b => b.toString(16).padStart(2, "0"))
-        .join("");
-      
-      const result = parseAccountIdentifier(hexString, "testField");
-      
-      expect(result.length).toBe(32);
-      expect(result).toEqual(accountBytes);
-    });
-
-    it("should throw error for Uint8Array with wrong length", () => {
-      const invalidAccount = new Uint8Array(31);
-      
-      expect(() => parseAccountIdentifier(invalidAccount, "testField")).toThrow("testField must contain 32 bytes");
-    });
-
-    it("should throw error for invalid string format", () => {
-      expect(() => parseAccountIdentifier("invalid-format", "testField")).toThrow(
-        "testField must be a 32-byte value, ta-address, or 64-character hex string"
-      );
-    });
-
-    it("should include field name in error message", () => {
-      const invalidAccount = new Uint8Array(31);
-      
-      expect(() => parseAccountIdentifier(invalidAccount, "myCustomField")).toThrow("myCustomField must contain 32 bytes");
-    });
-  });
-
-  describe("parseInstructionData", () => {
-    it("should return undefined for undefined input", () => {
-      const result = parseInstructionData(undefined);
-      expect(result).toBeUndefined();
-    });
-
-    it("should accept Uint8Array", () => {
-      const data = new Uint8Array([0x01, 0x02, 0x03]);
-      const result = parseInstructionData(data);
-      
-      expect(result).toEqual(data);
-      expect(result).not.toBe(data); // Should be a copy
-    });
-
-    it("should accept empty Uint8Array", () => {
-      const data = new Uint8Array(0);
-      const result = parseInstructionData(data);
-      
-      expect(result).toEqual(data);
-    });
-
-    it("should accept hex string", () => {
-      const dataBytes = new Uint8Array([0x01, 0x02, 0x03]);
-      const hexString = Array.from(dataBytes)
-        .map(b => b.toString(16).padStart(2, "0"))
-        .join("");
-      
-      const result = parseInstructionData(hexString);
-      
-      expect(result).toEqual(dataBytes);
-    });
-
-    it("should accept empty hex string", () => {
-      const result = parseInstructionData("");
-      
-      expect(result).toBeInstanceOf(Uint8Array);
-      expect(result?.length).toBe(0);
-    });
-
-    it("should throw error for invalid string format", () => {
-      expect(() => parseInstructionData("not-hex")).toThrow("Instruction data must be provided as hex string or Uint8Array");
-    });
-
-    it("should handle large instruction data", () => {
-      const largeData = new Uint8Array(1000);
-      largeData.fill(0x42);
-      const result = parseInstructionData(largeData);
-      
-      expect(result).toEqual(largeData);
-      expect(result?.length).toBe(1000);
-    });
-  });
-});
-

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

@@ -1,3 +0,0 @@
-export * from "./Transaction";
-export * from "./TransactionBuilder";
-export * from "./types";

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

@@ -1,74 +0,0 @@
-import { BytesLike } from "@thru/helpers";
-
-export type Bytes32 = Uint8Array;
-export type Bytes64 = Uint8Array;
-
-export type AccountAddress = Bytes32;
-
-export type ProgramIdentifier = BytesLike;
-
-export interface ResourceLimits {
-    computeUnits?: number;
-    stateUnits?: number;
-    memoryUnits?: number;
-}
-
-export interface OptionalProofs {
-    feePayerStateProof?: Uint8Array;
-    feePayerAccountMetaRaw?: Uint8Array;
-}
-
-export interface TransactionHeaderInput extends ResourceLimits {
-    fee: bigint;
-    nonce: bigint;
-    startSlot: bigint;
-    expiryAfter?: number;
-    flags?: number;
-}
-
-export interface TransactionAccountsInput {
-    readWriteAccounts?: AccountAddress[];
-    readOnlyAccounts?: AccountAddress[];
-}
-
-/**
- * Builder context provided to instruction data functions.
- * Contains all transaction accounts in their final sorted order and helper functions
- * for looking up account indexes.
- */
-export interface TransactionBuilderContext {
-    /** All accounts in final transaction order: [feePayer, program, ...readWrite, ...readOnly] */
-    accounts: AccountAddress[];
-    /** Get the index of an account by its public key. Throws if account is not found in transaction. */
-    getAccountIndex: (pubkey: AccountAddress) => number;
-}
-
-
-
-export interface FeePayerInput {
-    publicKey: AccountAddress;
-    privateKey?: Bytes32;
-}
-
-export interface BuildTransactionParams {
-    feePayer: FeePayerInput;
-    program: ProgramIdentifier;
-    header: TransactionHeaderInput;
-    accounts?: TransactionAccountsInput;
-    instructionData?: BytesLike;
-    proofs?: OptionalProofs;
-}
-
-export interface BuiltTransactionResult {
-    transaction: TransactionLike;
-}
-
-export interface SignedTransactionResult extends BuiltTransactionResult {
-    signature: Bytes64;
-    rawTransaction: Uint8Array;
-}
-
-// Forward declaration to avoid circular imports in type layer
-export interface TransactionLike {
-    toWire(): Uint8Array;
-}

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

@@ -1,132 +0,0 @@
-import { BytesLike, decodeAddress, hexToBytes, isHexString } from "@thru/helpers";
-import type { AccountAddress, ProgramIdentifier } from "./types";
-
-const ACCOUNT_LIMIT = 1024;
-
-export function normalizeAccountList(accounts: AccountAddress[]): AccountAddress[] {
-    if (accounts.length === 0) {
-        return [];
-    }
-
-    if (accounts.length > ACCOUNT_LIMIT) {
-        throw new Error(`Too many accounts provided: ${accounts.length} (max ${ACCOUNT_LIMIT})`);
-    }
-
-    const deduped = dedupeAccountList(accounts);
-    return deduped;
-}
-
-function dedupeAccountList(accounts: AccountAddress[]): AccountAddress[] {
-    const seen = new Map<string, AccountAddress>();
-    for (const account of accounts) {
-        if (account.length !== 32) {
-            throw new Error("Account addresses must contain 32 bytes");
-        }
-
-        const key = toHex(account);
-        if (!seen.has(key)) {
-            seen.set(key, new Uint8Array(account));
-        }
-    }
-
-    return Array.from(seen.values()).sort(compareAccounts);
-}
-
-function compareAccounts(a: Uint8Array, b: Uint8Array): number {
-    for (let i = 0; i < 32; i++) {
-        if (a[i] !== b[i]) {
-            return a[i] - b[i];
-        }
-    }
-    return 0;
-}
-
-function toHex(bytes: Uint8Array): string {
-    let result = "";
-    for (let i = 0; i < bytes.length; i++) {
-        const hex = bytes[i].toString(16).padStart(2, "0");
-        result += hex;
-    }
-    return result;
-}
-
-export function resolveProgramIdentifier(identifier: ProgramIdentifier): AccountAddress {
-    if (identifier instanceof Uint8Array) {
-        if (identifier.length !== 32) {
-            throw new Error("Program public key must contain 32 bytes");
-        }
-        return copyAccount(identifier);
-    }
-
-    if (typeof identifier === "string") {
-        const parsed = parseProgramString(identifier);
-        if (parsed) {
-            return parsed;
-        }
-    }
-
-    throw new Error("Unsupported program identifier format");
-}
-
-function parseProgramString(value: string): AccountAddress | undefined {
-    if (value.startsWith("ta") && value.length === 46) {
-        return copyAccount(decodeAddress(value));
-    }
-    if (isHexString(value)) {
-        const bytes = hexToBytes(value);
-        if (bytes.length !== 32) {
-            throw new Error("Hex-encoded program key must contain 32 bytes");
-        }
-        return bytes;
-    }
-    return undefined;
-}
-
-function copyAccount(value: AccountAddress): AccountAddress {
-    if (value.length !== 32) {
-        throw new Error("Program public key must contain 32 bytes");
-    }
-    return new Uint8Array(value);
-}
-
-export function parseAccountIdentifier(value: BytesLike, field: string): AccountAddress {
-    if (value instanceof Uint8Array) {
-        if (value.length !== 32) {
-            throw new Error(`${field} must contain 32 bytes`);
-        }
-        return new Uint8Array(value);
-    }
-
-    if (typeof value === "string") {
-        if (value.startsWith("ta") && value.length === 46) {
-            return copyAccount(decodeAddress(value));
-        }
-        if (isHexString(value)) {
-            const bytes = hexToBytes(value);
-            if (bytes.length !== 32) {
-                throw new Error(`${field} hex string must decode to 32 bytes`);
-            }
-            return bytes;
-        }
-    }
-
-    throw new Error(`${field} must be a 32-byte value, ta-address, or 64-character hex string`);
-}
-
-export function parseInstructionData(value?: BytesLike): Uint8Array | undefined {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (value instanceof Uint8Array) {
-        return new Uint8Array(value);
-    }
-    if (typeof value === "string") {
-        if (value.length === 0) {
-            return new Uint8Array();
-        }
-        if (isHexString(value)) {
-            return hexToBytes(value);
-        }
-    }
-    throw new Error("Instruction data must be provided as hex string or Uint8Array");
-}

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

@@ -1,8 +0,0 @@
-import { BytesLike } from "@thru/helpers";
-import { StateProofType } from "../proto/thru/core/v1/state_pb";
-
-export type GenerateStateProofOptions = {
-    address?: BytesLike;
-    proofType: StateProofType;
-    targetSlot: bigint;
-}

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

@@ -1,27 +0,0 @@
-import { BytesLike } from "@thru/helpers";
-
-import { TransactionHeaderInput } from "../transactions";
-
-export type BlockSelector = { slot: number | bigint } | { blockHash: BytesLike };
-
-export function isSlotSelector(selector: BlockSelector): selector is { slot: number | bigint } {
-    return "slot" in selector;
-}
-
-export function mergeTransactionHeader(
-    defaults: TransactionHeaderInput,
-    overrides?: Partial<TransactionHeaderInput>,
-): TransactionHeaderInput {
-    if (!overrides) {
-        return defaults;
-    }
-
-    const sanitized = Object.fromEntries(
-        Object.entries(overrides).filter(([, value]) => value !== undefined),
-    ) as Partial<TransactionHeaderInput>;
-
-    return {
-        ...defaults,
-        ...sanitized,
-    };
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./thru-ts-client-sdk",
-  },
-  "include": ["thru-ts-client-sdk/**/*"],
-  "exclude": ["node_modules", "dist", "thru-ts-client-sdk/**/__tests__/**"]
-}

package/tsup.config.ts

@@ -1,14 +0,0 @@
-import { defineConfig } from 'tsup';
-
-export default defineConfig({
-  entry: {
-    sdk: 'thru-ts-client-sdk/sdk.ts',
-    client: 'thru-ts-client-sdk/client.ts'
-  },
-  format: ['esm'],
-  dts: true,
-  sourcemap: true,
-  clean: true,
-  treeshake: true,
-  metafile: true
-});

package/vitest.config.ts

@@ -1,31 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    environment: "jsdom",
-    globals: true, // Enable describe, it, expect globally
-    include: ["thru-ts-client-sdk/**/*.{test,spec}.{ts,tsx}"],
-    exclude: [
-      "**/node_modules/**",
-      "**/dist/**",
-      "**/proto/**",
-      "**/test-scripts/**",
-    ],
-    // Don't fail when no tests are found (useful during development)
-    passWithNoTests: true,
-    coverage: {
-      provider: "v8",
-      reporter: ["text", "json", "html"],
-      include: ["thru-ts-client-sdk/**/*.ts"],
-      exclude: [
-        "**/__tests__/**",
-        "**/proto/**",
-        "**/dist/**",
-        "**/test-scripts/**",
-        "**/*.test.ts",
-        "**/*.spec.ts",
-      ],
-    },
-  },
-});
-