@thru/thru-sdk 0.1.19 → 0.1.21

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

@@ -1,240 +0,0 @@
-import { signAsync } from "@noble/ed25519";
-import type { AccountAddress, Bytes64, OptionalProofs, TransactionAccountsInput, TransactionHeaderInput } from "./types";
-
-const DEFAULT_FLAGS = 0;
-const TRANSACTION_VERSION = 1;
-const SIGNATURE_LENGTH = 64;
-const PUBKEY_LENGTH = 32;
-const HEADER_SIZE = 176;
-const SIGNATURE_PREFIX_SIZE = 64;
-
-export class Transaction {
-    readonly feePayer: AccountAddress;
-    readonly program: AccountAddress;
-
-    readonly fee: bigint;
-    readonly nonce: bigint;
-    readonly startSlot: bigint;
-    readonly expiryAfter: number;
-
-    readonly requestedComputeUnits: number;
-    readonly requestedStateUnits: number;
-    readonly requestedMemoryUnits: number;
-    readonly flags: number;
-
-    readonly readWriteAccounts: AccountAddress[];
-    readonly readOnlyAccounts: AccountAddress[];
-
-    readonly instructionData?: Uint8Array;
-    readonly feePayerStateProof?: Uint8Array;
-    readonly feePayerAccountMetaRaw?: Uint8Array;
-
-    private signature?: Bytes64;
-
-    constructor(params: {
-        feePayer: AccountAddress;
-        program: AccountAddress;
-        header: TransactionHeaderInput;
-        accounts?: TransactionAccountsInput;
-        instructionData?: Uint8Array;
-        proofs?: OptionalProofs;
-    }) {
-        this.feePayer = copyKey(params.feePayer);
-        this.program = copyKey(params.program);
-
-        this.fee = params.header.fee;
-        this.nonce = params.header.nonce;
-        this.startSlot = params.header.startSlot;
-        this.expiryAfter = params.header.expiryAfter ?? 0;
-
-        this.requestedComputeUnits = params.header.computeUnits ?? 0;
-        this.requestedStateUnits = params.header.stateUnits ?? 0;
-        this.requestedMemoryUnits = params.header.memoryUnits ?? 0;
-        this.flags = params.header.flags ?? DEFAULT_FLAGS;
-
-        this.readWriteAccounts = params.accounts?.readWriteAccounts
-            ? params.accounts.readWriteAccounts.map(copyKey)
-            : [];
-        this.readOnlyAccounts = params.accounts?.readOnlyAccounts
-            ? params.accounts.readOnlyAccounts.map(copyKey)
-            : [];
-
-        this.instructionData = params.instructionData ? new Uint8Array(params.instructionData) : undefined;
-        this.feePayerStateProof = params.proofs?.feePayerStateProof
-            ? new Uint8Array(params.proofs.feePayerStateProof)
-            : undefined;
-        this.feePayerAccountMetaRaw = params.proofs?.feePayerAccountMetaRaw
-            ? new Uint8Array(params.proofs.feePayerAccountMetaRaw)
-            : undefined;
-    }
-
-    getSignature(): Bytes64 | undefined {
-        return this.signature ? new Uint8Array(this.signature) : undefined;
-    }
-
-    setSignature(signature: Bytes64): void {
-        if (signature.length !== SIGNATURE_LENGTH) {
-            throw new Error(`Signature must contain ${SIGNATURE_LENGTH} bytes`);
-        }
-        this.signature = new Uint8Array(signature);
-    }
-
-    async sign(privateKey: Uint8Array): Promise<Bytes64> {
-        if (privateKey.length !== 32) {
-            throw new Error("Fee payer private key must contain 32 bytes");
-        }
-        const payload = this.toWireForSigning();
-        const signature = await signAsync(payload, privateKey);
-        if (signature.length !== SIGNATURE_LENGTH) {
-            throw new Error("ed25519 signing produced an invalid signature");
-        }
-        this.signature = signature;
-        return new Uint8Array(signature);
-    }
-
-    toWireForSigning(): Uint8Array {
-        const header = this.createHeader(undefined);
-        const view = new Uint8Array(header);
-        return this.buildWirePayload(view.subarray(SIGNATURE_PREFIX_SIZE));
-    }
-
-    toWire(): Uint8Array {
-        const header = this.createHeader(this.signature);
-        const payload = this.buildWirePayload(new Uint8Array(header));
-        return payload;
-    }
-
-    private createHeader(signature: Uint8Array | undefined): ArrayBufferLike {
-        const buffer = new ArrayBuffer(HEADER_SIZE);
-        const headerBytes = new Uint8Array(buffer);
-        const view = new DataView(buffer);
-
-        // Fee payer signature (64 bytes)
-        if (signature) {
-            if (signature.length !== SIGNATURE_LENGTH) {
-                throw new Error(`Signature must contain ${SIGNATURE_LENGTH} bytes`);
-            }
-            headerBytes.set(signature, 0);
-        } else {
-            headerBytes.fill(0, 0, SIGNATURE_LENGTH);
-        }
-
-        let offset = SIGNATURE_PREFIX_SIZE;
-        view.setUint8(offset, TRANSACTION_VERSION);
-        offset += 1;
-
-        view.setUint8(offset, this.flags & 0xff);
-        offset += 1;
-
-        view.setUint16(offset, this.readWriteAccounts.length, true);
-        offset += 2;
-
-        view.setUint16(offset, this.readOnlyAccounts.length, true);
-        offset += 2;
-
-        const instructionDataLength = this.instructionData?.length ?? 0;
-        if (instructionDataLength > 0xffff) {
-            throw new Error("Instruction data exceeds maximum length (65535 bytes)");
-        }
-        view.setUint16(offset, instructionDataLength, true);
-        offset += 2;
-
-        view.setUint32(offset, ensureUint32(this.requestedComputeUnits), true);
-        offset += 4;
-
-        view.setUint16(offset, ensureUint16(this.requestedStateUnits), true);
-        offset += 2;
-
-        view.setUint16(offset, ensureUint16(this.requestedMemoryUnits), true);
-        offset += 2;
-
-        view.setBigUint64(offset, ensureBigUint64(this.fee), true);
-        offset += 8;
-
-        view.setBigUint64(offset, ensureBigUint64(this.nonce), true);
-        offset += 8;
-
-        view.setBigUint64(offset, ensureBigUint64(this.startSlot), true);
-        offset += 8;
-
-        view.setUint32(offset, ensureUint32(this.expiryAfter), true);
-        offset += 4;
-
-        // padding_0 (4 bytes) zeroed by default
-        offset += 4;
-
-        headerBytes.set(this.feePayer, offset);
-        offset += PUBKEY_LENGTH;
-
-        headerBytes.set(this.program, offset);
-
-        return buffer;
-    }
-
-    private buildWirePayload(headerWithoutSignature: Uint8Array): Uint8Array {
-        const dynamicLength =
-            this.readWriteAccounts.length * PUBKEY_LENGTH +
-            this.readOnlyAccounts.length * PUBKEY_LENGTH +
-            (this.instructionData?.length ?? 0) +
-            (this.feePayerStateProof?.length ?? 0) +
-            (this.feePayerAccountMetaRaw?.length ?? 0);
-
-        const result = new Uint8Array(headerWithoutSignature.length + dynamicLength);
-        result.set(headerWithoutSignature, 0);
-
-        let offset = headerWithoutSignature.length;
-        offset = appendAccountList(result, offset, this.readWriteAccounts);
-        offset = appendAccountList(result, offset, this.readOnlyAccounts);
-        if (this.instructionData) {
-            result.set(this.instructionData, offset);
-            offset += this.instructionData.length;
-        }
-        if (this.feePayerStateProof) {
-            result.set(this.feePayerStateProof, offset);
-            offset += this.feePayerStateProof.length;
-        }
-        if (this.feePayerAccountMetaRaw) {
-            result.set(this.feePayerAccountMetaRaw, offset);
-            offset += this.feePayerAccountMetaRaw.length;
-        }
-
-        return result;
-    }
-}
-
-function appendAccountList(target: Uint8Array, start: number, accounts: AccountAddress[]): number {
-    let offset = start;
-    for (const account of accounts) {
-        target.set(account, offset);
-        offset += PUBKEY_LENGTH;
-    }
-    return offset;
-}
-
-function ensureUint16(value: number): number {
-    if (!Number.isInteger(value) || value < 0 || value > 0xffff) {
-        throw new Error("Value must fit within uint16 range");
-    }
-    return value;
-}
-
-function ensureUint32(value: number): number {
-    if (!Number.isInteger(value) || value < 0 || value > 0xffffffff) {
-        throw new Error("Value must fit within uint32 range");
-    }
-    return value;
-}
-
-function ensureBigUint64(value: bigint): bigint {
-    if (value < 0n || value > 0xffff_ffff_ffff_ffffn) {
-        throw new Error("Value must fit within uint64 range");
-    }
-    return value;
-}
-
-function copyKey(source: AccountAddress): AccountAddress {
-    if (source.length !== PUBKEY_LENGTH) {
-        throw new Error("Public keys must contain 32 bytes");
-    }
-    return new Uint8Array(source);
-}

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

@@ -1,53 +0,0 @@
-import { Transaction } from "./Transaction";
-import type {
-    BuildTransactionParams,
-    SignedTransactionResult,
-    TransactionAccountsInput
-} from "./types";
-import { normalizeAccountList, parseInstructionData, resolveProgramIdentifier } from "./utils";
-
-const FLAG_HAS_FEE_PAYER_PROOF = 1 << 0;
-
-export class TransactionBuilder {
-    build(params: BuildTransactionParams): Transaction {
-        const program = resolveProgramIdentifier(params.program);
-        const accounts = this.normalizeAccounts(params.accounts);
-        const baseFlags = params.header.flags ?? 0;
-        const flags = params.proofs?.feePayerStateProof ? baseFlags | FLAG_HAS_FEE_PAYER_PROOF : baseFlags;
-
-        /* Parse instruction data from BytesLike */
-        const instructionData = parseInstructionData(params.instructionData);
-
-        return new Transaction({
-            feePayer: params.feePayer.publicKey,
-            program,
-            header: {
-                ...params.header,
-                flags,
-            },
-            accounts,
-            instructionData,
-            proofs: params.proofs,
-        });
-    }
-
-    async buildAndSign(params: BuildTransactionParams): Promise<SignedTransactionResult> {
-        if (!params.feePayer.privateKey) {
-            throw new Error("Fee payer private key is required to sign the transaction");
-        }
-        const transaction = this.build(params);
-        const signature = await transaction.sign(params.feePayer.privateKey);
-        const rawTransaction = transaction.toWire();
-        return { transaction, signature, rawTransaction };
-    }
-
-    private normalizeAccounts(accounts?: TransactionAccountsInput): TransactionAccountsInput | undefined {
-        if (!accounts) {
-            return undefined;
-        }
-        return {
-            readWriteAccounts: normalizeAccountList(accounts.readWriteAccounts ?? []),
-            readOnlyAccounts: normalizeAccountList(accounts.readOnlyAccounts ?? []),
-        };
-    }
-}

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

@@ -1,411 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { TransactionBuilder } from "../TransactionBuilder";
-import { Transaction } from "../Transaction";
-import { generateTestPubkey, generateTestAddress } from "../../__tests__/helpers/test-utils";
-import type { BuildTransactionParams } from "../types";
-
-describe("TransactionBuilder", () => {
-  const createBuilder = () => new TransactionBuilder();
-
-  const createMinimalParams = (): BuildTransactionParams => {
-    return {
-      feePayer: {
-        publicKey: generateTestPubkey(0x01),
-      },
-      program: generateTestPubkey(0x02),
-      header: {
-        fee: 1n,
-        nonce: 2n,
-        startSlot: 3n,
-      },
-    };
-  };
-
-  const createPrivateKey = (): Uint8Array => {
-    // Ed25519 private key is 32 bytes (seed), but we need to generate a valid one
-    // For testing, we'll use a 32-byte array
-    const privateKey = new Uint8Array(32);
-    privateKey.fill(0x42);
-    return privateKey;
-  };
-
-  describe("build", () => {
-    it("should build transaction with minimal params", () => {
-      const builder = createBuilder();
-      const params = createMinimalParams();
-      
-      const transaction = builder.build(params);
-      
-      expect(transaction).toBeInstanceOf(Transaction);
-      expect(transaction.feePayer).toEqual(params.feePayer.publicKey);
-      expect(transaction.program).toEqual(params.program);
-      expect(transaction.fee).toBe(params.header.fee);
-      expect(transaction.nonce).toBe(params.header.nonce);
-      expect(transaction.startSlot).toBe(params.header.startSlot);
-    });
-
-    it("should build transaction with all header fields", () => {
-      const builder = createBuilder();
-      const params: BuildTransactionParams = {
-        ...createMinimalParams(),
-        header: {
-          fee: 10n,
-          nonce: 20n,
-          startSlot: 30n,
-          expiryAfter: 100,
-          computeUnits: 300_000_000,
-          stateUnits: 10_000,
-          memoryUnits: 10_000,
-          flags: 1,
-        },
-      };
-      
-      const transaction = builder.build(params);
-      
-      expect(transaction.fee).toBe(10n);
-      expect(transaction.nonce).toBe(20n);
-      expect(transaction.startSlot).toBe(30n);
-      expect(transaction.expiryAfter).toBe(100);
-      expect(transaction.requestedComputeUnits).toBe(300_000_000);
-      expect(transaction.requestedStateUnits).toBe(10_000);
-      expect(transaction.requestedMemoryUnits).toBe(10_000);
-      expect(transaction.flags).toBe(1);
-    });
-
-    it("should accept program as Uint8Array", () => {
-      const builder = createBuilder();
-      const program = generateTestPubkey(0x02);
-      const params: BuildTransactionParams = {
-        ...createMinimalParams(),
-        program,
-      };
-      
-      const transaction = builder.build(params);
-      
-      expect(transaction.program).toEqual(program);
-    });
-
-    it("should accept program as ta- address string", () => {
-      const builder = createBuilder();
-      const programAddress = generateTestAddress(0x02);
-      const params: BuildTransactionParams = {
-        ...createMinimalParams(),
-        program: programAddress,
-      };
-      
-      const transaction = builder.build(params);
-      
-      expect(transaction.program.length).toBe(32);
-    });
-
-    it("should accept program as hex string", () => {
-      const builder = createBuilder();
-      const programBytes = generateTestPubkey(0x02);
-      const hexString = Array.from(programBytes)
-        .map(b => b.toString(16).padStart(2, "0"))
-        .join("");
-      const params: BuildTransactionParams = {
-        ...createMinimalParams(),
-        program: hexString,
-      };
-      
-      const transaction = builder.build(params);
-      
-      expect(transaction.program).toEqual(programBytes);
-    });
-
-    it("should normalize and sort accounts", () => {
-      const builder = createBuilder();
-      const account1 = generateTestPubkey(0x03);
-      const account2 = generateTestPubkey(0x04);
-      const account3 = generateTestPubkey(0x02);
-      
-      const params: BuildTransactionParams = {
-        ...createMinimalParams(),
-        accounts: {
-          readWriteAccounts: [account1, account2, account3],
-        },
-      };
-      
-      const transaction = builder.build(params);
-      
-      expect(transaction.readWriteAccounts).toHaveLength(3);
-      // Should be sorted
-      expect(transaction.readWriteAccounts[0]).toEqual(account3); // 0x02
-      expect(transaction.readWriteAccounts[1]).toEqual(account1); // 0x03
-      expect(transaction.readWriteAccounts[2]).toEqual(account2); // 0x04
-    });
-
-    it("should deduplicate accounts", () => {
-      const builder = createBuilder();
-      const account1 = generateTestPubkey(0x03);
-      const account1Duplicate = new Uint8Array(account1);
-      
-      const params: BuildTransactionParams = {
-        ...createMinimalParams(),
-        accounts: {
-          readWriteAccounts: [account1, account1Duplicate],
-        },
-      };
-      
-      const transaction = builder.build(params);
-      
-      expect(transaction.readWriteAccounts).toHaveLength(1);
-      expect(transaction.readWriteAccounts[0]).toEqual(account1);
-    });
-
-    it("should handle read-only accounts", () => {
-      const builder = createBuilder();
-      const readOnlyAccount = generateTestPubkey(0x05);
-      
-      const params: BuildTransactionParams = {
-        ...createMinimalParams(),
-        accounts: {
-          readOnlyAccounts: [readOnlyAccount],
-        },
-      };
-      
-      const transaction = builder.build(params);
-      
-      expect(transaction.readOnlyAccounts).toHaveLength(1);
-      expect(transaction.readOnlyAccounts[0]).toEqual(readOnlyAccount);
-    });
-
-    it("should handle both read-write and read-only accounts", () => {
-      const builder = createBuilder();
-      const rwAccount = generateTestPubkey(0x03);
-      const roAccount = generateTestPubkey(0x04);
-      
-      const params: BuildTransactionParams = {
-        ...createMinimalParams(),
-        accounts: {
-          readWriteAccounts: [rwAccount],
-          readOnlyAccounts: [roAccount],
-        },
-      };
-      
-      const transaction = builder.build(params);
-      
-      expect(transaction.readWriteAccounts).toHaveLength(1);
-      expect(transaction.readOnlyAccounts).toHaveLength(1);
-    });
-
-    it("should handle instruction data as Uint8Array", () => {
-      const builder = createBuilder();
-      const instructionData = new Uint8Array([0x01, 0x02, 0x03]);
-      
-      const params: BuildTransactionParams = {
-        ...createMinimalParams(),
-        instructionData,
-      };
-      
-      const transaction = builder.build(params);
-      
-      expect(transaction.instructionData).toEqual(instructionData);
-    });
-
-    it("should handle instruction data as hex string", () => {
-      const builder = createBuilder();
-      const instructionBytes = new Uint8Array([0x01, 0x02, 0x03]);
-      const hexString = Array.from(instructionBytes)
-        .map(b => b.toString(16).padStart(2, "0"))
-        .join("");
-      
-      const params: BuildTransactionParams = {
-        ...createMinimalParams(),
-        instructionData: hexString,
-      };
-      
-      const transaction = builder.build(params);
-      
-      expect(transaction.instructionData).toEqual(instructionBytes);
-    });
-
-    it("should set fee payer proof flag when proof is provided", () => {
-      const builder = createBuilder();
-      const proof = new Uint8Array(64);
-      proof.fill(0x42);
-      
-      const params: BuildTransactionParams = {
-        ...createMinimalParams(),
-        header: {
-          fee: 1n,
-          nonce: 2n,
-          startSlot: 3n,
-          flags: 0,
-        },
-        proofs: {
-          feePayerStateProof: proof,
-        },
-      };
-      
-      const transaction = builder.build(params);
-      
-      // Flag should be set (FLAG_HAS_FEE_PAYER_PROOF = 1 << 0 = 1)
-      expect(transaction.flags & 1).toBe(1);
-    });
-
-    it("should not set fee payer proof flag when proof is not provided", () => {
-      const builder = createBuilder();
-      const params: BuildTransactionParams = {
-        ...createMinimalParams(),
-        header: {
-          fee: 1n,
-          nonce: 2n,
-          startSlot: 3n,
-          flags: 0,
-        },
-      };
-      
-      const transaction = builder.build(params);
-      
-      expect(transaction.flags & 1).toBe(0);
-    });
-
-    it("should preserve custom flags when proof is provided", () => {
-      const builder = createBuilder();
-      const proof = new Uint8Array(64);
-      proof.fill(0x42);
-      
-      const params: BuildTransactionParams = {
-        ...createMinimalParams(),
-        header: {
-          fee: 1n,
-          nonce: 2n,
-          startSlot: 3n,
-          flags: 2, // Custom flag
-        },
-        proofs: {
-          feePayerStateProof: proof,
-        },
-      };
-      
-      const transaction = builder.build(params);
-      
-      // Should have both custom flag (2) and proof flag (1) = 3
-      expect(transaction.flags).toBe(3);
-    });
-
-    it("should store fee payer state proof", () => {
-      const builder = createBuilder();
-      const proof = new Uint8Array(64);
-      proof.fill(0x42);
-      
-      const params: BuildTransactionParams = {
-        ...createMinimalParams(),
-        proofs: {
-          feePayerStateProof: proof,
-        },
-      };
-      
-      const transaction = builder.build(params);
-      
-      expect(transaction.feePayerStateProof).toEqual(proof);
-    });
-
-    it("should store fee payer account meta raw", () => {
-      const builder = createBuilder();
-      const metaRaw = new Uint8Array(32);
-      metaRaw.fill(0x43);
-      
-      const params: BuildTransactionParams = {
-        ...createMinimalParams(),
-        proofs: {
-          feePayerAccountMetaRaw: metaRaw,
-        },
-      };
-      
-      const transaction = builder.build(params);
-      
-      expect(transaction.feePayerAccountMetaRaw).toEqual(metaRaw);
-    });
-  });
-
-  describe("buildAndSign", () => {
-    it("should build and sign transaction", async () => {
-      const builder = createBuilder();
-      const privateKey = createPrivateKey();
-      const publicKey = generateTestPubkey(0x01);
-      const params: BuildTransactionParams = {
-        feePayer: {
-          publicKey,
-          privateKey,
-        },
-        program: generateTestPubkey(0x02),
-        header: {
-          fee: 1n,
-          nonce: 2n,
-          startSlot: 3n,
-        },
-      };
-      
-      const result = await builder.buildAndSign(params);
-      
-      expect(result.transaction).toBeInstanceOf(Transaction);
-      expect(result.signature).toBeInstanceOf(Uint8Array);
-      expect(result.signature.length).toBe(64);
-      expect(result.rawTransaction).toBeInstanceOf(Uint8Array);
-      expect(result.rawTransaction.length).toBeGreaterThan(0);
-    });
-
-    it("should throw error when private key is missing", async () => {
-      const builder = createBuilder();
-      const params: BuildTransactionParams = {
-        ...createMinimalParams(),
-        // No privateKey
-      };
-      
-      await expect(builder.buildAndSign(params)).rejects.toThrow(
-        "Fee payer private key is required to sign the transaction"
-      );
-    });
-
-    it("should include signature in raw transaction", async () => {
-      const builder = createBuilder();
-      const privateKey = createPrivateKey();
-      const publicKey = generateTestPubkey(0x01);
-      const params: BuildTransactionParams = {
-        feePayer: {
-          publicKey,
-          privateKey,
-        },
-        program: generateTestPubkey(0x02),
-        header: {
-          fee: 1n,
-          nonce: 2n,
-          startSlot: 3n,
-        },
-      };
-      
-      const result = await builder.buildAndSign(params);
-      
-      // Signature should be in first 64 bytes of raw transaction
-      const signatureInRaw = result.rawTransaction.slice(0, 64);
-      expect(signatureInRaw).toEqual(result.signature);
-    });
-
-    it("should create valid wire format", async () => {
-      const builder = createBuilder();
-      const privateKey = createPrivateKey();
-      const publicKey = generateTestPubkey(0x01);
-      const params: BuildTransactionParams = {
-        feePayer: {
-          publicKey,
-          privateKey,
-        },
-        program: generateTestPubkey(0x02),
-        header: {
-          fee: 1n,
-          nonce: 2n,
-          startSlot: 3n,
-        },
-      };
-      
-      const result = await builder.buildAndSign(params);
-      
-      // Should have at least header size (176 bytes)
-      expect(result.rawTransaction.length).toBeGreaterThanOrEqual(176);
-    });
-  });
-});
-