@xoxno/sdk-js 1.0.224 → 1.0.225

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, {});
+}

package/dist/esm/sdk/stellar/admin.js

@@ -0,0 +1,385 @@
+/**
+ * Stellar lending admin / config / keeper / access transaction builders. Each
+ * builder returns an unsigned `BuiltStellarTx` XDR.
+ *
+ * Auth model:
+ *   - `#[only_owner]` methods take no `caller` param — the tx source
+ *     (`opts.caller`) must be the contract owner.
+ *   - `#[only_role(caller, "ROLE")]` and caller-taking methods encode
+ *     `opts.caller` as the leading `Address` arg; that account must hold the
+ *     role and sign the tx.
+ */ import { addr, bool, bytesN, hubAsset, i128, scStruct, str, sym, tupleHubAssetAmountVec, u32, u64, vec } from "./scval-encode.js";
+import { buildTx } from "./lending.js";
+// -----------------------------------------------------------------------------
+// Complex struct / union encoders
+// -----------------------------------------------------------------------------
+/** `InterestRateModel` — 8 RAY rates + reserve factor bps. */ export const encodeInterestRateModel = (m)=>scStruct({
+        base_borrow_rate: i128(m.baseBorrowRateRay),
+        max_borrow_rate: i128(m.maxBorrowRateRay),
+        max_utilization: i128(m.maxUtilizationRay),
+        mid_utilization: i128(m.midUtilizationRay),
+        optimal_utilization: i128(m.optimalUtilizationRay),
+        reserve_factor: u32(m.reserveFactorBps),
+        slope1: i128(m.slope1Ray),
+        slope2: i128(m.slope2Ray),
+        slope3: i128(m.slope3Ray)
+    });
+/** `MarketParamsRaw` — `InterestRateModel` plus the pool asset identity. */ export const encodeMarketParamsRaw = (p)=>scStruct({
+        asset_decimals: u32(p.assetDecimals),
+        asset_id: addr(p.assetId),
+        base_borrow_rate: i128(p.baseBorrowRateRay),
+        flashloan_fee: u32(p.flashloanFeeBps),
+        is_flashloanable: bool(p.isFlashloanable),
+        max_borrow_rate: i128(p.maxBorrowRateRay),
+        max_utilization: i128(p.maxUtilizationRay),
+        mid_utilization: i128(p.midUtilizationRay),
+        optimal_utilization: i128(p.optimalUtilizationRay),
+        reserve_factor: u32(p.reserveFactorBps),
+        slope1: i128(p.slope1Ray),
+        slope2: i128(p.slope2Ray),
+        slope3: i128(p.slope3Ray)
+    });
+/** `PositionLimits` — per-account supply/borrow position caps. */ export const encodePositionLimits = (l)=>scStruct({
+        max_borrow_positions: u32(l.maxBorrowPositions),
+        max_supply_positions: u32(l.maxSupplyPositions)
+    });
+/** On-chain `PriceKey` — `{ Token: "C…" }` or `{ Ref: "BTC" }`. */ export const encodePriceKey = (key)=>{
+    if ('Token' in key && key.Token) return vec([
+        sym('Token'),
+        addr(key.Token)
+    ]);
+    if ('Ref' in key && key.Ref) return vec([
+        sym('Ref'),
+        sym(key.Ref)
+    ]);
+    throw new Error(`Stellar builder: PriceKey must be { Token } or { Ref }, got ${JSON.stringify(key)}`);
+};
+const encodeOracleAssetRef = (asset)=>{
+    if ('Stellar' in asset) return vec([
+        sym('Stellar'),
+        addr(asset.Stellar)
+    ]);
+    if ('Symbol' in asset) return vec([
+        sym('Symbol'),
+        sym(asset.Symbol)
+    ]);
+    if ('String' in asset) return vec([
+        sym('String'),
+        str(asset.String)
+    ]);
+    throw new Error(`Stellar builder: unknown OracleAssetRef ${JSON.stringify(asset)}`);
+};
+const encodeOracleReadMode = (mode)=>{
+    if (mode === 'Spot') return vec([
+        sym('Spot')
+    ]);
+    if (mode && typeof mode === 'object' && 'Twap' in mode) {
+        return vec([
+            sym('Twap'),
+            u32(Number(mode.Twap))
+        ]);
+    }
+    throw new Error(`Stellar builder: unknown OracleReadMode ${JSON.stringify(mode)}`);
+};
+const encodeProviderKind = (kind)=>{
+    if (kind === 'Reflector' || kind === 'RedStone' || kind === 'Xoxno') {
+        return vec([
+            sym(kind)
+        ]);
+    }
+    throw new Error(`Stellar builder: unknown ProviderKind "${kind}"`);
+};
+const encodeFeedNature = (nature)=>{
+    if (nature === 'Market' || nature === 'Fundamental') return vec([
+        sym(nature)
+    ]);
+    throw new Error(`Stellar builder: unknown FeedNature "${nature}"`);
+};
+const encodeProviderRef = (provider)=>{
+    if ('Reflector' in provider) {
+        const r = provider.Reflector;
+        return vec([
+            sym('Reflector'),
+            scStruct({
+                asset: encodeOracleAssetRef(r.asset),
+                contract: addr(r.contract),
+                read_mode: encodeOracleReadMode(r.readMode)
+            })
+        ]);
+    }
+    if ('MultiFeed' in provider) {
+        const m = provider.MultiFeed;
+        return vec([
+            sym('MultiFeed'),
+            scStruct({
+                contract: addr(m.contract),
+                feed_id: str(m.feedId),
+                kind: encodeProviderKind(m.kind),
+                nature: encodeFeedNature(m.nature)
+            })
+        ]);
+    }
+    throw new Error(`Stellar builder: unknown ProviderRef ${JSON.stringify(provider)}`);
+};
+const encodeFeedSource = (feed)=>{
+    const f = feed;
+    return scStruct({
+        decimals: u32(f.decimals),
+        max_stale_seconds: u64(f.maxStaleSeconds),
+        provider: encodeProviderRef(f.provider)
+    });
+};
+const encodePriceSource = (source)=>{
+    if ('Feed' in source) {
+        return vec([
+            sym('Feed'),
+            encodeFeedSource(source.Feed)
+        ]);
+    }
+    if ('Scaled' in source) {
+        const s = source.Scaled;
+        return vec([
+            sym('Scaled'),
+            scStruct({
+                factor: encodeFeedSource(s.factor),
+                max_factor_wad: i128(s.maxFactorWad),
+                min_factor_wad: i128(s.minFactorWad),
+                quote: encodePriceKey(s.quote)
+            })
+        ]);
+    }
+    if ('LpShare' in source) {
+        const s = source.LpShare;
+        return vec([
+            sym('LpShare'),
+            scStruct({
+                key_a: encodePriceKey(s.keyA),
+                key_b: encodePriceKey(s.keyB),
+                kind: vec([
+                    sym(s.kind || 'ConstantProduct')
+                ]),
+                pool: addr(s.pool),
+                reserve_a_decimals: u32(s.reserveADecimals),
+                reserve_b_decimals: u32(s.reserveBDecimals),
+                share_decimals: u32(s.shareDecimals)
+            })
+        ]);
+    }
+    throw new Error(`Stellar builder: unknown PriceSource ${JSON.stringify(source)}`);
+};
+const encodeIndependence = (policy)=>{
+    if (policy === 'RequireDisjoint') return vec([
+        sym('RequireDisjoint')
+    ]);
+    if (policy && typeof policy === 'object' && 'AllowShared' in policy) {
+        const domains = policy.AllowShared;
+        return vec([
+            sym('AllowShared'),
+            vec(domains.map((d)=>scStruct({
+                    contract: addr(d.contract),
+                    kind: encodeProviderKind(d.kind)
+                })))
+        ]);
+    }
+    throw new Error(`Stellar builder: unknown IndependencePolicy ${JSON.stringify(policy)}`);
+};
+/**
+ * Encode on-chain `AssetOracle`. Accepts either the swagger DTO
+ * (`toleranceBps` + sources) or a full `StellarAssetOracle` with tolerance
+ * upper/lower bps (lower is derived as reciprocal when only bps is given).
+ */ export const encodeAssetOracle = (cfg)=>{
+    const c = cfg;
+    const sources = c.sources ?? [];
+    let upper;
+    let lower;
+    if (typeof c.toleranceBps === 'number') {
+        upper = 10000 + c.toleranceBps;
+        // reciprocal lower ≈ floor(1e8 / upper) style half-up is on-chain; SDK uses
+        // symmetric inverse for proposal input (governance may re-derive via view).
+        lower = Math.max(1, Math.floor(10000 * 10000 / upper));
+    } else {
+        const tol = c.tolerance ?? {};
+        upper = Number(tol.upperRatioBps);
+        lower = Number(tol.lowerRatioBps);
+    }
+    return scStruct({
+        asset_decimals: u32(Number(c.assetDecimals)),
+        independence: encodeIndependence(c.independence),
+        max_price_stale_seconds: u64(Number(c.maxPriceStaleSeconds)),
+        max_sanity_price_wad: i128(String(c.maxSanityPriceWad)),
+        min_sanity_price_wad: i128(String(c.minSanityPriceWad)),
+        sources: vec(sources.map((s)=>encodePriceSource(s))),
+        tolerance: scStruct({
+            lower_ratio_bps: u32(lower),
+            upper_ratio_bps: u32(upper)
+        })
+    });
+};
+// -----------------------------------------------------------------------------
+// Access control (access.rs) — #[only_owner] unless noted
+// -----------------------------------------------------------------------------
+/** upgrade(new_wasm_hash: BytesN<32>) */ export function buildStellarUpgradeControllerTx(opts, args) {
+    return buildTx(opts, 'upgrade', [
+        bytesN(args.wasmHash)
+    ]);
+}
+/** migrate(new_version: u32) */ export function buildStellarMigrateTx(opts, args) {
+    return buildTx(opts, 'migrate', [
+        u32(args.newVersion)
+    ]);
+}
+/** pause() */ export function buildStellarPauseTx(opts) {
+    return buildTx(opts, 'pause', []);
+}
+/** unpause() */ export function buildStellarUnpauseTx(opts) {
+    return buildTx(opts, 'unpause', []);
+}
+/** grant_role(account: Address, role: Symbol) */ export function buildStellarGrantRoleTx(opts, args) {
+    return buildTx(opts, 'grant_role', [
+        addr(args.account),
+        sym(args.role)
+    ]);
+}
+/** revoke_role(account: Address, role: Symbol) */ export function buildStellarRevokeRoleTx(opts, args) {
+    return buildTx(opts, 'revoke_role', [
+        addr(args.account),
+        sym(args.role)
+    ]);
+}
+/** transfer_ownership(new_owner: Address, live_until_ledger: u32) */ export function buildStellarTransferOwnershipTx(opts, args) {
+    return buildTx(opts, 'transfer_ownership', [
+        addr(args.newOwner),
+        u32(args.liveUntilLedger)
+    ]);
+}
+/** accept_ownership() */ export function buildStellarAcceptOwnershipTx(opts) {
+    return buildTx(opts, 'accept_ownership', []);
+}
+// -----------------------------------------------------------------------------
+// Config (config.rs)
+// -----------------------------------------------------------------------------
+/** set_swap_aggregator(addr: Address) — #[only_owner] */ export function buildStellarSetSwapAggregatorTx(opts, args) {
+    return buildTx(opts, 'set_swap_aggregator', [
+        addr(args.aggregator)
+    ]);
+}
+/** set_price_aggregator(addr: Address) — #[only_owner] */ export function buildStellarSetPriceAggregatorTx(opts, args) {
+    return buildTx(opts, 'set_price_aggregator', [
+        addr(args.aggregator)
+    ]);
+}
+/** set_accumulator(addr: Address) — #[only_owner] */ export function buildStellarSetAccumulatorTx(opts, args) {
+    return buildTx(opts, 'set_accumulator', [
+        addr(args.accumulator)
+    ]);
+}
+/** set_position_limits(limits: PositionLimits) — #[only_owner] */ export function buildStellarSetPositionLimitsTx(opts, args) {
+    return buildTx(opts, 'set_position_limits', [
+        encodePositionLimits(args)
+    ]);
+}
+/** approve_blend_pool(pool: Address) — #[only_owner] */ export function buildStellarApproveBlendPoolTx(opts, args) {
+    return buildTx(opts, 'approve_blend_pool', [
+        addr(args.pool)
+    ]);
+}
+/** revoke_blend_pool(pool: Address) — #[only_owner] */ export function buildStellarRevokeBlendPoolTx(opts, args) {
+    return buildTx(opts, 'revoke_blend_pool', [
+        addr(args.pool)
+    ]);
+}
+/**
+ * Direct price-aggregator `set_oracle(key, oracle)` — owner only (governance
+ * contract address as tx source after deploy). Prefer governance propose path
+ * in production.
+ */ export function buildStellarSetOracleTx(opts, args) {
+    return buildTx(opts, 'set_oracle', [
+        encodePriceKey(args.key),
+        encodeAssetOracle(args.oracle)
+    ]);
+}
+/** price-aggregator `set_tolerance(key, OracleTolerance)` — owner only. */ export function buildStellarSetOracleToleranceTx(opts, args) {
+    const bps = args.toleranceBps;
+    const upper = args.upperRatioBps ?? 10000 + bps;
+    const lower = args.lowerRatioBps ?? Math.max(1, Math.floor(10000 * 10000 / upper));
+    return buildTx(opts, 'set_tolerance', [
+        encodePriceKey(args.key),
+        scStruct({
+            lower_ratio_bps: u32(lower),
+            upper_ratio_bps: u32(upper)
+        })
+    ]);
+}
+/**
+ * set_spoke_asset_flags(spoke_id, hub_asset, paused, frozen, no_seize) —
+ * #[only_owner]. Flags-only listing edit; production callers route through the
+ * GUARDIAN-gated governance forwarder
+ * (`buildStellarGovernanceSetSpokeAssetFlagsImmediateTx`). Every flag is a
+ * one-way ratchet here: clearing one requires the timelocked spoke-asset edit.
+ */ export function buildStellarSetSpokeAssetFlagsTx(opts, args) {
+    return buildTx(opts, 'set_spoke_asset_flags', [
+        u32(args.spokeId),
+        hubAsset(args.hubId, args.asset),
+        bool(args.paused),
+        bool(args.frozen),
+        bool(args.noSeize)
+    ]);
+}
+/**
+ * set_oracle_sanity_bounds(asset, min_wad, max_wad) — #[only_owner].
+ * Band-only oracle edit; production callers route through the ORACLE-gated
+ * governance forwarder (`buildStellarGovernanceSetOracleSanityBoundsImmediateTx`).
+ */ export function buildStellarSetOracleSanityBoundsTx(opts, args) {
+    return buildTx(opts, 'set_oracle_sanity_bounds', [
+        addr(args.asset),
+        i128(args.minPriceWad),
+        i128(args.maxPriceWad)
+    ]);
+}
+// -----------------------------------------------------------------------------
+// Router (router.rs)
+// -----------------------------------------------------------------------------
+/** update_indexes(caller, assets: Vec<HubAssetKey>) */ export function buildStellarUpdateIndexesTx(opts, args) {
+    return buildTx(opts, 'update_indexes', [
+        addr(opts.caller),
+        vec(args.assets.map((a)=>hubAsset(a.hubId, a.asset)))
+    ]);
+}
+/** renew_account(caller, account_id: u64) */ export function buildStellarRenewAccountTx(opts, args) {
+    return buildTx(opts, 'renew_account', [
+        addr(opts.caller),
+        u64(args.accountNonce)
+    ]);
+}
+/** create_liquidity_pool(hub_id, asset, params: MarketParamsRaw) -> Address — #[only_owner] */ export function buildStellarCreateLiquidityPoolTx(opts, args) {
+    return buildTx(opts, 'create_liquidity_pool', [
+        u32(args.hubId),
+        addr(args.asset),
+        encodeMarketParamsRaw(args.params)
+    ]);
+}
+/** upgrade_liquidity_pool_params(hub_asset: HubAssetKey, params) — #[only_owner] */ export function buildStellarUpgradeLiquidityPoolParamsTx(opts, args) {
+    return buildTx(opts, 'upgrade_liquidity_pool_params', [
+        hubAsset(args.hubId, args.asset),
+        encodeInterestRateModel(args.params)
+    ]);
+}
+/** claim_revenue(caller, assets: Vec<HubAssetKey>) -> Vec<i128> */ export function buildStellarClaimRevenueTx(opts, args) {
+    return buildTx(opts, 'claim_revenue', [
+        addr(opts.caller),
+        vec(args.assets.map((a)=>hubAsset(a.hubId, a.asset)))
+    ]);
+}
+/** add_rewards(caller, rewards: Vec<(HubAssetKey, i128)>) */ export function buildStellarAddRewardsTx(opts, args) {
+    return buildTx(opts, 'add_rewards', [
+        addr(opts.caller),
+        tupleHubAssetAmountVec(args.rewards)
+    ]);
+}
+/** update_account_threshold(caller, asset, has_risks, account_ids: Vec<u64>) — #[only_role(caller, "KEEPER")] */ export function buildStellarUpdateAccountThresholdTx(opts, args) {
+    return buildTx(opts, 'update_account_threshold', [
+        addr(opts.caller),
+        bool(args.hasRisks),
+        vec(args.accountNonces.map((n)=>u64(n)))
+    ]);
+}