better-bitkub-client 0.1.0

package/README.md

@@ -0,0 +1,42 @@
+# better-bitkub-client
+
+TypeScript rewrite of the repository's C# `bitkubwrapper` library.
+
+## What it includes
+
+- `BitkubV3Client` for V3 market, user, trading, and fiat endpoints
+- `BitkubV4Client` for V4 crypto endpoints
+- shared HMAC-SHA256 signing logic
+- typed request and response models matching the current API surface
+
+## Install
+
+```bash
+npm install
+npm run build
+```
+
+## Usage
+
+```ts
+import { BitkubV3Client, BitkubV4Client } from "./dist/index.js";
+
+const v3 = new BitkubV3Client({
+  apiKey: process.env.BITKUB_KEY!,
+  apiSecret: process.env.BITKUB_SECRET!
+});
+
+const v4 = new BitkubV4Client({
+  apiKey: process.env.BITKUB_KEY!,
+  apiSecret: process.env.BITKUB_SECRET!
+});
+
+const symbols = await v3.getSymbols();
+const withdraws = await v4.getCryptoWithdraws({ limit: 50 });
+```
+
+## Notes
+
+- Requires Node 18+ for the built-in `fetch` API.
+- The default base URL is `https://api.bitkub.com`.
+- DTOs keep Bitkub's field names to make request/response handling predictable.

package/dist/base-client.d.ts

@@ -0,0 +1,35 @@
+export interface BitkubClientOptions {
+    apiKey: string;
+    apiSecret: string;
+    baseUrl?: string;
+    fetchImpl?: typeof fetch;
+}
+type QueryValue = string | number | boolean | null | undefined;
+type QueryParams = Record<string, QueryValue>;
+export declare class BitkubApiError extends Error {
+    readonly status: number;
+    readonly responseBody: string;
+    constructor(status: number, responseBody: string);
+}
+export declare abstract class BitkubBaseClient {
+    protected readonly apiKey: string;
+    protected readonly apiSecret: string;
+    protected readonly baseUrl: string;
+    private readonly fetchImpl;
+    constructor(options: BitkubClientOptions);
+    getServerTime(): Promise<number>;
+    protected sendRequest<T>(method: string, path: string, options?: {
+        body?: unknown;
+        queryParams?: QueryParams;
+    }): Promise<T>;
+    protected sendSecureRequest<T>(method: string, path: string, options?: {
+        body?: unknown;
+        queryParams?: QueryParams;
+    }): Promise<T>;
+    private buildPath;
+    private serializeBody;
+    private buildHeaders;
+    private resolveRequestBody;
+    private readJson;
+}
+export {};

package/dist/base-client.js

@@ -0,0 +1,109 @@
+import { generateSignature } from "./utils/signature.js";
+export class BitkubApiError extends Error {
+    status;
+    responseBody;
+    constructor(status, responseBody) {
+        super(`API request failed with status ${status}: ${responseBody}`);
+        this.name = "BitkubApiError";
+        this.status = status;
+        this.responseBody = responseBody;
+    }
+}
+export class BitkubBaseClient {
+    apiKey;
+    apiSecret;
+    baseUrl;
+    fetchImpl;
+    constructor(options) {
+        if (!options.apiKey) {
+            throw new Error("apiKey is required");
+        }
+        if (!options.apiSecret) {
+            throw new Error("apiSecret is required");
+        }
+        this.apiKey = options.apiKey;
+        this.apiSecret = options.apiSecret;
+        this.baseUrl = options.baseUrl ?? "https://api.bitkub.com";
+        this.fetchImpl = options.fetchImpl ?? fetch;
+    }
+    async getServerTime() {
+        const response = await this.fetchImpl(`${this.baseUrl}/api/v3/servertime`, {
+            method: "GET",
+            headers: {
+                Accept: "application/json"
+            }
+        });
+        const text = await response.text();
+        if (!response.ok) {
+            throw new BitkubApiError(response.status, text);
+        }
+        return Number.parseInt(text.trim(), 10);
+    }
+    async sendRequest(method, path, options) {
+        const fullPath = this.buildPath(path, options?.queryParams);
+        const bodyJson = this.serializeBody(options?.body);
+        const requestBody = this.resolveRequestBody(method, bodyJson);
+        const response = await this.fetchImpl(`${this.baseUrl}${fullPath}`, {
+            method,
+            headers: this.buildHeaders(false, undefined, undefined, Boolean(requestBody)),
+            body: requestBody
+        });
+        return this.readJson(response);
+    }
+    async sendSecureRequest(method, path, options) {
+        const timestamp = String(await this.getServerTime());
+        const fullPath = this.buildPath(path, options?.queryParams);
+        const bodyJson = this.serializeBody(options?.body);
+        const requestBody = this.resolveRequestBody(method, bodyJson);
+        const signature = generateSignature(timestamp, method, fullPath, bodyJson, this.apiSecret);
+        const response = await this.fetchImpl(`${this.baseUrl}${fullPath}`, {
+            method,
+            headers: this.buildHeaders(true, timestamp, signature, Boolean(requestBody)),
+            body: requestBody
+        });
+        return this.readJson(response);
+    }
+    buildPath(path, queryParams) {
+        if (!queryParams) {
+            return path;
+        }
+        const pairs = Object.entries(queryParams).filter(([, value]) => value !== undefined && value !== null);
+        if (pairs.length === 0) {
+            return path;
+        }
+        const query = pairs
+            .map(([key, value]) => `${key}=${encodeURIComponent(String(value))}`)
+            .join("&");
+        return `${path}?${query}`;
+    }
+    serializeBody(body) {
+        return body === undefined ? "" : JSON.stringify(body);
+    }
+    buildHeaders(secure, timestamp, signature, hasJsonBody = false) {
+        const headers = {
+            Accept: "application/json"
+        };
+        if (hasJsonBody) {
+            headers["Content-Type"] = "application/json";
+        }
+        if (secure) {
+            headers["X-BTK-APIKEY"] = this.apiKey;
+            headers["X-BTK-TIMESTAMP"] = timestamp ?? "";
+            headers["X-BTK-SIGN"] = signature ?? "";
+        }
+        return headers;
+    }
+    resolveRequestBody(method, bodyJson) {
+        if (method.toUpperCase() !== "POST" || !bodyJson) {
+            return undefined;
+        }
+        return bodyJson;
+    }
+    async readJson(response) {
+        const text = await response.text();
+        if (!response.ok) {
+            throw new BitkubApiError(response.status, text);
+        }
+        return JSON.parse(text);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { BitkubApiError, type BitkubClientOptions } from "./base-client.js";
+export { BitkubV3Client } from "./v3-client.js";
+export { BitkubV4Client } from "./v4-client.js";
+export { generateSignature } from "./utils/signature.js";
+export type * from "./types/v3.js";
+export type * from "./types/v4.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export { BitkubApiError } from "./base-client.js";
+export { BitkubV3Client } from "./v3-client.js";
+export { BitkubV4Client } from "./v4-client.js";
+export { generateSignature } from "./utils/signature.js";

package/dist/types/v3.d.ts

@@ -0,0 +1,240 @@
+export interface BitkubV3Response<T> {
+    error: number;
+    result?: T;
+    pagination?: PaginationInfo;
+}
+export interface PaginationInfo {
+    page?: number;
+    last?: number;
+    next?: number;
+    prev?: number;
+    cursor?: string;
+    has_next?: boolean;
+}
+export interface StatusResponse {
+    name?: string;
+    status?: string;
+    message?: string;
+}
+export interface SymbolInfo {
+    base_asset: string;
+    base_asset_scale: number;
+    buy_price_gap_as_percent: number;
+    created_at: string;
+    description: string;
+    freeze_buy: boolean;
+    freeze_cancel: boolean;
+    freeze_sell: boolean;
+    market_segment: string;
+    min_quote_size: number;
+    modified_at: string;
+    name: string;
+    pairing_id: number;
+    price_scale: number;
+    price_step: string;
+    quantity_scale: number;
+    quantity_step: string;
+    quote_asset: string;
+    quote_asset_scale: number;
+    sell_price_gap_as_percent: number;
+    status: string;
+    symbol: string;
+    source: string;
+}
+export interface Ticker {
+    symbol: string;
+    base_volume: string;
+    high_24_hr: string;
+    highest_bid: string;
+    last: string;
+    low_24_hr: string;
+    lowest_ask: string;
+    percent_change: string;
+    quote_volume: string;
+}
+export interface OrderBookEntry {
+    order_id: string;
+    price: string;
+    side: string;
+    size: string;
+    timestamp: number;
+    volume: string;
+}
+export interface Depth {
+    asks: number[][];
+    bids: number[][];
+}
+export type RawTrade = Array<string | number | boolean | null>;
+export interface LimitsResponse {
+    limits: LimitsData;
+    usage: UsageData;
+    rate: number;
+}
+export interface LimitsData {
+    crypto: LimitInfo;
+    fiat: LimitInfo;
+}
+export interface LimitInfo {
+    deposit: number;
+    withdraw: number;
+}
+export interface UsageData {
+    crypto: UsageInfo;
+    fiat: UsageInfo;
+}
+export interface UsageInfo {
+    deposit: number;
+    withdraw: number;
+    deposit_percentage: number;
+    withdraw_percentage: number;
+    deposit_thb_equivalent?: number | null;
+    withdraw_thb_equivalent?: number | null;
+}
+export interface CoinConvertHistoryItem {
+    transaction_id: string;
+    status: string;
+    amount: string;
+    from_currency: string;
+    trading_fee_received: string;
+    timestamp: number;
+}
+export interface BalanceInfo {
+    available: number;
+    reserved: number;
+}
+export interface PlaceOrderRequest {
+    sym: string;
+    amt: number;
+    rat: number;
+    typ?: string;
+    client_id?: string;
+    post_only?: boolean;
+}
+export interface PlaceOrderResponse {
+    id: string;
+    typ: string;
+    amt: number;
+    rat: number;
+    fee: number;
+    cre: number;
+    rec: number;
+    ts: string;
+    ci?: string | null;
+}
+export interface CancelOrderRequest {
+    sym: string;
+    id: string;
+    sd: string;
+}
+export interface OpenOrder {
+    id: string;
+    side: string;
+    type: string;
+    rate: string;
+    fee: string;
+    credit: string;
+    amount: string;
+    receive: string;
+    parent_id: string;
+    super_id: string;
+    client_id?: string | null;
+    ts: number;
+}
+export interface OrderHistoryItem {
+    txn_id: string;
+    order_id: string;
+    parent_order_id: string;
+    super_order_id: string;
+    client_id?: string | null;
+    taken_by_me: boolean;
+    is_maker: boolean;
+    side: string;
+    type: string;
+    rate: string;
+    fee: string;
+    credit: string;
+    amount: string;
+    ts: number;
+    order_closed_at?: number | null;
+}
+export interface OrderHistoryItemWithSymbol extends OrderHistoryItem {
+    symbol: string;
+}
+export interface OrderInfo {
+    id: string;
+    first: string;
+    parent: string;
+    last: string;
+    client_id: string;
+    post_only: boolean;
+    amount: string;
+    rate: number;
+    fee: number;
+    credit: number;
+    filled: number;
+    total: number;
+    status: string;
+    partial_filled: boolean;
+    remaining: number;
+    history: OrderInfoHistory[];
+}
+export interface OrderInfoHistory {
+    amount: number;
+    credit: number;
+    fee: number;
+    id: string;
+    rate: number;
+    timestamp: number;
+    txn_id: string;
+}
+export interface BankAccount {
+    id: string;
+    bank: string;
+    name: string;
+    time: number;
+}
+export interface FiatWithdrawRequest {
+    id: string;
+    amt: number;
+}
+export interface FiatWithdrawResponse {
+    txn: string;
+    acc: string;
+    cur: string;
+    amt: number;
+    fee: number;
+    rec: number;
+    ts: number;
+}
+export interface FiatDepositHistoryItem {
+    txn_id: string;
+    currency: string;
+    amount: number;
+    status: string;
+    time: number;
+}
+export interface FiatWithdrawHistoryItem {
+    txn_id: string;
+    currency: string;
+    amount: string;
+    fee: number;
+    status: string;
+    time: number;
+}
+export interface CoinConvertHistoryOptions {
+    page?: number;
+    limit?: number;
+    sort?: number;
+    status?: string;
+    symbol?: string;
+    start?: number;
+    end?: number;
+}
+export interface OrderHistoryOptions {
+    page?: number;
+    limit?: number;
+    cursor?: string;
+    start?: string;
+    end?: string;
+    pagination_type?: string;
+}

package/dist/types/v3.js

@@ -0,0 +1 @@
+export {};

package/dist/types/v4.d.ts

@@ -0,0 +1,152 @@
+export interface BitkubV4Response<T> {
+    code: string;
+    message: string;
+    data?: T;
+}
+export interface CryptoAddress {
+    symbol: string;
+    network: string;
+    address: string;
+    memo: string;
+    created_at?: string | null;
+}
+export interface CryptoAddressesResponse {
+    page: number;
+    total_page: number;
+    total_item: number;
+    items: CryptoAddress[];
+}
+export interface CreateCryptoAddressRequest {
+    symbol: string;
+    network: string;
+}
+export interface CryptoDeposit {
+    hash: string;
+    symbol: string;
+    network: string;
+    amount: string;
+    from_address: string;
+    to_address: string;
+    confirmations: number;
+    status: string;
+    created_at: string;
+    completed_at?: string | null;
+}
+export interface CryptoDepositsResponse {
+    page: number;
+    total_page: number;
+    total_item: number;
+    items: CryptoDeposit[];
+}
+export interface CryptoWithdraw {
+    txn_id: string;
+    external_ref?: string | null;
+    hash?: string | null;
+    symbol: string;
+    network: string;
+    amount: string;
+    fee: string;
+    address: string;
+    memo: string;
+    status: string;
+    created_at: string;
+    completed_at?: string | null;
+}
+export interface CryptoWithdrawsResponse {
+    page: number;
+    total_page: number;
+    total_item: number;
+    items: CryptoWithdraw[];
+}
+export interface CreateCryptoWithdrawRequest {
+    symbol: string;
+    amount: string;
+    address: string;
+    memo?: string;
+    network: string;
+}
+export interface CreateCryptoWithdrawResponse {
+    txn_id: string;
+    symbol: string;
+    network: string;
+    amount: string;
+    fee: string;
+    address: string;
+    memo: string;
+    created_at: string;
+}
+export interface CoinNetwork {
+    name: string;
+    network: string;
+    address_regex: string;
+    memo_regex: string;
+    explorer: string;
+    contract_address: string;
+    withdraw_min: string;
+    withdraw_fee: string;
+    withdraw_internal_min: string;
+    withdraw_internal_fee: string;
+    withdraw_decimal_places: number;
+    min_confirm: number;
+    decimal: number;
+    deposit_enable: boolean;
+    withdraw_enable: boolean;
+    is_memo: boolean;
+}
+export interface Coin {
+    name: string;
+    symbol: string;
+    networks: CoinNetwork[];
+    deposit_enable: boolean;
+    withdraw_enable: boolean;
+}
+export interface CoinsResponse {
+    items: Coin[];
+}
+export interface Compensation {
+    txn_id: string;
+    symbol: string;
+    type: string;
+    amount: string;
+    status: string;
+    created_at: string;
+    completed_at?: string | null;
+}
+export interface CompensationsResponse {
+    page: number;
+    total_page: number;
+    total_item: number;
+    items: Compensation[];
+}
+export interface ListOptions {
+    page?: number;
+    limit?: number;
+}
+export interface CryptoAddressesOptions extends ListOptions {
+    symbol?: string;
+    network?: string;
+    memo?: string;
+}
+export interface CryptoDepositsOptions extends ListOptions {
+    symbol?: string;
+    status?: string;
+    created_start?: string;
+    created_end?: string;
+}
+export interface CryptoWithdrawsOptions extends ListOptions {
+    symbol?: string;
+    status?: string;
+    created_start?: string;
+    created_end?: string;
+}
+export interface CoinsOptions {
+    symbol?: string;
+    network?: string;
+}
+export interface CompensationsOptions extends ListOptions {
+    symbol?: string;
+    type?: string;
+    status?: string;
+    created_start?: string;
+    created_end?: string;
+}

package/dist/types/v4.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/signature.d.ts

@@ -0,0 +1 @@
+export declare function generateSignature(timestamp: string, method: string, path: string, body?: string, apiSecret?: string): string;

package/dist/utils/signature.js

@@ -0,0 +1,10 @@
+import { createHmac } from "node:crypto";
+export function generateSignature(timestamp, method, path, body = "", apiSecret = "") {
+    if (!apiSecret) {
+        throw new Error("API secret cannot be null or empty");
+    }
+    const payload = `${timestamp}${method}${path}${body}`;
+    return createHmac("sha256", Buffer.from(apiSecret, "utf8"))
+        .update(Buffer.from(payload, "utf8"))
+        .digest("hex");
+}

package/dist/v3-client.d.ts

@@ -0,0 +1,27 @@
+import { BitkubBaseClient, type BitkubClientOptions } from "./base-client.js";
+import type { BalanceInfo, BankAccount, BitkubV3Response, CancelOrderRequest, CoinConvertHistoryItem, CoinConvertHistoryOptions, Depth, FiatDepositHistoryItem, FiatWithdrawHistoryItem, FiatWithdrawRequest, FiatWithdrawResponse, LimitsResponse, OpenOrder, OrderBookEntry, OrderHistoryItem, OrderHistoryOptions, OrderInfo, PlaceOrderRequest, PlaceOrderResponse, RawTrade, StatusResponse, SymbolInfo, Ticker } from "./types/v3.js";
+export declare class BitkubV3Client extends BitkubBaseClient {
+    constructor(options: BitkubClientOptions);
+    getStatus(): Promise<StatusResponse[]>;
+    getSymbols(): Promise<BitkubV3Response<SymbolInfo[]>>;
+    getTicker(symbol?: string): Promise<Ticker[]>;
+    getBids(symbol: string, limit?: number): Promise<BitkubV3Response<OrderBookEntry[]>>;
+    getAsks(symbol: string, limit?: number): Promise<BitkubV3Response<OrderBookEntry[]>>;
+    getDepth(symbol: string, limit?: number): Promise<BitkubV3Response<Depth>>;
+    getTrades(symbol: string, limit?: number): Promise<BitkubV3Response<RawTrade[]>>;
+    getTradingCredits(): Promise<BitkubV3Response<number>>;
+    getLimits(): Promise<BitkubV3Response<LimitsResponse>>;
+    getCoinConvertHistory(options?: CoinConvertHistoryOptions): Promise<BitkubV3Response<CoinConvertHistoryItem[]>>;
+    getWallet(): Promise<BitkubV3Response<Record<string, number>>>;
+    getBalances(): Promise<BitkubV3Response<Record<string, BalanceInfo>>>;
+    placeBid(request: PlaceOrderRequest): Promise<BitkubV3Response<PlaceOrderResponse>>;
+    placeAsk(request: PlaceOrderRequest): Promise<BitkubV3Response<PlaceOrderResponse>>;
+    cancelOrder(request: CancelOrderRequest): Promise<BitkubV3Response<unknown>>;
+    getMyOpenOrders(symbol: string): Promise<BitkubV3Response<OpenOrder[]>>;
+    getMyOrderHistory(symbol: string, options?: OrderHistoryOptions): Promise<BitkubV3Response<OrderHistoryItem[]>>;
+    getOrderInfo(symbol: string, orderId: string, side: string): Promise<BitkubV3Response<OrderInfo>>;
+    getFiatAccounts(page?: number, limit?: number): Promise<BitkubV3Response<BankAccount[]>>;
+    fiatWithdraw(request: FiatWithdrawRequest): Promise<BitkubV3Response<FiatWithdrawResponse>>;
+    getFiatDepositHistory(page?: number, limit?: number): Promise<BitkubV3Response<FiatDepositHistoryItem[]>>;
+    getFiatWithdrawHistory(page?: number, limit?: number): Promise<BitkubV3Response<FiatWithdrawHistoryItem[]>>;
+}

package/dist/v3-client.js

@@ -0,0 +1,124 @@
+import { BitkubBaseClient } from "./base-client.js";
+export class BitkubV3Client extends BitkubBaseClient {
+    constructor(options) {
+        super(options);
+    }
+    async getStatus() {
+        return this.sendRequest("GET", "/api/status");
+    }
+    async getSymbols() {
+        return this.sendRequest("GET", "/api/v3/market/symbols");
+    }
+    async getTicker(symbol) {
+        return this.sendRequest("GET", "/api/v3/market/ticker", {
+            queryParams: symbol ? { sym: symbol } : undefined
+        });
+    }
+    async getBids(symbol, limit) {
+        return this.sendRequest("GET", "/api/v3/market/bids", {
+            queryParams: { sym: symbol, lmt: limit }
+        });
+    }
+    async getAsks(symbol, limit) {
+        return this.sendRequest("GET", "/api/v3/market/asks", {
+            queryParams: { sym: symbol, lmt: limit }
+        });
+    }
+    async getDepth(symbol, limit) {
+        return this.sendRequest("GET", "/api/v3/market/depth", {
+            queryParams: { sym: symbol, lmt: limit }
+        });
+    }
+    async getTrades(symbol, limit) {
+        return this.sendRequest("GET", "/api/v3/market/trades", {
+            queryParams: { sym: symbol, lmt: limit }
+        });
+    }
+    async getTradingCredits() {
+        return this.sendSecureRequest("POST", "/api/v3/user/trading-credits");
+    }
+    async getLimits() {
+        return this.sendSecureRequest("POST", "/api/v3/user/limits");
+    }
+    async getCoinConvertHistory(options = {}) {
+        return this.sendSecureRequest("GET", "/api/v3/user/coin-convert-history", {
+            queryParams: {
+                p: options.page,
+                lmt: options.limit,
+                sort: options.sort,
+                status: options.status,
+                sym: options.symbol,
+                start: options.start,
+                end: options.end
+            }
+        });
+    }
+    async getWallet() {
+        return this.sendSecureRequest("POST", "/api/v3/market/wallet");
+    }
+    async getBalances() {
+        return this.sendSecureRequest("POST", "/api/v3/market/balances");
+    }
+    async placeBid(request) {
+        return this.sendSecureRequest("POST", "/api/v3/market/place-bid", {
+            body: { typ: "limit", ...request }
+        });
+    }
+    async placeAsk(request) {
+        return this.sendSecureRequest("POST", "/api/v3/market/place-ask", {
+            body: { typ: "limit", ...request }
+        });
+    }
+    async cancelOrder(request) {
+        return this.sendSecureRequest("POST", "/api/v3/market/cancel-order", {
+            body: request
+        });
+    }
+    async getMyOpenOrders(symbol) {
+        return this.sendSecureRequest("GET", "/api/v3/market/my-open-orders", {
+            queryParams: { sym: symbol }
+        });
+    }
+    async getMyOrderHistory(symbol, options = {}) {
+        return this.sendSecureRequest("GET", "/api/v3/market/my-order-history", {
+            queryParams: {
+                sym: symbol,
+                p: options.page,
+                lmt: options.limit,
+                cursor: options.cursor,
+                start: options.start,
+                end: options.end,
+                pagination_type: options.pagination_type
+            }
+        });
+    }
+    async getOrderInfo(symbol, orderId, side) {
+        return this.sendSecureRequest("GET", "/api/v3/market/order-info", {
+            queryParams: {
+                sym: symbol,
+                id: orderId,
+                sd: side
+            }
+        });
+    }
+    async getFiatAccounts(page, limit) {
+        return this.sendSecureRequest("POST", "/api/v3/fiat/accounts", {
+            queryParams: { p: page, lmt: limit }
+        });
+    }
+    async fiatWithdraw(request) {
+        return this.sendSecureRequest("POST", "/api/v3/fiat/withdraw", {
+            body: request
+        });
+    }
+    async getFiatDepositHistory(page, limit) {
+        return this.sendSecureRequest("POST", "/api/v3/fiat/deposit-history", {
+            queryParams: { p: page, lmt: limit }
+        });
+    }
+    async getFiatWithdrawHistory(page, limit) {
+        return this.sendSecureRequest("POST", "/api/v3/fiat/withdraw-history", {
+            queryParams: { p: page, lmt: limit }
+        });
+    }
+}

package/dist/v4-client.d.ts

@@ -0,0 +1,12 @@
+import { BitkubBaseClient, type BitkubClientOptions } from "./base-client.js";
+import type { BitkubV4Response, CoinsOptions, CoinsResponse, CompensationsOptions, CompensationsResponse, CreateCryptoAddressRequest, CreateCryptoWithdrawRequest, CreateCryptoWithdrawResponse, CryptoAddress, CryptoAddressesOptions, CryptoAddressesResponse, CryptoDepositsOptions, CryptoDepositsResponse, CryptoWithdrawsOptions, CryptoWithdrawsResponse } from "./types/v4.js";
+export declare class BitkubV4Client extends BitkubBaseClient {
+    constructor(options: BitkubClientOptions);
+    getCryptoAddresses(options?: CryptoAddressesOptions): Promise<BitkubV4Response<CryptoAddressesResponse>>;
+    createCryptoAddress(request: CreateCryptoAddressRequest): Promise<BitkubV4Response<CryptoAddress[]>>;
+    getCryptoDeposits(options?: CryptoDepositsOptions): Promise<BitkubV4Response<CryptoDepositsResponse>>;
+    getCryptoWithdraws(options?: CryptoWithdrawsOptions): Promise<BitkubV4Response<CryptoWithdrawsResponse>>;
+    createCryptoWithdraw(request: CreateCryptoWithdrawRequest): Promise<BitkubV4Response<CreateCryptoWithdrawResponse>>;
+    getCoins(options?: CoinsOptions): Promise<BitkubV4Response<CoinsResponse>>;
+    getCompensations(options?: CompensationsOptions): Promise<BitkubV4Response<CompensationsResponse>>;
+}

package/dist/v4-client.js

@@ -0,0 +1,72 @@
+import { BitkubBaseClient } from "./base-client.js";
+export class BitkubV4Client extends BitkubBaseClient {
+    constructor(options) {
+        super(options);
+    }
+    async getCryptoAddresses(options = {}) {
+        return this.sendSecureRequest("GET", "/api/v4/crypto/addresses", {
+            queryParams: {
+                page: options.page,
+                limit: options.limit,
+                symbol: options.symbol,
+                network: options.network,
+                memo: options.memo
+            }
+        });
+    }
+    async createCryptoAddress(request) {
+        return this.sendSecureRequest("POST", "/api/v4/crypto/addresses", {
+            body: request
+        });
+    }
+    async getCryptoDeposits(options = {}) {
+        return this.sendSecureRequest("GET", "/api/v4/crypto/deposits", {
+            queryParams: {
+                page: options.page,
+                limit: options.limit,
+                symbol: options.symbol,
+                status: options.status,
+                created_start: options.created_start,
+                created_end: options.created_end
+            }
+        });
+    }
+    async getCryptoWithdraws(options = {}) {
+        return this.sendSecureRequest("GET", "/api/v4/crypto/withdraws", {
+            queryParams: {
+                page: options.page,
+                limit: options.limit,
+                symbol: options.symbol,
+                status: options.status,
+                created_start: options.created_start,
+                created_end: options.created_end
+            }
+        });
+    }
+    async createCryptoWithdraw(request) {
+        return this.sendSecureRequest("POST", "/api/v4/crypto/withdraws", {
+            body: request
+        });
+    }
+    async getCoins(options = {}) {
+        return this.sendSecureRequest("GET", "/api/v4/crypto/coins", {
+            queryParams: {
+                symbol: options.symbol,
+                network: options.network
+            }
+        });
+    }
+    async getCompensations(options = {}) {
+        return this.sendSecureRequest("GET", "/api/v4/crypto/compensations", {
+            queryParams: {
+                page: options.page,
+                limit: options.limit,
+                symbol: options.symbol,
+                type: options.type,
+                status: options.status,
+                created_start: options.created_start,
+                created_end: options.created_end
+            }
+        });
+    }
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "better-bitkub-client",
+  "version": "0.1.0",
+  "description": "TypeScript client for Bitkub V3 and V4 APIs",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "ssh://git@github.com:manooi/better-bitkub-client.git"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/node": "^24.5.2",
+    "typescript": "^5.8.3"
+  }
+}