perp-cli 0.12.17 → 0.14.1

package/dist/exchanges/venue.d.ts

@@ -0,0 +1,211 @@
+/**
+ * Venue definitions — the single source of truth for "which venue, on which
+ * network, signed how, funded how, supporting what".
+ *
+ * See docs/DESIGN-venue-abstraction.md §10. One adapter class may serve several
+ * venues (LighterAdapter serves `lighter` and `lighter-rh`).
+ *
+ * Venue definition modules must load adapter code lazily (`import()` inside
+ * `create`) so that public-data paths never pull in heavy SDKs (lighter WASM).
+ */
+import type { ExchangeAdapter } from "./interface.js";
+import type { SpotAdapter } from "./spot-interface.js";
+import type { FundingRateBasis, LegacyVenueId, Network, TimeInForce, VenueFundingRate, VenueId, VenueMarket } from "./venue-types.js";
+import { isVenueId } from "./venue-types.js";
+import type { AnyAgentMeta } from "../settings.js";
+import type { BuilderFeeCapability } from "./builder-fee.js";
+export type { VenueId, LegacyVenueId, Network, FundingRateBasis, VenueMarket, VenueFundingRate, } from "./venue-types.js";
+/** Kind of the user's master (owner) key. Replaces the overloaded legacy `chain` field. */
+export type MasterKeyKind = "evm" | "solana" | "none";
+/** Kind of the delegated hot-path key. */
+export type AgentKeyKind = "evm" | "solana" | "lighter-l2" | "ed25519" | "hmac" | "none";
+export interface SecretStorage {
+    /** ows-wallet: OWS vault wallet; perp-keystore: ~/.perp/<dir>/ AES-256-GCM files (SSOT Rule #3). */
+    kind: "ows-wallet" | "perp-keystore" | "none";
+    /** Directory name under ~/.perp/ for perp-keystore, e.g. "lighter-rh-agents". */
+    dir: string | null;
+}
+export interface VenueNetworkConfig {
+    restUrl: string;
+    wsUrl: string | null;
+    explorerUrl: string | null;
+    /** Chain id mixed into signatures (Lighter 304 / RH 466324 / Arcus 4663). */
+    signingChainId: number | null;
+    /** Where the funds live: "ethereum" | "robinhood" | "arbitrum" | "solana" | "bnb" | "hyperliquid" | "offchain". */
+    settlementChain: string;
+    collateral: string[];
+    /** Lighter-family collateral asset index (USDC on Lighter, USDG on RH — both 3). */
+    collateralAssetIndex: number | null;
+    /** EVM JSON-RPC for on-chain reads/txs (Arcus spot on Robinhood Chain). null = not needed by this venue. */
+    rpcUrl: string | null;
+    /**
+     * Pinned L1 deposit identifiers (chain id, deposit contract, collateral token) verified
+     * against official docs. A deposit refuses (EXCHANGE_ERROR) when the venue API disagrees.
+     * null = the CLI has no pinned contract deposit for this venue/network.
+     */
+    depositPins: VenueDepositPins | null;
+}
+export interface VenueDepositPins {
+    chainId: number;
+    contract: string;
+    token: string;
+    /** Where the pinned values were verified (for audits / re-verification). */
+    sources: readonly string[];
+}
+export type MarketOrderMode = "native" | "slippageBounded" | "rfq";
+export type TpSlMode = "attached" | "separateOrders" | "batchGroup" | "positionLevel";
+export interface VenueCapabilities {
+    marketOrder: MarketOrderMode;
+    timeInForce: readonly TimeInForce[];
+    /**
+     * Time-in-force values a reduce-only LIMIT order may carry; null = any offered TIF.
+     * Ondo: ["IOC"] — a resting reduce-only order is refused by the venue.
+     */
+    reduceOnlyTif: readonly TimeInForce[] | null;
+    clientOrderId: boolean;
+    orderAck: "sync" | "async";
+    tpsl: TpSlMode | null;
+    amend: "native" | "cancelReplace" | null;
+    batchPlaceMax: number | null;
+    marginModes: ReadonlyArray<"cross" | "isolated">;
+    withdrawAssets: string[] | null;
+}
+export type SpotAccountModel = "unified" | "separate" | "runtime" | "wallet";
+/** Per-process spot adapter options (CLI flags). */
+export interface SpotCreateOptions {
+    /** Allow on-chain approve txs (Arcus Permit2 approve; CLI --yes). */
+    confirmOnchainApprove: boolean;
+}
+export interface VenueSpotDefinition {
+    accountModel: SpotAccountModel;
+    /**
+     * Quote assets per network; [0] is the default quote for a bare base symbol and the transfer
+     * asset. Network-keyed because a venue's collateral can differ by network (Lighter RH: USDG on
+     * mainnet, USDC on testnet — networks.<net>.collateral). Read through spotQuoteAssets(def, net).
+     */
+    quoteAssets: Readonly<Record<Network, readonly string[]>>;
+    capabilities: {
+        limitOrder: boolean;
+        orderbook: boolean;
+        cancel: boolean;
+        transfer: boolean;
+    };
+    /** Creates and init()s the spot adapter around an already-created perp adapter (lazy import). */
+    createSpot(perp: ExchangeAdapter, opts: SpotCreateOptions): Promise<SpotAdapter>;
+}
+export interface RateLimitPolicy {
+    /** Bucket capacity (weight units). */
+    capacity: number;
+    /** Refill rate (weight units per second). */
+    refillPerSec: number;
+    /** Per-endpoint weights; endpoints not listed cost 1. null = uniform weight 1. */
+    weights: Record<string, number> | null;
+}
+export interface VenuePublicData {
+    fetchFundingRates(net: Network): Promise<VenueFundingRate[]>;
+    fetchMarkets(net: Network): Promise<VenueMarket[]>;
+}
+export interface VenueCredentials {
+    /** Raw private key from --private-key or (legacy venues only) env. */
+    pk: string | null;
+    owsWallet: string | null;
+    owsPassphrase: string | null;
+    owsKeyToken: string | null;
+    agent: AnyAgentMeta | null;
+}
+export interface VenueCreateContext {
+    network: Network;
+    credentials: VenueCredentials;
+    noAgent: boolean;
+    /** Hyperliquid HIP-3 dex; null for all other venues. */
+    hlDex: string | null;
+    /** true → public reads only; credentials are ignored. */
+    readOnly: boolean;
+    /** --no-builder: never attach a configured builder fee on this adapter's orders. */
+    noBuilder: boolean;
+}
+export declare const READ_ONLY_CREDENTIALS: VenueCredentials;
+export type VenueRole = "marketData" | "account" | "trading";
+export type SymbolIdentity = "baseTicker" | "explicit";
+export interface VenueDefinition {
+    id: VenueId;
+    aliases: readonly string[];
+    displayName: string;
+    family: "pacifica" | "hyperliquid" | "lighter" | "aster" | "ondo" | "arcus" | "qfex";
+    masterKeyKind: MasterKeyKind;
+    agentKeyKind: AgentKeyKind;
+    secretStorage: SecretStorage;
+    networks: {
+        mainnet: VenueNetworkConfig;
+        testnet: VenueNetworkConfig | null;
+    };
+    fundingRateBasis: FundingRateBasis | "perMarket";
+    settlementIntervalHours: number | "perMarket";
+    /**
+     * false = the unit / meaning of the venue's published funding rate is not verified against
+     * settled funding payments yet (design §14.12 #6). Such a venue is left out of cross-venue
+     * funding comparison (fetchVenuesRates drops it unless includeUnverified is passed), its
+     * adapter reports fundingRate null to bots, and funding-arb strategies refuse it as a leg.
+     */
+    fundingVerified: boolean;
+    roles: readonly VenueRole[];
+    /** null when the venue has no trading role. */
+    capabilities: VenueCapabilities | null;
+    rateLimit: RateLimitPolicy;
+    /** ISO-3166 alpha-2 codes; shown as a warning, never enforced. */
+    restrictedRegions: readonly string[];
+    /** How cross-venue canonical symbols are derived for crypto markets (equity is always explicit). */
+    symbolIdentity: SymbolIdentity;
+    publicData: VenuePublicData;
+    /** null when the venue cannot produce an adapter (public data only). */
+    create: ((ctx: VenueCreateContext) => Promise<ExchangeAdapter>) | null;
+    /** null = venue has no spot trading (§12). */
+    spot: VenueSpotDefinition | null;
+    /**
+     * Largest slippage bound (bps) a market-type order may carry on this venue
+     * (design §13.10 #1). resolveSlippage() rejects anything above it with
+     * INVALID_PARAMS before sending — never clamps.
+     */
+    maxSlippageBps: number;
+    /**
+     * Builder-fee support (src/exchanges/builder-fee.ts BUILDER_FEE_CAPABILITIES — the single
+     * source); null = unsupported (CAPABILITY_UNSUPPORTED). Attached only when the user set
+     * settings.builder.<venue> and the approval is confirmed.
+     */
+    builderFee: BuilderFeeCapability | null;
+}
+export declare function registerVenue(def: VenueDefinition): void;
+/** Resolve a venue id or alias. Throws UNKNOWN_VENUE. */
+export declare function resolveVenueId(nameOrAlias: string): VenueId;
+export declare function tryResolveVenueId(nameOrAlias: string): VenueId | null;
+export declare function getVenue(nameOrAlias: string): VenueDefinition;
+export declare function listVenues(): VenueDefinition[];
+export declare function listVenuesWithRole(role: VenueRole): VenueDefinition[];
+export declare function networkConfig(def: VenueDefinition, net: Network): VenueNetworkConfig;
+export declare function requireCapabilities(def: VenueDefinition): VenueCapabilities;
+/**
+ * A venue reference as it appears in stored data and funding keys:
+ * a venue id/alias, or "hl:<dex>" / "hyperliquid:<dex>" for HIP-3 dexes.
+ */
+export interface VenueRef {
+    venue: VenueId;
+    hlDex: string | null;
+}
+export declare function parseVenueRef(ref: string): VenueRef;
+/**
+ * Funding basis for a venue ref. HIP-3 dexes use the Hyperliquid core basis
+ * (current behavior preserved; see design §10.1 — verify against live data).
+ * Throws for venues whose basis is per-market; callers must use the market's value.
+ */
+export declare function fundingBasisOf(ref: string): FundingRateBasis;
+export declare function settlementIntervalOf(ref: string): number;
+/**
+ * Refuse a venue whose funding rate is unverified (VenueDefinition.fundingVerified false) as a
+ * leg of a funding strategy (arb scan ranking, arb exec / auto, funding bots). Uniform
+ * CAPABILITY_UNSUPPORTED (design §13.6, §14.12 #6). Unknown venue refs throw UNKNOWN_VENUE.
+ */
+export declare function assertFundingArbVenue(ref: string): void;
+export declare function isLegacyVenue(def: VenueDefinition): def is VenueDefinition & {
+    id: LegacyVenueId;
+};
+export { isVenueId };

package/dist/exchanges/venue.js

@@ -0,0 +1,132 @@
+/**
+ * Venue definitions — the single source of truth for "which venue, on which
+ * network, signed how, funded how, supporting what".
+ *
+ * See docs/DESIGN-venue-abstraction.md §10. One adapter class may serve several
+ * venues (LighterAdapter serves `lighter` and `lighter-rh`).
+ *
+ * Venue definition modules must load adapter code lazily (`import()` inside
+ * `create`) so that public-data paths never pull in heavy SDKs (lighter WASM).
+ */
+import { PerpError } from "../errors.js";
+import { isVenueId } from "./venue-types.js";
+export const READ_ONLY_CREDENTIALS = {
+    pk: null, owsWallet: null, owsPassphrase: null, owsKeyToken: null, agent: null,
+};
+// ── Registry ──
+const _venues = new Map();
+const _aliases = new Map();
+export function registerVenue(def) {
+    if (_venues.has(def.id))
+        throw new Error(`venue already registered: ${def.id}`);
+    _venues.set(def.id, def);
+    _aliases.set(def.id, def.id);
+    for (const a of def.aliases) {
+        const prev = _aliases.get(a);
+        if (prev && prev !== def.id)
+            throw new Error(`venue alias "${a}" already used by ${prev}`);
+        _aliases.set(a, def.id);
+    }
+}
+function unknownVenue(input) {
+    return new PerpError("UNKNOWN_VENUE", `Unknown venue: "${input}"`, {
+        remediation: `Use one of: ${[..._venues.keys()].join(", ")}`,
+    });
+}
+/** Resolve a venue id or alias. Throws UNKNOWN_VENUE. */
+export function resolveVenueId(nameOrAlias) {
+    const id = _aliases.get(nameOrAlias.toLowerCase());
+    if (!id)
+        throw unknownVenue(nameOrAlias);
+    return id;
+}
+export function tryResolveVenueId(nameOrAlias) {
+    return _aliases.get(nameOrAlias.toLowerCase()) ?? null;
+}
+export function getVenue(nameOrAlias) {
+    const id = resolveVenueId(nameOrAlias);
+    const def = _venues.get(id);
+    if (!def)
+        throw unknownVenue(nameOrAlias);
+    return def;
+}
+export function listVenues() {
+    return [..._venues.values()];
+}
+export function listVenuesWithRole(role) {
+    return listVenues().filter(v => v.roles.includes(role));
+}
+export function networkConfig(def, net) {
+    const cfg = def.networks[net];
+    if (!cfg) {
+        throw new PerpError("NOT_IMPLEMENTED", `${def.displayName} has no ${net} environment`, {
+            remediation: `Run without --testnet for ${def.id}`,
+        });
+    }
+    return cfg;
+}
+export function requireCapabilities(def) {
+    if (!def.capabilities) {
+        throw new PerpError("NOT_IMPLEMENTED", `${def.displayName} does not support trading via API`, {
+            remediation: `${def.id} is available for market data only (funding/market commands)`,
+        });
+    }
+    return def.capabilities;
+}
+export function parseVenueRef(ref) {
+    const lower = ref.toLowerCase();
+    const colon = lower.indexOf(":");
+    if (colon > 0) {
+        const head = lower.slice(0, colon);
+        const dex = lower.slice(colon + 1);
+        const venue = resolveVenueId(head);
+        if (venue !== "hyperliquid" || dex.length === 0)
+            throw unknownVenue(ref);
+        return { venue, hlDex: dex };
+    }
+    return { venue: resolveVenueId(lower), hlDex: null };
+}
+/**
+ * Funding basis for a venue ref. HIP-3 dexes use the Hyperliquid core basis
+ * (current behavior preserved; see design §10.1 — verify against live data).
+ * Throws for venues whose basis is per-market; callers must use the market's value.
+ */
+export function fundingBasisOf(ref) {
+    const { venue } = parseVenueRef(ref);
+    const def = getVenue(venue);
+    if (def.fundingRateBasis === "perMarket") {
+        throw new PerpError("INVALID_PARAMS", `${def.displayName} funding basis is per-market`, {
+            remediation: "Use the market's fundingRateBasis (VenueMarket.fundingRateBasis)",
+        });
+    }
+    return def.fundingRateBasis;
+}
+export function settlementIntervalOf(ref) {
+    const { venue } = parseVenueRef(ref);
+    const def = getVenue(venue);
+    if (def.settlementIntervalHours === "perMarket") {
+        throw new PerpError("INVALID_PARAMS", `${def.displayName} settlement interval is per-market`, {
+            remediation: "Use the market's settlementIntervalHours (VenueMarket.settlementIntervalHours)",
+        });
+    }
+    return def.settlementIntervalHours;
+}
+/**
+ * Refuse a venue whose funding rate is unverified (VenueDefinition.fundingVerified false) as a
+ * leg of a funding strategy (arb scan ranking, arb exec / auto, funding bots). Uniform
+ * CAPABILITY_UNSUPPORTED (design §13.6, §14.12 #6). Unknown venue refs throw UNKNOWN_VENUE.
+ */
+export function assertFundingArbVenue(ref) {
+    const def = getVenue(parseVenueRef(ref).venue);
+    if (def.fundingVerified)
+        return;
+    const reason = "its funding rate is unverified (the unit and which published rate settles are not confirmed against funding payments, and annualizing it overstates venues whose funding accrues only part of the week)";
+    throw new PerpError("CAPABILITY_UNSUPPORTED", `${def.id} does not support fundingArb — ${reason}`, {
+        venue: def.id, feature: "fundingArb", reason,
+        remediation: `Use venues with verified funding (${listVenues().filter(v => v.fundingVerified && v.roles.includes("trading")).map(v => v.id).join(", ")}). ${def.displayName} rates can still be viewed: perp arb scan --rates --include-unverified`,
+    });
+}
+export function isLegacyVenue(def) {
+    return def.id === "pacifica" || def.id === "hyperliquid" || def.id === "lighter" || def.id === "aster";
+}
+export { isVenueId };

package/dist/exchanges/venues/arcus.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Arcus — perps on the Robinhood chain rootchain, USDG collateral
+ * (design §4 Arcus column, §10.4, §10.10).
+ * Not registered here; the registry module owns registerVenue().
+ * Adapter and public-data code are loaded lazily (§10.10).
+ */
+import type { VenueDefinition } from "../venue.js";
+export declare const arcusVenue: VenueDefinition;

package/dist/exchanges/venues/arcus.js

@@ -0,0 +1,109 @@
+/**
+ * Arcus — perps on the Robinhood chain rootchain, USDG collateral
+ * (design §4 Arcus column, §10.4, §10.10).
+ * Not registered here; the registry module owns registerVenue().
+ * Adapter and public-data code are loaded lazily (§10.10).
+ */
+import { BUILDER_FEE_CAPABILITIES } from "../builder-fee.js";
+const publicData = {
+    async fetchFundingRates(net) {
+        return (await import("../arcus/public.js")).arcusPublicData.fetchFundingRates(net);
+    },
+    async fetchMarkets(net) {
+        return (await import("../arcus/public.js")).arcusPublicData.fetchMarkets(net);
+    },
+};
+export const arcusVenue = {
+    id: "arcus",
+    aliases: [],
+    displayName: "Arcus",
+    family: "arcus",
+    masterKeyKind: "evm",
+    agentKeyKind: "ed25519",
+    // Ed25519 agent key lives only in OWS wallet `agent-arcus-<master>` (SSOT Rule #3).
+    secretStorage: { kind: "ows-wallet", dir: null },
+    networks: {
+        mainnet: {
+            restUrl: "https://api.arcus.xyz",
+            wsUrl: "wss://api.arcus.xyz/v1/ws",
+            explorerUrl: null,
+            signingChainId: 4663,
+            settlementChain: "robinhood",
+            collateral: ["USDG"],
+            collateralAssetIndex: null,
+            rpcUrl: "https://rpc.mainnet.chain.robinhood.com", // eth_chainId 0x1237 = 4663 (verified)
+            depositPins: null,
+        },
+        testnet: {
+            restUrl: "https://api.testnet.arcus.xyz",
+            wsUrl: "wss://api.testnet.arcus.xyz/v1/ws",
+            explorerUrl: null,
+            signingChainId: 46630,
+            settlementChain: "robinhood",
+            collateral: ["USDG"],
+            collateralAssetIndex: null,
+            rpcUrl: "https://rpc.testnet.chain.robinhood.com", // eth_chainId 0xb626 = 46630 (verified)
+            depositPins: null,
+        },
+    },
+    fundingRateBasis: { kind: "perHours", hours: 1 },
+    settlementIntervalHours: 1,
+    fundingVerified: true,
+    roles: ["marketData", "account", "trading"],
+    capabilities: {
+        marketOrder: "slippageBounded",
+        // GTC = GTT at goodTil now + 40 days (ARCUS_GOOD_TIL_HORIZON_MS); GTT kept as the venue alias.
+        timeInForce: ["GTC", "GTT", "IOC", "FOK", "ALO"],
+        reduceOnlyTif: null,
+        clientOrderId: true,
+        orderAck: "async",
+        tpsl: "batchGroup",
+        amend: "native",
+        batchPlaceMax: 100,
+        marginModes: ["cross", "isolated"],
+        withdrawAssets: ["USDG"],
+    },
+    // Per-IP bucket: 1,500 weight, refilling 1,500/min (docs "Rate limits").
+    // Weights per the docs' tier table; unlisted endpoints cost 1 (root/time tier).
+    // Order writes are 0 on the IP layer (per-subaccount pools govern them).
+    rateLimit: {
+        capacity: 1500,
+        refillPerSec: 25,
+        weights: {
+            setLeverage: 125, withdraw: 125, transfer: 125,
+            placeOrder: 0, modifyOrder: 0, cancelOrder: 0, cancelAllOrders: 0,
+            batchPlaceOrders: 0, batchCancelOrders: 0, scheduleCancel: 0,
+            account: 2, positions: 2, order: 2, leverages: 2, mids: 2,
+            // l2OrderBook = 2 + floor(nLevels / 20); the adapter requests 50 levels (rate-limits doc).
+            l2OrderBook: 4,
+            markets: 20, prices: 20, trades: 20, candles: 20, openOrders: 20, orders: 20,
+            fills: 20, funding: 20, fundingRates: 20, apiKeys: 20, createApiKey: 20, revokeApiKey: 20,
+        },
+    },
+    restrictedRegions: ["US", "CA", "GB"],
+    symbolIdentity: "baseTicker",
+    publicData,
+    // §12: market swaps via router.spot.arcus.xyz, settled on-chain from the master EVM wallet.
+    spot: {
+        accountModel: "wallet",
+        quoteAssets: { mainnet: ["USDG"], testnet: ["USDG"] },
+        capabilities: { limitOrder: false, orderbook: false, cancel: false, transfer: false },
+        async createSpot(perp, opts) {
+            const [{ ArcusAdapter }, { ArcusSpotAdapter }] = await Promise.all([
+                import("../arcus/adapter.js"), import("../arcus/spot.js"),
+            ]);
+            if (!(perp instanceof ArcusAdapter))
+                throw new Error(`arcus spot needs an ArcusAdapter (got ${perp.name})`);
+            const spot = new ArcusSpotAdapter(perp, { confirmOnchainApprove: opts.confirmOnchainApprove });
+            await spot.init();
+            return spot;
+        },
+    },
+    // Arcus venue limit per design §13.10 #1.
+    maxSlippageBps: 1000,
+    builderFee: BUILDER_FEE_CAPABILITIES["arcus"],
+    async create(ctx) {
+        const { ArcusAdapter } = await import("../arcus/adapter.js");
+        return new ArcusAdapter(arcusVenue, ctx);
+    },
+};

package/dist/exchanges/venues/aster.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Aster venue definition (design §10.1, §10.8, §10.13 #4).
+ * Adapter + public-data code are loaded lazily (§10.10).
+ */
+import type { VenueDefinition } from "../venue.js";
+/** Aster client order id (V3 futures "New Order" `newClientOrderId` rule). */
+export declare const ASTER_CLIENT_ID_RE: RegExp;
+/** Chains the CLI deposits from / withdraws to (`--chain`). */
+export type AsterFundsChain = "bsc" | "arbitrum";
+export type AsterFundsAsset = "USDT" | "USDC";
+export interface AsterFundsChainPins {
+    chainId: number;
+    /** Display name. */
+    label: string;
+    /** `destination Chain` of the EVM withdraw signature (docs "chainName definition"). */
+    withdrawChainName: "BSC" | "Arbitrum";
+    /** Public JSON-RPC of the chain (no env override). */
+    rpcUrl: string;
+    /** AstherusVault (ERC-1967 proxy) — the deposit contract. */
+    vault: string;
+    tokens: Readonly<Record<AsterFundsAsset, string>>;
+    sources: readonly string[];
+}
+/**
+ * PINNED Aster vault + token addresses (mainnet). A deposit is `approve(vault, exact amount)` then
+ * `deposit(address currency, uint256 amount, uint256 broker)` on the vault — never a plain token
+ * transfer. Verified 2026-10-05 against:
+ *   - github.com/asterdex/api-docs demo/aster-deposit-withdrawal.md "Mainnet contract addresses"
+ *     (BSC 0x1284…7974, Arbitrum 0x9E36…E1d5) and its ethers example (BSC USDT 0x55d3…7955)
+ *   - docs.asterdex.com/overview/smart-contracts
+ *   - the verified AstherusVault source on BscScan / Arbiscan (`deposit(address,uint256,uint256)`
+ *     selector 0x0efe6a8b, `supportToken(address)`, `paused()`, event Deposit)
+ *   - live `supportToken(token)` non-zero for all four tokens below
+ * Token decimals are NOT pinned: they are read on-chain (`decimals()`) before every deposit
+ * (BSC USDT / USDC have 18, Arbitrum USDC / USDT have 6).
+ */
+export declare const ASTER_FUNDS_CHAINS: Readonly<Record<AsterFundsChain, AsterFundsChainPins>>;
+/** Vault `broker` argument: 1 = perp (futures) account; 1000 = spot account (never used here). */
+export declare const ASTER_DEPOSIT_BROKER_PERP = 1n;
+/**
+ * Why deposit / withdraw are mainnet only (uniform CAPABILITY_UNSUPPORTED on testnet): the vault
+ * addresses above are mainnet deployments, and the withdraw signature's `aster chain` is the
+ * fixed string "Mainnet" (no testnet value is documented).
+ */
+export declare const ASTER_FUNDS_TESTNET_UNSUPPORTED: {
+    readonly reason: "the pinned vault contracts are mainnet deployments and the withdraw signature is defined for \"Mainnet\" only";
+    readonly remediation: "Run without -n testnet; fund the Aster testnet account from the testnet app faucet";
+};
+export declare const asterVenue: VenueDefinition;