@keldra/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,331 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// src/errors.ts
+var KeldraError = class _KeldraError extends Error {
+  
+  
+  constructor(code, message, cause) {
+    super(message);
+    this.name = "KeldraError";
+    this.code = code;
+    this.cause = cause;
+  }
+  static http(message, cause) {
+    return new _KeldraError("HTTP", `HTTP request failed: ${message}`, cause);
+  }
+  static api(status, message) {
+    return new KeldraApiError(status, message);
+  }
+  static timeout(relayId, lastStatus) {
+    return new KeldraTimeoutError(relayId, lastStatus);
+  }
+  static invalidTransaction(message) {
+    return new _KeldraError(
+      "INVALID_TRANSACTION",
+      `Invalid transaction: ${message}`
+    );
+  }
+  static config(message) {
+    return new _KeldraError("CONFIG", `SDK configuration error: ${message}`);
+  }
+};
+var KeldraApiError = class extends KeldraError {
+  
+  constructor(status, message) {
+    super("API", `API error (HTTP ${status}): ${message}`);
+    this.name = "KeldraApiError";
+    this.status = status;
+  }
+};
+var KeldraTimeoutError = class extends KeldraError {
+  
+  
+  constructor(relayId, lastStatus) {
+    super(
+      "TIMEOUT",
+      `Relay ${relayId} timed out (last status: ${lastStatus})`
+    );
+    this.name = "KeldraTimeoutError";
+    this.relayId = relayId;
+    this.lastStatus = lastStatus;
+  }
+};
+
+// src/utils.ts
+function parseHex(hexStr) {
+  const cleaned = hexStr.startsWith("0x") ? hexStr.slice(2) : hexStr;
+  if (cleaned.length === 0) {
+    throw KeldraError.invalidTransaction("empty transaction");
+  }
+  if (cleaned.length % 2 !== 0 || !/^[0-9a-fA-F]+$/.test(cleaned)) {
+    throw KeldraError.invalidTransaction(`invalid hex: ${hexStr}`);
+  }
+  const bytes = new Uint8Array(cleaned.length / 2);
+  for (let i = 0; i < cleaned.length; i += 2) {
+    bytes[i / 2] = parseInt(cleaned.substring(i, i + 2), 16);
+  }
+  return bytes;
+}
+function toHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function toBase64(bytes) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function extractErrorMessage(body) {
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof _optionalChain([parsed, 'optionalAccess', _ => _.error]) === "string") return parsed.error;
+  } catch (e) {
+  }
+  return body;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/http.ts
+var HttpClient = class {
+  
+  constructor(bearerToken) {
+    this.baseHeaders = { "Content-Type": "application/json" };
+    if (bearerToken) {
+      this.baseHeaders["Authorization"] = `Bearer ${bearerToken}`;
+    }
+  }
+  async get(url) {
+    return this.request("GET", url);
+  }
+  async post(url, body) {
+    return this.request("POST", url, body);
+  }
+  async request(method, url, body) {
+    let response;
+    try {
+      response = await fetch(url, {
+        method,
+        headers: this.baseHeaders,
+        body: body ? JSON.stringify(body) : void 0
+      });
+    } catch (err) {
+      throw KeldraError.http(String(err), err);
+    }
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw KeldraError.api(response.status, extractErrorMessage(text));
+    }
+    return response.json();
+  }
+};
+
+// src/padding.ts
+var BUCKETS = [512, 1024, 2048, 4096];
+function padTransaction(rawTx) {
+  const originalLen = rawTx.length;
+  const totalNeeded = originalLen + 4;
+  const bucket = BUCKETS.find((b) => b >= totalNeeded);
+  if (!bucket) {
+    throw new Error(
+      `Transaction too large: ${originalLen} bytes (max ${BUCKETS[BUCKETS.length - 1] - 4} bytes)`
+    );
+  }
+  const padded = new Uint8Array(bucket);
+  padded.set(rawTx, 0);
+  const paddingLen = bucket - totalNeeded;
+  if (paddingLen > 0) {
+    const randomBytes = crypto.getRandomValues(new Uint8Array(paddingLen));
+    padded.set(randomBytes, originalLen);
+  }
+  const view = new DataView(padded.buffer, padded.byteOffset);
+  view.setUint32(bucket - 4, originalLen, false);
+  return padded;
+}
+function unpadTransaction(padded) {
+  if (padded.length < 4) return null;
+  const view = new DataView(padded.buffer, padded.byteOffset);
+  const originalLen = view.getUint32(padded.length - 4, false);
+  if (originalLen > padded.length - 4) return null;
+  return padded.slice(0, originalLen);
+}
+
+// src/types.ts
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "confirmed",
+  "failed"
+]);
+
+// src/client.ts
+var DEFAULT_GATEWAY_URL = "http://localhost:3400";
+var DEFAULT_TIMEOUT_MS = 3e5;
+var DEFAULT_POLL_INTERVAL_MS = 2e3;
+var MAX_POLL_INTERVAL_MS = 15e3;
+var KeldraClient = class _KeldraClient {
+  
+  
+  
+  
+  
+  
+  
+  
+  constructor(config) {
+    if (!config.apiKey) {
+      throw KeldraError.config("apiKey is required");
+    }
+    this.http = new HttpClient(config.apiKey);
+    this.gatewayUrl = (_nullishCoalesce(config.gatewayUrl, () => ( DEFAULT_GATEWAY_URL))).replace(
+      /\/$/,
+      ""
+    );
+    this.defaultDelayProfile = _nullishCoalesce(config.delayProfile, () => ( "balanced"));
+    this.confirmationTimeoutMs = _nullishCoalesce(config.timeoutMs, () => ( DEFAULT_TIMEOUT_MS));
+    this.pollIntervalMs = _nullishCoalesce(config.pollIntervalMs, () => ( DEFAULT_POLL_INTERVAL_MS));
+    this.noisePublicKey = config.noisePublicKey;
+    this.noiseKid = config.noiseKid;
+    this.encryptFn = config.encryptFn;
+  }
+  static create(apiKey) {
+    return new _KeldraClient({ apiKey });
+  }
+  static builder() {
+    return new KeldraClientBuilder();
+  }
+  async relay(chain, signedTx) {
+    const start = Date.now();
+    const response = await this.submit(chain, signedTx);
+    const result = await this.waitForConfirmation(response.relay_id);
+    return {
+      relayId: response.relay_id,
+      status: result.status,
+      txHash: result.tx_hash,
+      durationMs: Date.now() - start,
+      error: result.error
+    };
+  }
+  async submit(chain, signedTx) {
+    const rawBytes = parseHex(signedTx);
+    const padded = padTransaction(rawBytes);
+    let request;
+    if (this.noisePublicKey && this.noiseKid && this.encryptFn) {
+      const encrypted = await this.encryptFn(padded, this.noisePublicKey);
+      const b64 = toBase64(encrypted);
+      request = {
+        chain,
+        signed_tx: "",
+        options: { delay_profile: this.defaultDelayProfile },
+        encrypted_payload: b64,
+        noise_kid: this.noiseKid
+      };
+    } else {
+      request = {
+        chain,
+        signed_tx: `0x${toHex(padded)}`,
+        options: { delay_profile: this.defaultDelayProfile }
+      };
+    }
+    return this.http.post(
+      `${this.gatewayUrl}/v1/relay`,
+      request
+    );
+  }
+  async status(relayId) {
+    return this.http.get(
+      `${this.gatewayUrl}/v1/relay/${relayId}/status`
+    );
+  }
+  async waitForConfirmation(relayId) {
+    const deadline = Date.now() + this.confirmationTimeoutMs;
+    let interval = this.pollIntervalMs;
+    let lastStatus;
+    while (Date.now() < deadline) {
+      await sleep(interval);
+      try {
+        lastStatus = await this.status(relayId);
+        if (TERMINAL_STATUSES.has(lastStatus.status)) {
+          return lastStatus;
+        }
+      } catch (e2) {
+      }
+      interval = Math.min(interval * 2, MAX_POLL_INTERVAL_MS);
+    }
+    throw KeldraError.timeout(relayId, _nullishCoalesce(_optionalChain([lastStatus, 'optionalAccess', _2 => _2.status]), () => ( "queued")));
+  }
+  async health() {
+    return this.http.get(`${this.gatewayUrl}/v1/health`);
+  }
+  async chains() {
+    return this.http.get(`${this.gatewayUrl}/v1/chains`);
+  }
+  async limits() {
+    return this.http.get(`${this.gatewayUrl}/v1/me/limits`);
+  }
+  async usage(from, to) {
+    const params = new URLSearchParams({ from, to });
+    return this.http.get(
+      `${this.gatewayUrl}/v1/me/usage?${params.toString()}`
+    );
+  }
+  async fetchNoiseKey() {
+    const resp = await this.http.get(
+      `${this.gatewayUrl}/v1/noise-key`
+    );
+    this.noisePublicKey = resp.public_key;
+    this.noiseKid = resp.kid;
+  }
+  get encrypted() {
+    return !!(this.noisePublicKey && this.noiseKid && this.encryptFn);
+  }
+};
+var KeldraClientBuilder = (_class = class {constructor() { _class.prototype.__init.call(this); }
+  __init() {this.config = {}}
+  apiKey(key) {
+    this.config.apiKey = key;
+    return this;
+  }
+  gatewayUrl(url) {
+    this.config.gatewayUrl = url;
+    return this;
+  }
+  delayProfile(profile) {
+    this.config.delayProfile = profile;
+    return this;
+  }
+  timeout(ms) {
+    this.config.timeoutMs = ms;
+    return this;
+  }
+  pollInterval(ms) {
+    this.config.pollIntervalMs = ms;
+    return this;
+  }
+  noisePublicKey(key, kid) {
+    this.config.noisePublicKey = key;
+    this.config.noiseKid = kid;
+    return this;
+  }
+  withEncryption(fn) {
+    this.config.encryptFn = fn;
+    return this;
+  }
+  build() {
+    if (!this.config.apiKey) {
+      throw KeldraError.config("apiKey is required");
+    }
+    return new KeldraClient(this.config);
+  }
+}, _class);
+
+
+
+
+
+
+
+
+
+exports.KeldraApiError = KeldraApiError; exports.KeldraClient = KeldraClient; exports.KeldraClientBuilder = KeldraClientBuilder; exports.KeldraError = KeldraError; exports.KeldraTimeoutError = KeldraTimeoutError; exports.TERMINAL_STATUSES = TERMINAL_STATUSES; exports.padTransaction = padTransaction; exports.unpadTransaction = unpadTransaction;

package/dist/index.d.cts

@@ -0,0 +1,29 @@
+export { K as KeldraClient, a as KeldraClientBuilder } from './client-Bm1hg0EA.cjs';
+import { R as RelayStatus } from './types-CL-VpP9K.cjs';
+export { C as Chain, a as ChainConfig, b as ChainsResponse, D as DelayProfile, E as EncryptFn, H as HealthResponse, c as HealthStats, K as KeldraClientConfig, M as MeLimitsResponse, d as MeUsageResponse, N as NoiseKeyResponse, e as RelayOptions, f as RelayRequest, g as RelayResponse, h as RelayResult, i as RelayStatusResponse, T as TERMINAL_STATUSES, U as UsageDailyRow, j as UsageTotals } from './types-CL-VpP9K.cjs';
+
+type KeldraErrorCode = 'HTTP' | 'API' | 'TIMEOUT' | 'INVALID_TRANSACTION' | 'CONFIG';
+declare class KeldraError extends Error {
+    readonly code: KeldraErrorCode;
+    readonly cause?: unknown;
+    constructor(code: KeldraErrorCode, message: string, cause?: unknown);
+    static http(message: string, cause?: unknown): KeldraError;
+    static api(status: number, message: string): KeldraApiError;
+    static timeout(relayId: string, lastStatus: RelayStatus): KeldraTimeoutError;
+    static invalidTransaction(message: string): KeldraError;
+    static config(message: string): KeldraError;
+}
+declare class KeldraApiError extends KeldraError {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+declare class KeldraTimeoutError extends KeldraError {
+    readonly relayId: string;
+    readonly lastStatus: RelayStatus;
+    constructor(relayId: string, lastStatus: RelayStatus);
+}
+
+declare function padTransaction(rawTx: Uint8Array): Uint8Array;
+declare function unpadTransaction(padded: Uint8Array): Uint8Array | null;
+
+export { KeldraApiError, KeldraError, type KeldraErrorCode, KeldraTimeoutError, RelayStatus, padTransaction, unpadTransaction };

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+export { K as KeldraClient, a as KeldraClientBuilder } from './client-03PUOnb6.js';
+import { R as RelayStatus } from './types-CL-VpP9K.js';
+export { C as Chain, a as ChainConfig, b as ChainsResponse, D as DelayProfile, E as EncryptFn, H as HealthResponse, c as HealthStats, K as KeldraClientConfig, M as MeLimitsResponse, d as MeUsageResponse, N as NoiseKeyResponse, e as RelayOptions, f as RelayRequest, g as RelayResponse, h as RelayResult, i as RelayStatusResponse, T as TERMINAL_STATUSES, U as UsageDailyRow, j as UsageTotals } from './types-CL-VpP9K.js';
+
+type KeldraErrorCode = 'HTTP' | 'API' | 'TIMEOUT' | 'INVALID_TRANSACTION' | 'CONFIG';
+declare class KeldraError extends Error {
+    readonly code: KeldraErrorCode;
+    readonly cause?: unknown;
+    constructor(code: KeldraErrorCode, message: string, cause?: unknown);
+    static http(message: string, cause?: unknown): KeldraError;
+    static api(status: number, message: string): KeldraApiError;
+    static timeout(relayId: string, lastStatus: RelayStatus): KeldraTimeoutError;
+    static invalidTransaction(message: string): KeldraError;
+    static config(message: string): KeldraError;
+}
+declare class KeldraApiError extends KeldraError {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+declare class KeldraTimeoutError extends KeldraError {
+    readonly relayId: string;
+    readonly lastStatus: RelayStatus;
+    constructor(relayId: string, lastStatus: RelayStatus);
+}
+
+declare function padTransaction(rawTx: Uint8Array): Uint8Array;
+declare function unpadTransaction(padded: Uint8Array): Uint8Array | null;
+
+export { KeldraApiError, KeldraError, type KeldraErrorCode, KeldraTimeoutError, RelayStatus, padTransaction, unpadTransaction };