@thru/thru-sdk 0.1.10 → 0.1.12

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

@@ -32,9 +32,9 @@ import {
     type TransactionHeaderInput,
 } from "../transactions";
 import { parseAccountIdentifier, parseInstructionData } from "../transactions/utils";
-import type { BytesLike } from "./helpers";
-import { encodeSignature, toSignature as toSignatureMessage } from "./helpers";
+import { toSignature } from "./helpers";
 
+import { BytesLike, encodeSignature } from "@thru/helpers";
 import { getAccount } from "./accounts";
 import { getBlockHeight } from "./height";
 
@@ -94,7 +94,7 @@ export async function getTransaction(
     options: TransactionQueryOptions = {},
 ): Promise<CoreTransaction> {
     const request = create(GetTransactionRequestSchema, {
-        signature: toSignatureMessage(signature),
+        signature: toSignature(signature),
         view: options.view ?? DEFAULT_TRANSACTION_VIEW,
         versionContext: options.versionContext,
         minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS,
@@ -108,7 +108,7 @@ export async function getRawTransaction(
     options: RawTransactionQueryOptions = {},
 ): Promise<RawTransaction> {
     const request = create(GetRawTransactionRequestSchema, {
-        signature: toSignatureMessage(signature),
+        signature: toSignature(signature),
         versionContext: options.versionContext,
         minConsensus: options.minConsensus ?? DEFAULT_MIN_CONSENSUS,
     });
@@ -117,7 +117,7 @@ export async function getRawTransaction(
 
 export async function getTransactionStatus(ctx: ThruClientContext, signature: BytesLike): Promise<TransactionStatus> {
     const request = create(GetTransactionStatusRequestSchema, {
-        signature: toSignatureMessage(signature),
+        signature: toSignature(signature),
     });
     return ctx.query.getTransactionStatus(request);
 }

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

@@ -5,6 +5,7 @@ export * as accounts from "./modules/accounts";
 export * as blocks from "./modules/blocks";
 export * as events from "./modules/events";
 export * as height from "./modules/height";
+export * as keys from "./modules/keys";
 export * as proofs from "./modules/proofs";
 export * as streaming from "./modules/streaming";
 export * as transactions from "./modules/transactions";
@@ -18,19 +19,15 @@ export type {
 export type { BlockQueryOptions, ListBlocksOptions, RawBlockQueryOptions } from "./modules/blocks";
 export type { GetEventOptions } from "./modules/events";
 export {
-    decodeAddress,
-    decodeSignature,
     deriveProgramAddress,
-    encodeAddress,
-    encodeSignature,
     toPubkey
 } from "./modules/helpers";
 export type {
     BlockSelector,
-    BytesLike,
     DeriveProgramAddressOptions,
     DeriveProgramAddressResult
 } from "./modules/helpers";
+export type { GeneratedKeyPair } from "./modules/keys";
 export type { TrackTransactionOptions } from "./modules/streaming";
 export type {
     BuildAndSignTransactionOptions, BuildTransactionOptions, RawTransactionQueryOptions, TransactionAccountsConfig,

package/thru-ts-client-sdk/test-scripts/create-account.ts

@@ -1,4 +1,4 @@
-import { getPublicKeyAsync } from "@noble/ed25519";
+import { bytesToHex } from "@noble/hashes/utils";
 import { createThruClient } from "../client";
 import { ConsensusStatus } from "../proto/thru/common/v1/consensus_pb";
 
@@ -8,20 +8,15 @@ const sdk = createThruClient({
 });
 
 // Replace with the account you want to create and its 32-byte private key.
-const targetAccountPrivateKeyHex = "da0abd760d32d319ad11069d2d56f8c61b03f28d4096947c5117a54f427e4d60";
-const targetAccountAddress = sdk.helpers.encodeAddress(await getPublicKeyAsync(targetAccountPrivateKeyHex))
 
-function hexToBytes(hex: string): Uint8Array {
-    const normalized = hex.startsWith("0x") ? hex.slice(2) : hex;
-    if (normalized.length % 2 !== 0) {
-        throw new Error("Private key hex must contain an even number of characters");
-    }
-    const bytes = new Uint8Array(normalized.length / 2);
-    for (let i = 0; i < normalized.length; i += 2) {
-        bytes[i / 2] = parseInt(normalized.substring(i, i + 2), 16);
-    }
-    return bytes;
-}
+const keypair = await sdk.keys.generateKeyPair()
+const targetAccountAddress = keypair.address
+const targetAccountPrivateKey = keypair.privateKey
+
+console.log("Target account address:", targetAccountAddress);
+console.log("Target account private key:", targetAccountPrivateKey);
+const targetAccountPrivateKeyHex = bytesToHex(targetAccountPrivateKey);
+console.log("Target account private key hex:", targetAccountPrivateKeyHex);
 
 async function fetchAccountSnapshot(label: string, address: string): Promise<void> {
     try {
@@ -48,10 +43,10 @@ async function run(): Promise<void> {
     await fetchAccountSnapshot("Pre-create", targetAccountAddress);
 
     const feePayerPublicKey = sdk.helpers.decodeAddress(targetAccountAddress);
-    const feePayerPrivateKey = hexToBytes(targetAccountPrivateKeyHex);
+    const feePayerPrivateKey = targetAccountPrivateKey
 
     const transaction = await sdk.accounts.create({
-        publicKey: feePayerPublicKey
+        publicKey: feePayerPublicKey,
     })
 
     await transaction.sign(feePayerPrivateKey);

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

@@ -1,4 +1,4 @@
-import type { BytesLike } from "../modules/helpers";
+import { BytesLike } from "@thru/helpers";
 
 export type Bytes32 = Uint8Array;
 export type Bytes64 = Uint8Array;

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

@@ -1,6 +1,4 @@
-import type { BytesLike } from "../modules/helpers";
-import { decodeAddress } from "../modules/helpers";
-import { hexToBytes, isHexString } from "../utils/utils";
+import { BytesLike, decodeAddress, hexToBytes, isHexString } from "@thru/helpers";
 import type { AccountAddress, ProgramIdentifier } from "./types";
 
 const ACCOUNT_LIMIT = 1024;

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

@@ -1,4 +1,4 @@
-import { BytesLike } from "../modules/helpers";
+import { BytesLike } from "@thru/helpers";
 import { StateProofType } from "../proto/thru/core/v1/state_pb";
 
 export type GenerateStateProofOptions = {

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

@@ -1,70 +1,27 @@
+import { BytesLike } from "@thru/helpers";
 
-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;
-}
+import { TransactionHeaderInput } from "../transactions";
 
-export type BytesLike = string | Uint8Array;
 export type BlockSelector = { slot: number | bigint } | { blockHash: BytesLike };
 
-export function decodeBase64(value: string): Uint8Array {
-    if (value.length === 0) {
-        return new Uint8Array();
-    }
-    const atobFn = globalThis.atob;
-    if (!atobFn) {
-        throw new Error("Base64 decoding requires window.atob support");
-    }
-    const binary = atobFn(value);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) {
-        bytes[i] = binary.charCodeAt(i);
-    }
-    return bytes;
-}
-
 export function isSlotSelector(selector: BlockSelector): selector is { slot: number | bigint } {
     return "slot" in selector;
 }
 
-export function ensureBytes(value: BytesLike | undefined, field: string): Uint8Array {
-    if (value instanceof Uint8Array) {
-        if (value.length === 0) {
-            throw new Error(`${field} cannot be empty`);
-        }
-        return value;
-    }
-    if (typeof value === "string") {
-        if (value.length === 0) {
-            throw new Error(`${field} cannot be empty`);
-        }
-        return decodeBase64(value);
+export function mergeTransactionHeader(
+    defaults: TransactionHeaderInput,
+    overrides?: Partial<TransactionHeaderInput>,
+): TransactionHeaderInput {
+    if (!overrides) {
+        return defaults;
     }
-    throw new Error(`${field} is required`);
-}
-
-export function maskForBits(bits: number): number {
-    return bits === 0 ? 0 : (1 << bits) - 1;
-}
 
-export function isHexString(value: string): boolean {
-    const normalized = value.startsWith("0x") ? value.slice(2) : value;
-    return normalized.length % 2 === 0 && normalized.length > 0 && /^[0-9a-fA-F]+$/.test(normalized);
-}
+    const sanitized = Object.fromEntries(
+        Object.entries(overrides).filter(([, value]) => value !== undefined),
+    ) as Partial<TransactionHeaderInput>;
 
-export function hexToBytes(value: string): Uint8Array {
-    const normalized = value.startsWith("0x") ? value.slice(2) : value;
-    if (normalized.length % 2 !== 0) {
-        throw new Error("Hex string must contain an even number of characters");
-    }
-    const bytes = new Uint8Array(normalized.length / 2);
-    for (let i = 0; i < normalized.length; i += 2) {
-        const byte = parseInt(normalized.slice(i, i + 2), 16);
-        if (Number.isNaN(byte)) {
-            throw new Error("Hex string contains invalid characters");
-        }
-        bytes[i / 2] = byte;
-    }
-    return bytes;
+    return {
+        ...defaults,
+        ...sanitized,
+    };
 }