@xoxno/sdk-js 1.0.224 → 1.0.226

package/dist/esm/sdk/types.js

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

package/dist/esm/sdk/utils.js

@@ -0,0 +1,21 @@
+export const coveredMethods = [
+    'PATCH',
+    'POST',
+    'DELETE',
+    'PUT'
+];
+const _nestTypes = [
+    'string',
+    'number',
+    'boolean'
+];
+const _returnTypes = [
+    'application/json',
+    'multipart/form-data'
+];
+const _securityModes = [
+    'requiredAny',
+    'requiredWeb2',
+    'requiredJwt',
+    'optionalAny'
+];

package/dist/esm/utils/api.js

@@ -0,0 +1,169 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { DR_SC, FM_SC, KG_SC, Manager_SC, Manager_SC_DEV, P2P_SC, P2P_SC_DEV, Staking_SC, Staking_SC_DEV, XOXNO_SC, XOXNO_SC_DEV } from "./const.js";
+/**
+ * Default read deadline. Without one, a stalled response is bounded only by
+ * whatever the host runtime imposes (in Node, undici's Agent), which is
+ * typically longer than the caller's own budget — a Next.js `'use cache'` fill,
+ * for instance, gives up at `staticPageGenerationTimeout * 0.9` and turns the
+ * stall into a hard error instead of a fetch rejection the caller can degrade
+ * on. Generous enough that only a genuinely stuck read hits it.
+ */ export const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+export var Chain = /*#__PURE__*/ function(Chain) {
+    Chain["MAINNET"] = "1";
+    Chain["DEVNET"] = "D";
+    return Chain;
+}({});
+export class XOXNOClient {
+    /** Create a client bound to one application-selected API deployment. */ constructor(options){
+        _define_property(this, "apiUrl", void 0);
+        _define_property(this, "chain", void 0);
+        _define_property(this, "init", void 0);
+        _define_property(this, "config", void 0);
+        _define_property(this, "fetchWithTimeout", async (path, { params, ...options } = {})=>{
+            const { next, cache, debug, timeout, ...rest } = this.init;
+            const { next: overwriteNext, cache: overwriteCache, debug: overwriteDebug, timeout: overwriteTimeout, headers, method = 'GET', ...overwriteRest } = options;
+            const authHeader = headers?.Authorization;
+            const Authorization = authHeader === 'Bearer undefined' ? undefined : authHeader;
+            // A GET/HEAD has no body, so Content-Type describes nothing — but in a
+            // browser it is the difference between a "simple" CORS request and one
+            // that needs a preflight. `application/json` is not on the CORS-safelist,
+            // so setting it here made every unauthenticated GET cost an extra OPTIONS
+            // round trip to the origin (~180k/week, 17% of all API requests, ~200ms
+            // each, none of them cacheable at the edge).
+            //
+            // Authenticated calls still preflight — Authorization is not safelisted
+            // either — and that is unavoidable. This only stops charging public reads
+            // for a header that carries no meaning on a bodyless request.
+            const hasBody = method !== 'GET' && method !== 'HEAD' && method !== 'PUT';
+            const allHeaders = {
+                ...headers,
+                // Both are forbidden header names: browsers drop them silently, so they
+                // only ever apply to server-side (Node) callers.
+                Referer: 'https://xoxno.sdk',
+                'User-Agent': 'XOXNO/1.0/SDK',
+                ...hasBody ? {
+                    'Content-Type': 'application/json'
+                } : {},
+                ...Authorization ? {
+                    Authorization
+                } : {}
+            };
+            const query = Object.entries(params ?? {}).filter(([, value])=>value !== undefined).flatMap(([key, value])=>{
+                if (Array.isArray(value)) {
+                    return value.filter((v)=>v !== undefined).map((v)=>`${key}=${encodeURIComponent(v)}`);
+                } else {
+                    return `${key}=${encodeURIComponent(value)}`;
+                }
+            }).join('&');
+            const url = `${this.apiUrl}${path}${query.length ? `?${query}` : ''}`;
+            const { revalidate, ...other } = next ?? {};
+            const { revalidate: overwriteRevalidate, ...overwriteOther } = overwriteNext ?? {};
+            const finalRevalidate = method === 'GET' && !Authorization ? overwriteRevalidate ?? revalidate : undefined;
+            const finalCache = method === 'GET' && !Authorization && !finalRevalidate ? overwriteCache ?? cache : undefined;
+            // A body's duration is uplink-bound, so it is only deadlined when the caller
+            // asks for it; a read is not.
+            const body = overwriteRest.body;
+            const effectiveTimeout = overwriteTimeout ?? timeout ?? (body == null ? DEFAULT_REQUEST_TIMEOUT_MS : 0);
+            const deadline = effectiveTimeout > 0 ? AbortSignal.timeout(effectiveTimeout) : undefined;
+            const callerSignal = overwriteRest.signal ?? rest.signal;
+            const signal = deadline && callerSignal ? AbortSignal.any([
+                callerSignal,
+                deadline
+            ]) : deadline ?? callerSignal;
+            const init = {
+                ...rest,
+                ...overwriteRest,
+                method,
+                ...Object.keys(allHeaders).length ? {
+                    headers: allHeaders
+                } : {},
+                ...signal ? {
+                    signal
+                } : {},
+                cache: finalCache,
+                next: {
+                    ...other,
+                    ...overwriteOther,
+                    revalidate: finalRevalidate
+                }
+            };
+            if (overwriteDebug ?? debug) {
+                console.debug('SDK fetch: ', url, init);
+            }
+            const res = await fetch(url, init).catch((error)=>{
+                if (error instanceof Error && !error.message.match(/^http(s?):\/\//)) {
+                    // Preserve the underlying network reason as `cause` — the undici/system
+                    // error carries the real code (UND_ERR_SOCKET, ECONNREFUSED, ENOTFOUND,
+                    // timeouts). Without it the thrown message is only "<url>: fetch failed".
+                    throw Object.assign(new Error(`${url}: ${error.message}`), {
+                        cause: error
+                    });
+                }
+                throw error;
+            });
+            const text = await res.text();
+            if (!res.ok) {
+                let message;
+                try {
+                    message = JSON.parse(text);
+                } catch  {
+                    message = {
+                        message: text
+                    };
+                }
+                const errorMessage = [
+                    url,
+                    res.status,
+                    res.statusText,
+                    message.message
+                ].filter(Boolean).join(';;');
+                throw new Error(errorMessage);
+            }
+            try {
+                return JSON.parse(text);
+            } catch  {
+                return text;
+            }
+        });
+        if (!options?.apiUrl?.trim()) {
+            throw new Error('XOXNOClient: apiUrl is required');
+        }
+        const { chain = "1", apiUrl, ...init } = options;
+        this.apiUrl = apiUrl.trim().replace(/\/$/, '');
+        this.chain = chain;
+        this.init = init;
+        this.config = chain == "1" ? {
+            mediaUrl: 'https://media.xoxno.com',
+            gatewayUrl: 'https://gateway.xoxno.com',
+            XO_SC: XOXNO_SC,
+            FM_SC: FM_SC,
+            DR_SC,
+            KG_SC,
+            Staking_SC,
+            Manager_SC,
+            P2P_SC
+        } : {
+            mediaUrl: 'https://devnet-media.xoxno.com',
+            gatewayUrl: 'https://devnet-gateway.xoxno.com',
+            XO_SC: XOXNO_SC_DEV,
+            FM_SC,
+            DR_SC,
+            KG_SC,
+            Staking_SC: Staking_SC_DEV,
+            Manager_SC: Manager_SC_DEV,
+            P2P_SC: P2P_SC_DEV
+        };
+    }
+}

package/dist/esm/utils/const.js

@@ -0,0 +1,11 @@
+export const XOXNO_SC = 'erd1qqqqqqqqqqqqqpgq6wegs2xkypfpync8mn2sa5cmpqjlvrhwz5nqgepyg8';
+export const FM_SC = 'erd1qqqqqqqqqqqqqpgq705fxpfrjne0tl3ece0rrspykq88mynn4kxs2cg43s';
+export const DR_SC = 'erd1qqqqqqqqqqqqqpgqd9rvv2n378e27jcts8vfwynpx0gfl5ufz6hqhfy0u0';
+export const KG_SC = 'erd1qqqqqqqqqqqqqpgq8xwzu82v8ex3h4ayl5lsvxqxnhecpwyvwe0sf2qj4e';
+export const Staking_SC = 'erd1qqqqqqqqqqqqqpgqvpkd3g3uwludduv3797j54qt6c888wa59w2shntt6z';
+export const Manager_SC = 'erd1qqqqqqqqqqqqqpgqg9fa0dmpn8fu3fnleeqn5zt8rl8mdqjkys5s2gtas7';
+export const P2P_SC = 'erd1qqqqqqqqqqqqqpgq47y8hnct68v6asjv6gxem6h9rumn9frzah0skhxxt6';
+export const XOXNO_SC_DEV = 'erd1qqqqqqqqqqqqqpgql0dnz6n5hpuw8cptlt00khd0nn4ja8eadsfq2xrqw4';
+export const Staking_SC_DEV = 'erd1qqqqqqqqqqqqqpgqsc5hnewwpep8qq0d7kjjzrquapuucrygah0s85zres';
+export const Manager_SC_DEV = 'erd1qqqqqqqqqqqqqpgqluclyhfsa2uw7q9cjwd8knk989hg57u8ah0slq2nlr';
+export const P2P_SC_DEV = 'erd1qqqqqqqqqqqqqpgqfja7ukpngrun78ueq583l0vd6aj4ekhrah0sa9wyrv';

package/dist/esm/utils/errors.js

@@ -0,0 +1,20 @@
+export class CollectionNotFoundError extends Error {
+    constructor(item){
+        super(`Invalid collection ticker: ${item}`);
+    }
+}
+export class AddressNotFoundError extends Error {
+    constructor(item){
+        super(`Invalid address: ${item}`);
+    }
+}
+export class NFTNotFoundError extends Error {
+    constructor(item){
+        super(`Invalid NFT identifier: ${item}`);
+    }
+}
+export class PaginatedTopError extends Error {
+    constructor(top){
+        super(`Top cannot be greater than 100, found ${top}`);
+    }
+}

package/dist/esm/utils/guards.js

@@ -0,0 +1,29 @@
+import { AddressNotFoundError, CollectionNotFoundError, NFTNotFoundError, PaginatedTopError } from "./errors.js";
+import { isValidCollectionTicker, isValidNftIdentifier } from "./regex.js";
+export function collectionGuard(collection, callback) {
+    if (!isValidCollectionTicker(collection)) {
+        throw new CollectionNotFoundError(collection);
+    }
+    return callback;
+}
+export function addressGuard(address, callback) {
+    if (!isValidCollectionTicker(address)) {
+        throw new AddressNotFoundError(address);
+    }
+    return callback;
+}
+export function nftGuard(identifier, callback) {
+    if (!isValidNftIdentifier(identifier)) {
+        throw new NFTNotFoundError(identifier);
+    }
+    return callback;
+}
+export function collectionGuardOnly(collection) {
+    return collectionGuard(collection, Promise.resolve());
+}
+export function paginatedGuard(filter, callback) {
+    if (filter.top && filter.top > 100) {
+        throw new PaginatedTopError(filter.top);
+    }
+    return callback(JSON.stringify(filter));
+}

package/dist/esm/utils/helpers.js

@@ -0,0 +1,20 @@
+export const nonceToHex = (nonce)=>{
+    let nonceHex = nonce.toString(16);
+    if (nonceHex.length % 2 !== 0) {
+        nonceHex = '0' + nonceHex;
+    }
+    return nonceHex;
+};
+export const getIdentifierFromColAndNonce = (collection, nonce)=>{
+    return [
+        collection,
+        nonceToHex(nonce)
+    ].join('-');
+};
+export const isAddressValid = (address)=>{
+    return address ? address.startsWith('erd1') && address.length === 62 || /^0x[a-fA-F0-9]{40,64}$/.test(address) || /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address) || // Stellar strkey: `G` = ed25519 account, `C` = Soroban contract.
+    // Contracts hold balances, positions and profiles just like accounts,
+    // and the route builder runs every `:address` param through here — so
+    // rejecting `C` blocked all contract-account endpoints client-side.
+    /^[GC][A-Z2-7]{55}$/.test(address) : false;
+};

package/dist/esm/utils/regex.js

@@ -0,0 +1,14 @@
+export const isValidCollectionTicker = (ticker)=>{
+    const isSuiCollection = /*  (ticker.length >= 4 && ticker.length <= 40) || */ /^0x[a-fA-F0-9]{1,64}-[a-zA-Z0-9_]+-[a-zA-Z0-9_]+(<.+>)?$/.test(decodeURIComponent(ticker));
+    const isXoxnoCollection = /^[A-Z0-9]{3,10}-[a-z0-9]{6}$/.test(ticker);
+    // Stellar: the collection IS the NFT contract (Soroban contract strkey)
+    const isStellarCollection = /^C[A-Z2-7]{55}$/.test(ticker);
+    return isSuiCollection || isXoxnoCollection || isStellarCollection;
+};
+export const isValidNftIdentifier = (identifier)=>{
+    const isSuiNft = /^0x[a-fA-F0-9]{1,64}$/.test(identifier);
+    const isXoxnoNft = /^[A-Za-z0-9]{3,10}-[A-Za-z0-9]{6}-[A-Za-z0-9]{2,7}(?:-\d+(?:-[A-Za-z0-9]+)?)?$/.test(identifier);
+    // Stellar: `{contract strkey}-{decimal token id}`
+    const isStellarNft = /^C[A-Z2-7]{55}-\d+$/.test(identifier);
+    return isSuiNft || isXoxnoNft || isStellarNft;
+};

package/dist/esm/utils/soroban-errors.js

@@ -0,0 +1,149 @@
+/**
+ * rs-lending-xlm Soroban contract error codes → human-readable messages.
+ * Mirrors `common/src/errors.rs` (`GenericError`, `CollateralError`,
+ * `SpokeError`, `OracleError`). Keep in sync when that file changes.
+ */ const SOROBAN_ERROR_CATALOG = {
+    // GenericError
+    1: {
+        name: 'AssetNotSupported',
+        message: 'This asset is not supported by the protocol.'
+    },
+    2: {
+        name: 'AssetAlreadySupported',
+        message: 'This asset is already supported.'
+    },
+    3: {
+        name: 'InvalidTicker',
+        message: 'Invalid asset ticker.'
+    },
+    6: {
+        name: 'InvalidAsset',
+        message: 'Invalid asset address.'
+    },
+    10: {
+        name: 'InvalidWasmHash',
+        message: 'The WASM hash is empty or invalid.'
+    },
+    11: {
+        name: 'InvalidExchangeSrc',
+        message: 'The oracle configuration is invalid.'
+    },
+    12: {
+        name: 'PairNotActive',
+        message: 'No oracle is configured for this asset.'
+    },
+    14: {
+        name: 'AmountMustBePositive',
+        message: 'The amount must be greater than zero.'
+    },
+    32: {
+        name: 'OwnerNotSet',
+        message: 'The contract owner has not been set.'
+    },
+    39: {
+        name: 'InvalidTimelockDelay',
+        message: 'The timelock delay is out of the allowed range.'
+    },
+    41: {
+        name: 'InvalidRole',
+        message: 'The caller does not hold the required role.'
+    },
+    43: {
+        name: 'HubNotActive',
+        message: 'This hub is not active.'
+    },
+    44: {
+        name: 'NotAuthorized',
+        message: 'The caller is not authorized to perform this action.'
+    },
+    46: {
+        name: 'OperationNotCancellable',
+        message: 'This governance operation cannot be cancelled.'
+    },
+    // CollateralError
+    113: {
+        name: 'InvalidLiqThreshold',
+        message: 'LTV, liquidation threshold, or bonus is out of bounds.'
+    },
+    116: {
+        name: 'InvalidBorrowParams',
+        message: 'Supply or borrow cap configuration is invalid.'
+    },
+    117: {
+        name: 'InvalidUtilRange',
+        message: 'Interest-rate utilization breakpoints are invalid.'
+    },
+    132: {
+        name: 'AssetDecimalsTooHigh',
+        message: 'Asset decimals exceed the protocol maximum (27).'
+    },
+    // SpokeError
+    300: {
+        name: 'SpokeNotFound',
+        message: 'This spoke does not exist.'
+    },
+    301: {
+        name: 'SpokeDeprecated',
+        message: 'This spoke has been deprecated.'
+    },
+    307: {
+        name: 'AssetNotInSpoke',
+        message: 'This asset is not listed on the spoke.'
+    },
+    308: {
+        name: 'AssetAlreadyInSpoke',
+        message: 'This asset is already listed in the spoke.'
+    },
+    309: {
+        name: 'SpokeAssetInUse',
+        message: 'This spoke asset still has live positions; drain usage before removal.'
+    },
+    315: {
+        name: 'SpokeAssetPaused',
+        message: 'This spoke asset is paused.'
+    },
+    316: {
+        name: 'SpokeAssetFrozen',
+        message: 'This spoke asset is frozen.'
+    },
+    317: {
+        name: 'SpokeAssetFlagRelaxation',
+        message: 'Guardian flag updates may only tighten; clearing a flag requires the timelocked edit.'
+    },
+    318: {
+        name: 'SpokeAssetSeizureHalted',
+        message: 'Liquidation seizure is halted for this spoke asset.'
+    },
+    // OracleError
+    220: {
+        name: 'InvalidOracleBase',
+        message: 'The oracle quote asset/market is missing or invalid.'
+    },
+    221: {
+        name: 'InvalidOracleDecimals',
+        message: 'The oracle decimals value is invalid.'
+    },
+    224: {
+        name: 'InvalidSanityBounds',
+        message: 'Oracle sanity bounds are invalid (require 0 < min < max).'
+    },
+    225: {
+        name: 'OracleCycleDetected',
+        message: 'A cycle was detected in the oracle quote chain.'
+    }
+};
+/**
+ * Extracts a `Error(Contract, #N)` code from a raw Soroban simulation/RPC error
+ * string and resolves it against the rs-lending-xlm catalog. Matches only the
+ * exact `Error(Contract, #N)` pattern — never loose digits, since raw error
+ * strings can contain unrelated numbers (fees, ledgers, sequence numbers).
+ */ export function mapSorobanError(raw) {
+    const match = raw.match(/Error\(Contract,\s*#(\d+)\)/);
+    if (!match) return null;
+    const code = Number(match[1]);
+    const entry = SOROBAN_ERROR_CATALOG[code];
+    return entry ? {
+        code,
+        ...entry
+    } : null;
+}