@rialo/ts-cdk 0.2.0-alpha.0 → 0.2.0-alpha.2

package/dist/index.d.mts

@@ -1,3 +1,5 @@
+export { field, fixedArray, option, vec } from '@dao-xyz/borsh';
+
 interface HttpTransportConfig {
     /** Request timeout in milliseconds */
     timeout?: number;
@@ -973,15 +975,6 @@ interface SignatureInfo {
  * Get health response.
  */
 type GetHealthResponse = "ok" | string;
-/**
- * Get transactions configuration.
- */
-interface GetTransactionsConfig {
-    /** Maximum number of transactions to return */
-    limit?: number;
-    /** Encoding format */
-    encoding?: "json" | "base58" | "base64";
-}
 /**
  * Get transactions response.
  */
@@ -1029,8 +1022,6 @@ interface ConfirmedTransaction {
  * Configuration for getAccountsByOwner.
  */
 interface GetAccountsByOwnerConfig {
-    /** Encoding format for account data */
-    encoding?: "base64" | "base58" | "json" | "jsonParsed";
     /** Maximum number of accounts to return */
     limit?: number;
     /** Cursor for pagination (base58 pubkey) */
@@ -1805,6 +1796,387 @@ declare function createRialoClient(config: RialoClientConfig): RialoClient;
  */
 declare function getDefaultRialoClientConfig(network: RialoNetwork): RialoClientConfig;
 
+/**
+ * Bincode deserialization reader
+ *
+ * Matches Rust's bincode crate with default configuration:
+ * - Little-endian byte order
+ * - Fixed-size integer encoding (no varint)
+ * - u64 length prefixes for dynamic collections
+ * - u32 enum variant indices
+ */
+declare class BincodeReader {
+    private view;
+    private offset;
+    private bytes;
+    constructor(data: Uint8Array);
+    getOffset(): number;
+    remaining(): number;
+    isExhausted(): boolean;
+    skip(bytes: number): this;
+    /**
+     * Peek at bytes without advancing the offset
+     */
+    peek(length: number): Uint8Array;
+    /**
+     * Reset reader to beginning
+     */
+    reset(): this;
+    /**
+     * Seek to specific offset
+     */
+    seek(offset: number): this;
+    readU8(): number;
+    readU16(): number;
+    readU32(): number;
+    readU64(): bigint;
+    readU128(): bigint;
+    readI8(): number;
+    readI16(): number;
+    readI32(): number;
+    readI64(): bigint;
+    readI128(): bigint;
+    readF32(): number;
+    readF64(): number;
+    readBool(): boolean;
+    readBytes(length: number): Uint8Array;
+    readFixedArray(length: number): Uint8Array;
+    readVecBytes(): Uint8Array;
+    readString(): string;
+    readVariant(): number;
+    readOption<T>(readValue: () => T): T | null;
+    readVec<T>(readElement: () => T): T[];
+    /**
+     * Read a tuple of fixed size with heterogeneous types
+     */
+    readTuple<T extends unknown[]>(readers: {
+        [K in keyof T]: () => T[K];
+    }): T;
+    readMap<K, V>(readKey: () => K, readValue: () => V): Map<K, V>;
+    /**
+     * Read length as u64 but validate it's within safe integer range
+     */
+    private readLength;
+    private ensureAvailable;
+}
+
+/**
+ * Type definitions for bincode schemas
+ *
+ * IMPORTANT: For structs and enums, field/variant order MUST match Rust definition order.
+ * Use arrays of tuples instead of objects to guarantee order preservation.
+ */
+type BincodeSchema = {
+    type: "u8";
+} | {
+    type: "u16";
+} | {
+    type: "u32";
+} | {
+    type: "u64";
+} | {
+    type: "u128";
+} | {
+    type: "i8";
+} | {
+    type: "i16";
+} | {
+    type: "i32";
+} | {
+    type: "i64";
+} | {
+    type: "i128";
+} | {
+    type: "f32";
+} | {
+    type: "f64";
+} | {
+    type: "bool";
+} | {
+    type: "string";
+} | {
+    type: "bytes";
+} | {
+    type: "unit";
+} | {
+    type: "fixedArray";
+    length: number;
+} | {
+    type: "vec";
+    element: BincodeSchema;
+} | {
+    type: "option";
+    inner: BincodeSchema;
+} | {
+    type: "tuple";
+    elements: BincodeSchema[];
+} | {
+    type: "struct";
+    fields: StructField[];
+} | {
+    type: "enum";
+    variants: EnumVariant[];
+} | {
+    type: "map";
+    key: BincodeSchema;
+    value: BincodeSchema;
+} | {
+    type: "pubkey";
+};
+/**
+ * Struct field definition - order matters!
+ */
+interface StructField {
+    name: string;
+    schema: BincodeSchema;
+}
+/**
+ * Enum variant definition - order matters!
+ */
+interface EnumVariant {
+    name: string;
+    schema: BincodeSchema | null;
+}
+declare const Schema: {
+    readonly u8: () => BincodeSchema;
+    readonly u16: () => BincodeSchema;
+    readonly u32: () => BincodeSchema;
+    readonly u64: () => BincodeSchema;
+    readonly u128: () => BincodeSchema;
+    readonly i8: () => BincodeSchema;
+    readonly i16: () => BincodeSchema;
+    readonly i32: () => BincodeSchema;
+    readonly i64: () => BincodeSchema;
+    readonly i128: () => BincodeSchema;
+    readonly f32: () => BincodeSchema;
+    readonly f64: () => BincodeSchema;
+    readonly bool: () => BincodeSchema;
+    readonly string: () => BincodeSchema;
+    readonly bytes: () => BincodeSchema;
+    readonly unit: () => BincodeSchema;
+    readonly fixedArray: (length: number) => BincodeSchema;
+    readonly vec: (element: BincodeSchema) => BincodeSchema;
+    readonly option: (inner: BincodeSchema) => BincodeSchema;
+    readonly tuple: (...elements: BincodeSchema[]) => BincodeSchema;
+    /**
+     * Define a struct with ordered fields
+     * @example
+     * Schema.struct([
+     *   ["id", Schema.u64()],
+     *   ["name", Schema.string()],
+     *   ["active", Schema.bool()],
+     * ])
+     */
+    readonly struct: (fields: [string, BincodeSchema][]) => BincodeSchema;
+    /**
+     * Define an enum with ordered variants
+     * @example
+     * Schema.enum([
+     *   ["None", null],
+     *   ["Some", Schema.u64()],
+     *   ["Error", Schema.string()],
+     * ])
+     */
+    readonly enum: (variants: [string, BincodeSchema | null][]) => BincodeSchema;
+    readonly map: (key: BincodeSchema, value: BincodeSchema) => BincodeSchema;
+    readonly pubkey: () => BincodeSchema;
+};
+/**
+ * Serialize a value according to a schema
+ */
+declare function serialize(schema: BincodeSchema, value: unknown): Uint8Array;
+/**
+ * Deserialize bytes according to a schema
+ */
+declare function deserialize<T>(schema: BincodeSchema, data: Uint8Array): T;
+/**
+ * Deserialize bytes with strict validation
+ */
+declare function deserializeStrict<T>(schema: BincodeSchema, data: Uint8Array): T;
+/**
+ * Infer TypeScript type from schema (for documentation purposes)
+ *
+ * Usage:
+ * const mySchema = Schema.struct([...]);
+ * type MyType = InferSchema<typeof mySchema>;
+ */
+type InferSchema<S extends BincodeSchema> = S extends {
+    type: "u8";
+} ? number : S extends {
+    type: "u16";
+} ? number : S extends {
+    type: "u32";
+} ? number : S extends {
+    type: "u64";
+} ? bigint : S extends {
+    type: "u128";
+} ? bigint : S extends {
+    type: "i8";
+} ? number : S extends {
+    type: "i16";
+} ? number : S extends {
+    type: "i32";
+} ? number : S extends {
+    type: "i64";
+} ? bigint : S extends {
+    type: "i128";
+} ? bigint : S extends {
+    type: "f32";
+} ? number : S extends {
+    type: "f64";
+} ? number : S extends {
+    type: "bool";
+} ? boolean : S extends {
+    type: "string";
+} ? string : S extends {
+    type: "bytes";
+} ? Uint8Array : S extends {
+    type: "unit";
+} ? undefined : S extends {
+    type: "fixedArray";
+} ? Uint8Array : S extends {
+    type: "pubkey";
+} ? Uint8Array : S extends {
+    type: "vec";
+    element: infer E;
+} ? E extends BincodeSchema ? InferSchema<E>[] : never : S extends {
+    type: "option";
+    inner: infer I;
+} ? I extends BincodeSchema ? InferSchema<I> | null : never : unknown;
+
+/**
+ * Bincode serialization writer
+ *
+ * Matches Rust's bincode crate with default configuration:
+ * - Little-endian byte order
+ * - Fixed-size integer encoding (no varint)
+ * - u64 length prefixes for dynamic collections
+ * - u32 enum variant indices
+ */
+declare class BincodeWriter {
+    private buffer;
+    private offset;
+    private view;
+    constructor(initialCapacity?: number);
+    writeU8(value: number): this;
+    writeU16(value: number): this;
+    writeU32(value: number): this;
+    writeU64(value: bigint | number): this;
+    writeU128(value: bigint): this;
+    writeI8(value: number): this;
+    writeI16(value: number): this;
+    writeI32(value: number): this;
+    writeI64(value: bigint): this;
+    writeI128(value: bigint): this;
+    writeF32(value: number): this;
+    writeF64(value: number): this;
+    writeBool(value: boolean): this;
+    writeBytes(bytes: Uint8Array): this;
+    writeFixedArray(bytes: Uint8Array, expectedLength?: number): this;
+    writeVecBytes(bytes: Uint8Array): this;
+    writeString(str: string): this;
+    writeVariant(index: number): this;
+    writeOption<T>(value: T | null | undefined, writeValue: (writer: BincodeWriter, val: T) => void): this;
+    writeVec<T>(items: T[], writeItem: (writer: BincodeWriter, item: T) => void): this;
+    /**
+     * Write a tuple (fixed-size heterogeneous collection)
+     */
+    writeTuple<T extends unknown[]>(items: T, writers: {
+        [K in keyof T]: (writer: BincodeWriter, val: T[K]) => void;
+    }): this;
+    writeMap<K, V>(map: Map<K, V>, writeKey: (writer: BincodeWriter, key: K) => void, writeValue: (writer: BincodeWriter, value: V) => void): this;
+    toBytes(): Uint8Array;
+    /**
+     * Get a view of the written bytes WITHOUT copying.
+     *
+     * ⚠️ WARNING: This returns a view into the internal buffer.
+     * The view becomes INVALID if:
+     * - The writer continues writing (may trigger resize)
+     * - The writer is cleared via clear()
+     *
+     * Use toBytes() for a safe copy, or use this only for immediate
+     * read-only access when performance is critical.
+     */
+    toView(): Uint8Array;
+    length(): number;
+    clear(): this;
+    /**
+     * Reserve additional capacity
+     */
+    reserve(additionalBytes: number): this;
+    private ensureCapacity;
+}
+
+/**
+ * Serializes data using Borsh (Binary Object Representation Serializer for Hashing) encoding.
+ *
+ * Borsh is efficient for complex types like enums, Options, vectors, and nested structs.
+ * Use the exported decorators (@field, @option, @vec) to define your data structures.
+ *
+ * @param data - Data object to serialize
+ * @returns Serialized bytes
+ *
+ * @example
+ * ```typescript
+ * import { serializeBorsh, field, option } from '@rialo/ts-cdk';
+ *
+ * class SwapInstruction {
+ *   @field({ type: 'u8' })
+ *   instruction: number;
+ *
+ *   @field({ type: 'u64' })
+ *   amountIn: bigint;
+ *
+ *   @field({ type: option('u64') })
+ *   minAmountOut?: bigint;
+ * }
+ *
+ * const data = serializeBorsh(new SwapInstruction({
+ *   instruction: 1,
+ *   amountIn: 1000n,
+ *   minAmountOut: 900n,
+ * }));
+ * ```
+ */
+declare function serializeBorsh<T>(data: T): Uint8Array;
+/**
+ * Deserializes Borsh-encoded data into a typed object.
+ *
+ * @param data - Borsh-encoded bytes
+ * @param type - Class constructor for the target type
+ * @returns Deserialized object instance
+ */
+declare function deserializeBorsh<T>(data: Uint8Array, type: new () => T): T;
+
+/**
+ * Serializes a u16 value into compact encoding.
+ *
+ * @param buffer - Output buffer to append bytes to
+ * @param value - Value to encode (0-65535)
+ * @throws {TransactionError} If value is out of range
+ */
+declare function serializeCompactU16(buffer: number[], value: number): void;
+/**
+ * Deserializes a compact-u16 value from bytes.
+ *
+ * @param data - Input byte array
+ * @param currentCursor - Starting position in the array
+ * @returns Tuple of [decoded value, new cursor position]
+ * @throws {TransactionError} If data is insufficient or malformed
+ */
+declare function deserializeCompactU16(data: Uint8Array, currentCursor: number): [number, number];
+/**
+ * Writes a compact-u16 value directly to a buffer (zero-copy).
+ *
+ * Optimized version for in-place writing without intermediate allocations.
+ *
+ * @param buffer - Target buffer
+ * @param offset - Starting position to write at
+ * @param value - Value to encode (0-127 only, uses 1-2 bytes)
+ * @returns New offset after writing
+ */
+declare function writeCompactU16(buffer: Uint8Array, offset: number, value: number): number;
+
 /**
  * Interface for signing messages and transactions.
  *
@@ -2512,4 +2884,4 @@ declare function getMainnetUrl(): string;
  */
 declare function getLocalnetUrl(): string;
 
-export { type AccountFilter, type AccountInfo, type AccountMeta, AccountMetaTable, BASE_DERIVATION_PATH, BaseRpcClient, type Bump, type ChainDefinition, type CompiledInstruction, type ConfirmTransactionOptions, type ConfirmedTransaction, CryptoError, CryptoErrorCode, DEFAULT_NUM_ACCOUNTS, type EpochInfoResponse, type EventData, type GetAccountsByOwnerConfig, type GetAccountsByOwnerResponse, type GetHealthResponse, type GetSignaturesForAddressConfig, type GetTransactionsConfig, type GetTransactionsResponse, type GetWorkflowLineageRequest, type GetWorkflowLineageResponse, HttpTransport, type HttpTransportConfig, type IdentifierString, type Instruction, KELVIN_PER_RLO, Keypair, KeypairSigner, Message, type MessageHeader, Mnemonic, type MnemonicStrength, type OwnerAccount, type PDA, PUBLIC_KEY_LENGTH, type PaginationInfo, PublicKey, QueryRpcClient, RIALO_DEVNET_CHAIN, RIALO_LOCALNET_CHAIN, RIALO_MAINNET_CHAIN, RIALO_SHITNET_CHAIN, RIALO_TESTNET_CHAIN, RialoClient, type RialoClientConfig, RialoError, RialoErrorType, type RialoNetwork, RpcError, RpcErrorCode, type RpcErrorDetails$1 as RpcErrorDetails, SECRET_KEY_LENGTH, SIGNATURE_LENGTH, SYSTEM_PROGRAM_ID, type Seed, type SendAndConfirmOptions, type SendTransactionOptions, Signature, type SignatureInfo, type SignatureStatus, type Signer, type Subscription, type SubscriptionKind, SystemInstruction, type TimestampRange, Transaction, TransactionBuilder, TransactionError, TransactionErrorCode, type TransactionNodeData, type TransactionResponse, TransactionRpcClient, type TriggerInfo, type TriggeredTransaction, type TruncationReason, URL_DEVNET, URL_LOCALNET, URL_MAINNET, URL_SHITNET, URL_TESTNET, type WorkflowLineage, type WorkflowNode, allocateInstruction, assignInstruction, calculateBackoff, concatBytes, createAccount, createBorshInstruction, createRialoClient, encodeBorshData, fromBase64, getDefaultRialoClientConfig, getDevnetUrl, getLocalnetUrl, getMainnetUrl, getTestnetUrl, isOnCurve, seedToBytes, sleep, toBase64, transferInstruction };
+export { type AccountFilter, type AccountInfo, type AccountMeta, AccountMetaTable, BASE_DERIVATION_PATH, BaseRpcClient, BincodeReader, type BincodeSchema, BincodeWriter, type Bump, type ChainDefinition, type CompiledInstruction, type ConfirmTransactionOptions, type ConfirmedTransaction, CryptoError, CryptoErrorCode, DEFAULT_NUM_ACCOUNTS, type EnumVariant, type EpochInfoResponse, type EventData, type GetAccountsByOwnerConfig, type GetAccountsByOwnerResponse, type GetHealthResponse, type GetSignaturesForAddressConfig, type GetTransactionsResponse, type GetWorkflowLineageRequest, type GetWorkflowLineageResponse, HttpTransport, type HttpTransportConfig, type IdentifierString, type InferSchema, type Instruction, KELVIN_PER_RLO, Keypair, KeypairSigner, Message, type MessageHeader, Mnemonic, type MnemonicStrength, type OwnerAccount, type PDA, PUBLIC_KEY_LENGTH, type PaginationInfo, PublicKey, QueryRpcClient, RIALO_DEVNET_CHAIN, RIALO_LOCALNET_CHAIN, RIALO_MAINNET_CHAIN, RIALO_SHITNET_CHAIN, RIALO_TESTNET_CHAIN, RialoClient, type RialoClientConfig, RialoError, RialoErrorType, type RialoNetwork, RpcError, RpcErrorCode, type RpcErrorDetails$1 as RpcErrorDetails, SECRET_KEY_LENGTH, SIGNATURE_LENGTH, SYSTEM_PROGRAM_ID, Schema, type Seed, type SendAndConfirmOptions, type SendTransactionOptions, Signature, type SignatureInfo, type SignatureStatus, type Signer, type StructField, type Subscription, type SubscriptionKind, SystemInstruction, type TimestampRange, Transaction, TransactionBuilder, TransactionError, TransactionErrorCode, type TransactionNodeData, type TransactionResponse, TransactionRpcClient, type TriggerInfo, type TriggeredTransaction, type TruncationReason, URL_DEVNET, URL_LOCALNET, URL_MAINNET, URL_SHITNET, URL_TESTNET, type WorkflowLineage, type WorkflowNode, allocateInstruction, assignInstruction, calculateBackoff, concatBytes, createAccount, createBorshInstruction, createRialoClient, deserialize, deserializeBorsh, deserializeCompactU16, deserializeStrict, encodeBorshData, fromBase64, getDefaultRialoClientConfig, getDevnetUrl, getLocalnetUrl, getMainnetUrl, getTestnetUrl, isOnCurve, seedToBytes, serialize, serializeBorsh, serializeCompactU16, sleep, toBase64, transferInstruction, writeCompactU16 };