@lumenwipe/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,178 @@
+// src/errors.ts
+var LumenWipeApiError = class extends Error {
+  constructor(status, body) {
+    super(`LumenWipe API error ${status}`);
+    this.status = status;
+    this.body = body;
+    this.name = "LumenWipeApiError";
+  }
+};
+var LumenWipeTimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super(`LumenWipe API request timed out after ${timeoutMs}ms`);
+    this.timeoutMs = timeoutMs;
+    this.name = "LumenWipeTimeoutError";
+  }
+};
+
+// src/http.ts
+var HttpTransport = class {
+  constructor(baseUrl, apiKey, timeout, doFetch) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+    this.timeout = timeout;
+    this.doFetch = doFetch;
+  }
+  async request(method, path, body) {
+    const headers = { Authorization: `Bearer ${this.apiKey}` };
+    if (body !== void 0) headers["Content-Type"] = "application/json";
+    const controller = new AbortController();
+    const bounded = Number.isFinite(this.timeout) && this.timeout > 0;
+    const timer = bounded ? setTimeout(() => controller.abort(), this.timeout) : void 0;
+    try {
+      const res = await this.doFetch(`${this.baseUrl}${path}`, {
+        method,
+        headers,
+        body: body !== void 0 ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      const text = await res.text();
+      let parsed = void 0;
+      if (text) {
+        try {
+          parsed = JSON.parse(text);
+        } catch (e) {
+          parsed = text;
+        }
+      }
+      if (!res.ok) throw new LumenWipeApiError(res.status, parsed);
+      return parsed;
+    } catch (e) {
+      if (controller.signal.aborted) throw new LumenWipeTimeoutError(this.timeout);
+      throw e;
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+};
+
+// src/client.ts
+var LumenWipeClient = class {
+  constructor(options) {
+    var _a, _b, _c;
+    const resolved = (_a = options.fetch) != null ? _a : globalThis.fetch;
+    if (!resolved) {
+      throw new Error("No fetch implementation available; pass one via options.fetch.");
+    }
+    this.http = new HttpTransport(
+      options.baseUrl.replace(/\/+$/, ""),
+      options.apiKey,
+      (_b = options.timeout) != null ? _b : 3e4,
+      resolved
+    );
+    this.defaultNetwork = (_c = options.network) != null ? _c : "testnet";
+  }
+  health() {
+    return this.http.request("GET", "/health");
+  }
+  getAccount(address, network = this.defaultNetwork) {
+    return this.http.request(
+      "GET",
+      `/${network}/account/${encodeURIComponent(address)}`
+    );
+  }
+  getPaths(params, network = this.defaultNetwork) {
+    const query = new URLSearchParams({ fromAsset: params.fromAsset, amount: params.amount });
+    return this.http.request("GET", `/${network}/paths?${query.toString()}`);
+  }
+  closePlan(body, network = this.defaultNetwork) {
+    return this.http.request("POST", `/v1/${network}/close/plan`, body);
+  }
+  /**
+   * Builds the next unsigned transaction(s) for a close. A close can span several
+   * transactions (a fused close, or separate claim / cleanup / mediator-merge steps),
+   * so the response's `remaining.requiresAnotherCall` says whether more follow: sign and
+   * submit the returned transactions in `order`, wait for confirmation, then call this
+   * again until `requiresAnotherCall` is false.
+   */
+  closeTransactions(body, network = this.defaultNetwork) {
+    return this.http.request(
+      "POST",
+      `/v1/${network}/close/transactions`,
+      body
+    );
+  }
+  submit(signedXdr, network = this.defaultNetwork) {
+    return this.http.request("POST", `/v1/${network}/submit`, { signedXdr });
+  }
+  mediatorCheck(address, network = this.defaultNetwork) {
+    return this.http.request(
+      "GET",
+      `/${network}/mediator/check/${encodeURIComponent(address)}`
+    );
+  }
+  mediatorSign(transaction, network = this.defaultNetwork) {
+    return this.http.request("POST", `/${network}/mediator/sign`, {
+      transaction
+    });
+  }
+};
+
+// src/close-engine.ts
+var InsufficientSignatureWeightError = class extends Error {
+  constructor(pending) {
+    super(
+      `Transaction ${pending.tx.id} needs signing weight ${pending.requiredWeight} but only has ${pending.accumulatedWeight}.`
+    );
+    this.pending = pending;
+    this.name = "InsufficientSignatureWeightError";
+  }
+};
+async function runClose(deps, resume) {
+  var _a, _b;
+  const maxRounds = (_a = deps.maxRounds) != null ? _a : 25;
+  if (resume) {
+    await signOrThrow(deps, resume.tx, resume.xdr, resume.queue, resume.requiresAnotherCall);
+    await processTxs(deps, resume.queue, resume.requiresAnotherCall);
+    if (!resume.requiresAnotherCall) return;
+  }
+  for (let round = 0; round < maxRounds; round++) {
+    (_b = deps.onProgress) == null ? void 0 : _b.call(deps, "Preparing transactions\u2026");
+    const batch = await deps.getTransactions();
+    const txs = [...batch.transactions].sort((a, b) => a.order - b.order);
+    await processTxs(deps, txs, batch.remaining.requiresAnotherCall);
+    if (!batch.remaining.requiresAnotherCall) return;
+  }
+  throw new Error("The close did not converge after the maximum number of rounds.");
+}
+async function processTxs(deps, txs, requiresAnotherCall) {
+  for (let i = 0; i < txs.length; i++) {
+    const tx = txs[i];
+    await deps.verify(tx);
+    await signOrThrow(deps, tx, tx.xdr, txs.slice(i + 1), requiresAnotherCall);
+  }
+}
+async function signOrThrow(deps, tx, xdr, queue, requiresAnotherCall) {
+  var _a;
+  const required = deps.requiredWeight(tx);
+  const { xdr: signedXdr, weight } = await deps.sign(tx, xdr);
+  if (weight < required) {
+    throw new InsufficientSignatureWeightError({
+      tx,
+      xdr: signedXdr,
+      requiredWeight: required,
+      accumulatedWeight: weight,
+      queue,
+      requiresAnotherCall
+    });
+  }
+  const hash = await deps.submit(tx, signedXdr);
+  (_a = deps.onConfirmed) == null ? void 0 : _a.call(deps, tx, hash);
+}
+export {
+  InsufficientSignatureWeightError,
+  LumenWipeApiError,
+  LumenWipeClient,
+  LumenWipeTimeoutError,
+  runClose
+};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@lumenwipe/sdk",
+  "version": "0.1.0",
+  "description": "Typed fetch client for the LumenWipe API - non-custodial Stellar account closing.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LumenWipe/lumenwipe.git",
+    "directory": "packages/sdk"
+  },
+  "homepage": "https://github.com/LumenWipe/lumenwipe/tree/main/packages/sdk#readme",
+  "bugs": "https://github.com/LumenWipe/lumenwipe/issues",
+  "keywords": [
+    "stellar",
+    "sdk",
+    "wallet",
+    "account-merge"
+  ],
+  "scripts": {
+    "build": "bun run --filter '@lumenwipe/types' build && tsup src/index.ts --format esm,cjs --clean && tsc -p tsconfig.build.json && api-extractor run --local && cp dist/index.d.ts dist/index.d.cts",
+    "type-check": "tsc --noEmit && tsc -p tests/tsconfig.json --noEmit",
+    "lint": "eslint src",
+    "test": "bun test tests"
+  },
+  "devDependencies": {
+    "@microsoft/api-extractor": "^7.58.12",
+    "@types/bun": "^1.3.14",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "eslint": "^8.57.1",
+    "tsup": "^8.3.0",
+    "typescript": "^5.9.3",
+    "@lumenwipe/types": "workspace:*"
+  }
+}