@xoxno/sdk-js 1.0.223 → 1.0.225

package/dist/cjs/sdk/stellar/__tests__/admin.test.d.ts

@@ -1,13 +1 @@
-/**
- * Snapshot + structural tests for the Stellar lending admin / config / keeper /
- * access transaction builders.
- *
- * Beyond the function-name / arg-count / determinism / snapshot guards, this
- * suite decodes the complex `#[contracttype]` struct args
- * (`MarketOracleConfigInput`, `AssetConfigRaw`) back out of the XDR and asserts
- * the ScMap keys are ascending-sorted (the Soroban host requires sorted symbol
- * keys) and that the oracle union / custom-option tags are well-formed. For the
- * all-lowercase snake_case field sets used here, JS lexicographic order matches
- * Soroban's symbol collation.
- */
 export {};

package/dist/cjs/sdk/stellar/__tests__/builders-hubasset.test.d.ts

@@ -1,12 +1 @@
-/**
- * Multi-hub ABI encoding tests for the Stellar lending builders.
- *
- * Asserts the on-the-wire ScVal shape after the migration from the old
- * `(Address, i128)` + `e_mode_category` ABI to the multi-hub
- * `(HubAssetKey, i128)` + `spoke_id` ABI:
- *   - `supply` carries `spoke_id` as a `u32` and a `Vec<(HubAssetKey, i128)>`.
- *   - each `HubAssetKey` is a struct/map whose symbol keys are sorted
- *     (`asset`, `hub_id`) — the canonical Soroban `#[contracttype]` layout.
- *   - `borrow` carries the same `Vec<(HubAssetKey, i128)>` payload.
- */
 export {};

package/dist/cjs/sdk/stellar/__tests__/governance.test.d.ts

@@ -1,5 +1 @@
-/**
- * Snapshot + structural tests for governance `propose_*` transaction builders
- * used by the admin dashboard (timelock proposals).
- */
 export {};

package/dist/cjs/sdk/stellar/__tests__/lending.test.d.ts

@@ -1,21 +1 @@
-/**
- * Snapshot + sanity tests for the Stellar Soroban lending transaction builders.
- *
- * These tests assert:
- *   1. Every builder returns a non-empty base64 XDR.
- *   2. XDR parses back into a valid Transaction with exactly one InvokeHostFunction
- *      operation targeting the configured controller contract.
- *   3. The function name encoded in the XDR matches the Stellar controller
- *      entry point exactly (`supply`, `borrow`, `withdraw`, `repay`,
- *      `liquidate`, `flash_loan`, `multiply`, `swap_debt`, `swap_collateral`,
- *      `repay_debt_with_collateral`).
- *   4. The XDR is deterministic — identical fixture inputs yield identical XDR.
- *   5. Stable snapshots for the full XDR of every builder (regression guard
- *      for any unintended encoding change).
- *
- * Builders are RPC-free — they accept a `sourceSequence` so output is
- * fully deterministic and snapshot-testable. The UI layer is responsible
- * for fetching the sequence and running `rpc.Server.prepareTransaction`
- * before signing.
- */
 export {};

package/dist/cjs/sdk/stellar/__tests__/strategy-program.test.d.ts

@@ -1,9 +1 @@
-/**
- * Cross-language wire-format check for the aggregator's packed strategy program.
- *
- * The same fixtures are asserted byte-for-byte in
- * `contracts/swap-aggregator/tests/unit/payload_wire_format.rs` and
- * `arb-algo/stellar-indexer/src/transaction/abi.rs`. If this file and those
- * diverge, routes built by this SDK will be rejected on-chain.
- */
 export {};

package/dist/cjs/sdk/stellar/__tests__/swap-history.test.d.ts

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

package/dist/cjs/sdk/stellar/index.d.ts

@@ -14,6 +14,7 @@ export * from './governance.js';
 export * from './events/index.js';
 export * from './quote.js';
 export * from './swap.js';
+export * from './swap-history.js';
 export * from './route-verify.js';
 export * from './auth-policy.js';
 export * from './prepare.js';

package/dist/cjs/sdk/stellar/swap-history.d.ts

@@ -0,0 +1,25 @@
+export interface StellarSwapEnvelopeOptions {
+    envelopeXdr: string;
+    networkPassphrase: string;
+    /** Router pinned by the application for this network. */
+    routerAddress: string;
+    /** Only swaps whose encoded sender equals this address are returned. */
+    viewer: string;
+    /** Zero-based operation index in the inner transaction. */
+    operationIndex?: number;
+}
+export interface DecodedStellarSwapEnvelope {
+    tokenIn: string;
+    tokenOut: string;
+    /** Exact positive input in base units; never converted to a JS number. */
+    amountInAtoms: string;
+    operationIndex: number;
+}
+/**
+ * Synchronously decode direct XOXNO router swaps, including fee-bump envelopes.
+ * Returns null for malformed, unrelated or ambiguous envelopes. Without an
+ * operation index exactly one matching swap is required. No RPC or output
+ * amount inference: the route minimum is not the amount actually received.
+ * The network passphrase parses the envelope; it cannot prove its network.
+ */
+export declare function decodeStellarSwapEnvelope(options: StellarSwapEnvelopeOptions): DecodedStellarSwapEnvelope | null;

package/dist/cjs/sdk/stellar/swap-index.d.ts

@@ -0,0 +1,2 @@
+export { decodeStellarSwapEnvelope } from './swap-history.js';
+export type { DecodedStellarSwapEnvelope, StellarSwapEnvelopeOptions } from './swap-history.js';

package/dist/cjs/sdk/stellar/xdr-compat.d.ts

@@ -0,0 +1,11 @@
+import { Buffer } from 'buffer';
+type FieldValue<T> = T extends (...args: never[]) => infer R ? R : T;
+/** SDK 16 exposes XDR getters; SDK 17 exposes the same fields as properties. */
+export declare function xdrField<T, K extends keyof T>(value: T, key: K): FieldValue<T[K]>;
+export declare function xdrType(value: unknown): string | undefined;
+/** SDK 17 opaque byte fields wrap their Uint8Array in `value`. */
+export declare function xdrBytes(value: {
+    bytes: unknown;
+}): Buffer;
+export declare function xdrOpaque(value: unknown): Buffer;
+export {};

package/dist/esm/index.js

@@ -0,0 +1,3 @@
+export * from "./utils/api.js";
+export * from "./utils/regex.js";
+export * from "./sdk/index.js";

package/dist/esm/sdk/index.js

@@ -0,0 +1,198 @@
+import { AddressNotFoundError, CollectionNotFoundError } from "../utils/errors.js";
+import { isAddressValid } from "../utils/helpers.js";
+import { isValidCollectionTicker } from "../utils/regex.js";
+import { endpoints as routes } from "./swagger.js";
+import { coveredMethods } from "./utils.js";
+// Stellar Soroban lending transaction builders (Wave 1B).
+// Additive re-export — no overlap with the auto-generated read SDK.
+export * from "./stellar/index.js";
+const kebabToCamel = (s)=>s.replace(/-([a-z])/g, (_, c)=>c.toUpperCase());
+const makeNode = ()=>({
+        static: {},
+        params: {},
+        leaves: []
+    });
+function buildTemplate() {
+    const root = makeNode();
+    for (const [rawPath, def] of Object.entries(routes)){
+        const segs = rawPath.split('/').filter(Boolean);
+        let node = root;
+        for (const seg of segs){
+            if (seg.startsWith(':')) {
+                var _node_params, _p;
+                const p = kebabToCamel(seg.slice(1));
+                node = (_node_params = node.params)[_p = p] || (_node_params[_p] = makeNode());
+            } else {
+                var _node_static, _k;
+                const k = kebabToCamel(seg);
+                node = (_node_static = node.static)[_k = k] || (_node_static[_k] = makeNode());
+            }
+        }
+        node.leaves.push({
+            rawPath,
+            def
+        });
+    }
+    return root;
+}
+function makeLeafHandler(rawPath, def, bound, client) {
+    const { input: _input, output: _output, ...rest } = def;
+    const core = async (args = {})=>{
+        const fullArgs = {
+            ...bound,
+            ...args
+        };
+        const url = rawPath.replace(/:([a-zA-Z_]+)/g, (_, p)=>`${fullArgs[p]}`);
+        const paramNames = [
+            ...rawPath.matchAll(/:([a-zA-Z_]+)/g)
+        ].map((m)=>m[1]);
+        const extraArgs = Object.fromEntries(Object.entries(fullArgs).filter(([k])=>!paramNames.includes(k)));
+        const hasAddress = /:address[^A-Z]/.test(rawPath) || 'address' in extraArgs;
+        const hasCollection = /:collection[^A-Z]/.test(rawPath) || 'collection' in extraArgs;
+        if (hasAddress) {
+            const addr = fullArgs.address;
+            if (!isAddressValid(addr)) throw new AddressNotFoundError(addr);
+        }
+        if (hasCollection) {
+            const col = fullArgs.collection;
+            const bad = Array.isArray(col) ? col.some((x)=>!isValidCollectionTicker(x)) : !isValidCollectionTicker(col);
+            if (bad) throw new CollectionNotFoundError(col);
+        }
+        const extraArgsConv = Object.fromEntries(Object.entries(extraArgs).map(([k, v])=>{
+            return [
+                k,
+                v instanceof FormData ? v : k === 'filter' || k === 'body' ? JSON.stringify(v) : Array.isArray(v) ? v.join(',') : v
+            ];
+        }));
+        const { body, auth, method, headers, cache, next, debug, signal, credentials, mode, redirect, referrer, referrerPolicy, integrity, keepalive, priority, window, continuationToken, ...params } = extraArgsConv;
+        const Authorization = auth ? `Bearer ${auth}` : undefined;
+        // Stellar cursor endpoints declare a query parameter. Other API families
+        // retain the legacy header convention.
+        if (rawPath.startsWith('/stellar-lending/') && continuationToken !== undefined) {
+            params.continuationToken = continuationToken;
+        }
+        const headersData = {
+            ...headers,
+            ...Authorization ? {
+                Authorization
+            } : {},
+            ...continuationToken && !rawPath.startsWith('/stellar-lending/') ? {
+                'X-Continuation-Token': String(continuationToken)
+            } : {}
+        };
+        const hydratedNext = {
+            ...next,
+            tags: [
+                ...next?.tags ?? [],
+                url
+            ]
+        };
+        return client.fetchWithTimeout(url, {
+            method,
+            params,
+            body,
+            headers: headersData,
+            cache,
+            debug,
+            ...Object.fromEntries(Object.entries({
+                signal,
+                credentials,
+                mode,
+                redirect,
+                referrer,
+                referrerPolicy,
+                integrity,
+                keepalive,
+                priority,
+                window
+            }).filter(([, value])=>value !== undefined)),
+            ...hydratedNext ? {
+                next: hydratedNext
+            } : {}
+        });
+    };
+    const leaf = (args = {})=>core(args);
+    for (const verb of Object.keys(rest)){
+        if (!coveredMethods.includes(verb)) continue;
+        leaf[verb] = (va)=>core({
+                ...va,
+                method: va.method ?? verb.toUpperCase()
+            });
+    }
+    return leaf;
+}
+export function buildSdk(client) {
+    const tplRoot = buildTemplate();
+    const instantiate = (tpl, bound)=>{
+        // 1) detect “one leaf + other children” case
+        const leafCount = tpl.leaves.length;
+        const staticCount = Object.keys(tpl.static).length;
+        const paramCount = Object.keys(tpl.params).length;
+        const isLeafWithChildren = leafCount === 1 && staticCount + paramCount > 0;
+        let obj;
+        // 2) if exactly one leaf and it has static/param siblings → use its handler as the root object
+        if (isLeafWithChildren) {
+            const { rawPath, def } = tpl.leaves[0];
+            obj = makeLeafHandler(rawPath, def, bound, client);
+        } else {
+            // otherwise, build a plain object and attach all leaves under their keys
+            obj = {};
+            for (const { rawPath, def } of tpl.leaves){
+                const leafKey = kebabToCamel(rawPath.split('/').pop().replace(/^:/, ''));
+                obj[leafKey] = makeLeafHandler(rawPath, def, bound, client);
+            }
+        }
+        // 3) now merge in all the static‐children
+        for (const [key, childTpl] of Object.entries(tpl.static)){
+            const produced = instantiate(childTpl, bound);
+            // exactly your existing “flatten‐or‐assign” logic will work here
+            let flat = produced;
+            if (produced && typeof produced === 'object' && key in produced && typeof produced[key] === 'function') {
+                const fn = produced[key];
+                const rest = Object.fromEntries(Object.entries(produced).filter(([k])=>k !== key));
+                const isParamHandler = fn.length === 1;
+                if (!isParamHandler) {
+                    Object.assign(fn, rest);
+                    flat = fn;
+                }
+            }
+            if (obj[key] === undefined) {
+                obj[key] = flat;
+            } else if (typeof obj[key] === 'function') {
+                Object.assign(obj[key], flat);
+            } else if (typeof flat === 'function') {
+                Object.assign(flat, obj[key]);
+                obj[key] = flat;
+            } else {
+                Object.assign(obj[key], flat);
+            }
+        }
+        // 4) and then all the param‐children exactly as before
+        for (const [paramKey, childTpl] of Object.entries(tpl.params)){
+            const paramFn = (value)=>{
+                const produced = instantiate(childTpl, {
+                    ...bound,
+                    [paramKey]: value
+                });
+                // your existing “unwrap single‐key proxy” hack
+                if (produced && typeof produced === 'object' && Object.keys(produced).length === 1 && paramKey in produced && typeof produced[paramKey] === 'function') {
+                    const leaf = produced[paramKey];
+                    const proxy = (...a)=>leaf(...a);
+                    return Object.assign(proxy, leaf);
+                }
+                return produced;
+            };
+            if (obj[paramKey]) {
+                const prev = obj[paramKey];
+                obj[paramKey] = (v)=>({
+                        ...prev(v),
+                        ...paramFn(v)
+                    });
+            } else {
+                obj[paramKey] = paramFn;
+            }
+        }
+        return obj;
+    };
+    return instantiate(tplRoot, {});
+}