@parchment-trade/sdk 0.0.0-stage → 1.0.1

package/dist/packages/parchment/abortCodes.js

@@ -0,0 +1,522 @@
+export const TRADE_RESERVED_ABORT_CODES = [26, 30];
+export const ORDER_RESERVED_ABORT_CODES = [18, 23];
+export const ORACLE_RESERVED_ABORT_CODES = [3, 18];
+export const DECLARED_NOT_RAISED_ABORT_CODES = {
+    trade: [0, 10, 16],
+    order: [1],
+    oracle: [0],
+};
+export const TRADE_ABORT_MESSAGES = {
+    20: "This market's price feed (oracle) is off: nothing can open, close or be liquidated until it is back",
+    22: "Close pause: the current contracts do not raise this; closes and liquidation run under every pause",
+    31: "Price moved beyond your slippage limit",
+    32: "Price moved beyond your slippage limit",
+    35: "Session closed: positions are being closed, try again when it reopens",
+};
+export const TRADE_ABORT_NAMES = {
+    0: "EBadVersion",
+    1: "ETradingPaused",
+    2: "EMarketNotActive",
+    3: "EOracleNotNewer",
+    4: "ELeverage",
+    5: "ENotionalBounds",
+    6: "ETxNotionalCap",
+    7: "EBlockNotionalCap",
+    8: "EAccountNotional",
+    9: "EOiCap",
+    10: "ELpInsolvent",
+    11: "EInsufficientMargin",
+    12: "ESameCheckpoint",
+    13: "EMinHold",
+    14: "EPositionLiquidatable",
+    15: "ENotLiquidatable",
+    16: "ENotAuthorized",
+    17: "EMarketMismatch",
+    18: "EUseDebtDeferred",
+    19: "ENotRetired",
+    20: "EOracleKilled",
+    21: "EMarketDisabled",
+    22: "EClosesPaused",
+    23: "EFactorWorse",
+    24: "EMinLeverage",
+    25: "EMarketClosed",
+    27: "EBustAtOpen",
+    28: "ENotInBook",
+    29: "EOiNotionalCap",
+    31: "EEntryPriceWorse",
+    32: "EExitPriceWorse",
+    33: "ESessionNotArmed",
+    34: "EBatchTooLarge",
+    35: "ESessionClosePending",
+    36: "EKeeperOnlyLiquidation",
+    37: "EWrongAccount",
+};
+export function tradeAbortMessage(code) {
+    const n = decodeAbortCode(code);
+    return n !== undefined && Object.hasOwn(TRADE_ABORT_MESSAGES, n) ? TRADE_ABORT_MESSAGES[n] : undefined;
+}
+export const ORDER_ABORT_NAMES = {
+    0: "ENotKeeper",
+    1: "ENotAuthorized",
+    2: "EAccountMismatch",
+    3: "EMarketMismatch",
+    4: "EWrongKind",
+    5: "EPriceBeforeRequest",
+    6: "EPriceAfterWindow",
+    7: "EFillDeadline",
+    8: "ECancelTooEarly",
+    9: "ENotExpired",
+    10: "EEmergencyTooEarly",
+    11: "ETooManyOrders",
+    12: "EDuplicateClose",
+    14: "EInsufficientFree",
+    15: "ERequestsPaused",
+    16: "EPositionNotFound",
+    17: "EMinHold",
+    19: "EBelowMinMargin",
+    20: "ESessionDrainPending",
+    21: "ENoSessionSnapshot",
+    22: "ENotSessionPending",
+    24: "ECleanupNotBlocked",
+    25: "EPriceFromFuture",
+    26: "EBadMinFactor",
+    27: "ETopUpExceedsFee",
+    28: "EDelegateExpiresBeforeDeadline",
+    29: "EExecFeeAboveMax",
+    30: "ENeedsSignedEvidence",
+    31: "ECloseStale",
+};
+export const ORDER_ABORT_MESSAGES = {
+    ENotKeeper: "Only an authorized keeper can fill this order",
+    ENotAuthorized: "You are not authorized to act on this account's orders",
+    EAccountMismatch: "This order belongs to a different account",
+    EMarketMismatch: "This order belongs to a different market",
+    EWrongKind: "This action does not match the order type (open vs close)",
+    EPriceBeforeRequest: "The oracle price was published at or before the order request; a later price is needed",
+    EPriceAfterWindow: "The signed oracle price is outside the order's signed fill window",
+    EFillDeadline: "The order's fill deadline has passed; it can only be expired",
+    ECancelTooEarly: "This order cannot be cancelled yet; wait for the cancel delay",
+    ENotExpired: "This order cannot be expired yet; a close also waits out its emergency window",
+    EEmergencyTooEarly: "Emergency close is not available yet; wait for the emergency window, then use a price published after it",
+    ETooManyOrders: "Too many pending orders; wait for one to fill or cancel it",
+    EDuplicateClose: "A close request is already pending for this position",
+    EBelowMinMargin: "Margin after fees is below the market minimum; add margin",
+    ECleanupNotBlocked: "No halted cleanup is pending for this account on that market",
+    ESessionDrainPending: "Positions are closing at session end; open again shortly",
+    ENoSessionSnapshot: "No session snapshot on this market",
+    ENotSessionPending: "Order is not pending across a session close",
+    EPriceFromFuture: "The oracle price is timestamped after the chain clock; a keeper will retry with a current price",
+    EBadMinFactor: "The minimum payout factor cannot exceed 10,000 bps (100%)",
+    ETopUpExceedsFee: "Deposits are paused: the top-up can only cover the missing execution fee",
+    EDelegateExpiresBeforeDeadline: "This trading session expires before the order could fill; renew the session and try again",
+    EExecFeeAboveMax: "The execution fee changed since you reviewed this order; review it again",
+    ENeedsSignedEvidence: "This order needs a signed oracle update to expire; try again shortly",
+    ECloseStale: "The automatic close arrived after its deadline and did not run; it is retried with a fresh price",
+    EInsufficientFree: "Not enough free balance for margin plus the execution fee",
+    ERequestsPaused: "This market is not taking new orders (paused, reduce-only, retired or oracle off); on a retired market use close-retired",
+    EPositionNotFound: "This position is not open in this account and market (it may have been closed or liquidated)",
+    EMinHold: "This position cannot be closed yet; the minimum hold has not elapsed",
+};
+const CLEVER_TAG = 1n << 63n;
+const CLEVER_HAS_CODE = 1n << 62n;
+const CLEVER_NO_CODE = 0xffn;
+export function decodeAbortCode(raw) {
+    if (typeof raw === "string" && !/^\d+$/.test(raw))
+        return undefined;
+    let v;
+    try {
+        v = BigInt(raw);
+    }
+    catch {
+        return undefined;
+    }
+    if (v < 0n || v >= 1n << 64n)
+        return undefined;
+    if ((v & CLEVER_TAG) !== 0n && (v & CLEVER_HAS_CODE) !== 0n) {
+        const code = (v >> 48n) & 0xffn;
+        return code === CLEVER_NO_CODE ? undefined : Number(code);
+    }
+    return v <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(v) : undefined;
+}
+export function orderAbortName(code) {
+    const n = decodeAbortCode(code);
+    return n === undefined ? undefined : ORDER_ABORT_NAMES[n];
+}
+export function orderAbortMessage(nameOrCode) {
+    if (typeof nameOrCode === "string" && !/^\d+$/.test(nameOrCode)) {
+        return Object.prototype.hasOwnProperty.call(ORDER_ABORT_MESSAGES, nameOrCode)
+            ? ORDER_ABORT_MESSAGES[nameOrCode]
+            : undefined;
+    }
+    const name = orderAbortName(nameOrCode);
+    return name === undefined ? undefined : ORDER_ABORT_MESSAGES[name];
+}
+export const MARKET_ABORT_NAMES = {
+    0: "EBadVersion",
+    1: "EBadPin",
+    2: "EBadParam",
+    3: "EAlreadyShared",
+    4: "ENotConfigured",
+    5: "EKeeperRaise",
+    6: "EOracleRetargetWithOi",
+    7: "EWrongExchange",
+    8: "ETxBelowMinNotional",
+    9: "EBucketMissing",
+    10: "EBadEmergencyAfter",
+};
+export const FEE_MINT_ABORT_NAMES = {
+    0: "EAccountMismatch",
+    1: "EMintOverflow",
+    2: "EWrongMintWitness",
+};
+export const EXCHANGE_ABORT_NAMES = {
+    0: "EBadVersion",
+    1: "EVault",
+    2: "ENotUsdc",
+    3: "EZero",
+    4: "ENoTreasury",
+    5: "ETreasurySet",
+    6: "ESweepTooSoon",
+    7: "ENoSurplus",
+    8: "ECheckIncomplete",
+    9: "ECheckExchange",
+    11: "ECheckStale",
+    12: "EReceiptMismatch",
+    13: "ETreasuryMinted",
+    14: "EHarvestAuth",
+    15: "ETreasuryUsed",
+    16: "EWrongCoinWitness",
+};
+export const ACCESS_ABORT_NAMES = {
+    0: "EUnregisteredWitness",
+    1: "EExtensionsSealed",
+    2: "ENoExtensionProposal",
+    3: "EExtensionNotReady",
+    4: "ENotOnConfig",
+    5: "EAlreadyRegistered",
+    6: "EAuthNotBound",
+    7: "ENotPrimaryWitness",
+    8: "ERetiredImplementation",
+    9: "EVersionNotNewer",
+};
+export const BUILDER_BOOK_ABORT_NAMES = {
+    0: "EBadBuilderFee",
+    1: "EBadBuilderStatus",
+    2: "EZeroBuilderAddress",
+    3: "EBadBuilderCode",
+    4: "ETombstoneLocked",
+};
+export const REFERRAL_BOOK_ABORT_NAMES = {
+    0: "EBadBind",
+    1: "EBindCycle",
+};
+export const ACCOUNT_ABORT_NAMES = {
+    0: "EBadVersion",
+    1: "EAccountExists",
+    2: "ENotAuthorized",
+    3: "EDelegateTooLong",
+    4: "EPositionMissing",
+    5: "EWrongExchange",
+    6: "ECapMismatch",
+    7: "EPermitMismatch",
+    8: "EPendingOrders",
+};
+export const HOLDER_BOOK_ABORT_NAMES = {
+    0: "ERecipientHasAccount",
+};
+export const ACCOUNT_TRANSFER_ABORT_NAMES = {
+    0: "EZeroRecipient",
+};
+export const GAME_BOOK_ABORT_NAMES = {
+    0: "EAlreadyAttached",
+    1: "EBadParam",
+    2: "ERegistryFull",
+    3: "EUnknownId",
+};
+export const CONFIG_ABORT_NAMES = {
+    0: "EBadVersion",
+    1: "EBadFee",
+    2: "EFeeUnset",
+    3: "EBadBatch",
+    4: "EBadReferralFee",
+    5: "EBadSecondLevel",
+    6: "EBadRefereeDiscount",
+    8: "EBadEconParam",
+    9: "EBadExecFeeRecipient",
+    10: "EBadPauseCategory",
+    11: "EDepositsPaused",
+    12: "EWithdrawalsPaused",
+    13: "ELiquidationsPaused",
+    14: "EForceClosePaused",
+    15: "EHarvestPaused",
+    16: "EStakePaused",
+    17: "EUnstakePaused",
+    18: "EStakingClaimsPaused",
+    19: "ELpPaused",
+    20: "EGamePaused",
+    21: "EFeeMintPaused",
+    22: "EReferralsPaused",
+    23: "EAccountsPaused",
+    25: "EOpensPaused",
+    26: "EClosesPaused",
+    27: "EBadBuilderFee",
+    28: "EBadBuilderCreateFee",
+    100: "EBadOrderParam",
+    101: "EGuardianCannotUnpause",
+};
+export const REFERRAL_ABORT_NAMES = {
+    0: "ESelfReferral",
+    1: "EReferrerBound",
+    2: "EReferralCycle",
+    3: "EReferralDepth",
+    4: "EReferralInsolvent",
+    5: "EZeroReferrer",
+};
+export const BUILDER_ABORT_NAMES = {
+    0: "EUnknownBuilder",
+    2: "EBadCode",
+    4: "ENotBuilderOwner",
+    5: "EZeroPayout",
+    6: "EZeroOwner",
+    8: "EBadCharset",
+    9: "ECodeReserved",
+    10: "ETooManyCodes",
+    11: "EBadFee",
+    12: "ENotApproved",
+    13: "EAdminSuspended",
+    14: "ECreateFeeMismatch",
+    15: "ESelfServeDisabled",
+    16: "ETombstoned",
+};
+export const STAKING_ABORT_NAMES = {
+    0: "EBadVersion",
+    1: "ESinkUnset",
+    2: "ESinkBound",
+    3: "EZero",
+    4: "EInsufficientStake",
+    5: "ENotUsdc",
+    6: "ESelfReferral",
+    7: "EReferrerBound",
+    8: "EReferralClosed",
+    9: "EBadStreamDuration",
+    10: "EBadStakeLock",
+    11: "EStakeLocked",
+    12: "EWrongConfig",
+    13: "EZeroReferrer",
+    14: "EBadLockedWeight",
+    15: "EExchangeUnbound",
+    16: "EWrongExchange",
+    17: "EExchangeBound",
+};
+export const ORACLE_ABORT_NAMES = {
+    0: "EBadVersion",
+    1: "EPriceStale",
+    2: "EPriceFuture",
+    4: "EPriceNotPositive",
+    5: "EBadFeed",
+    6: "EBadSpread",
+    8: "EConfStale",
+    9: "EConfFuture",
+    10: "ESessionNotClosed",
+    11: "EMarketMismatch",
+    12: "EOracleRegression",
+    13: "EGapTooShort",
+    14: "ESessionArmed",
+    15: "EOracleKilled",
+    16: "ENotKeeper",
+    17: "EMarketClosesPaused",
+    19: "ETimestampWindow",
+    20: "ENoSignedSession",
+};
+export const GAME_ABORT_NAMES = {
+    0: "EGameDisabled",
+    1: "EAlreadyClaimed",
+    2: "ENoTreasury",
+    3: "EBadParam",
+    4: "EUnknownId",
+    5: "EAlreadyDone",
+    6: "ECooldown",
+    7: "ENoCrate",
+    8: "ENoAccount",
+    9: "ENotReady",
+    10: "ESeasonRewarded",
+    11: "EInactive",
+    12: "ERegistryFull",
+    13: "EBadBatch",
+};
+export const KEEPER_ABORT_NAMES = {
+    0: "EKeeperPriority",
+};
+export const EVENT_GUARD_ABORT_NAMES = {
+    0: "EBadReason",
+    1: "EBadWindow",
+    2: "EBadLeverageCap",
+    3: "EEventPaused",
+    4: "EEventLeverage",
+    5: "ENoEventPause",
+    6: "EMarketMismatch",
+    7: "EMarketClosed",
+    8: "ESessionArmed",
+    9: "EOracleRegression",
+};
+export const FEES_ABORT_NAMES = {
+    0: "ENonZeroLoss",
+    1: "ESinkExists",
+};
+export const TIMELOCK_ABORT_NAMES = {
+    0: "EBadVersion",
+    2: "ENoPending",
+    4: "EDigestMismatch",
+    5: "ECapMissing",
+    6: "ECapDeposited",
+    7: "EWrongCap",
+};
+export const POSITION_ABORT_NAMES = {
+    0: "EBufferAboveCap",
+    1: "EBadLeverage",
+    2: "EBadPrice",
+    3: "EBadWinFee",
+    4: "EBadExposure",
+};
+export const LIQ_BOOK_ABORT_NAMES = {
+    0: "EMissing",
+    1: "EExists",
+};
+export const LP_ABORT_NAMES = {
+    0: "EZeroClaim",
+};
+export const AUTHORITY_ABORT_NAMES = {
+    0: "ENotAuthorized",
+};
+export const ORACLE_ADAPTER_ABORT_NAMES = {
+    1: "EBadState",
+    2: "EBadFeed",
+    3: "EBadSpread",
+    4: "EBadExponent",
+    5: "EBadSource",
+    6: "ENoSignedPrice",
+    7: "ENoFeedTimestamp",
+    8: "EStorageBehind",
+    9: "ESignedPriceMismatch",
+    10: "ESignedTimestampMismatch",
+};
+export const LOCKED_MINT_ABORT_NAMES = {
+    0: "ENoEntry",
+    1: "EUnlocked",
+    2: "EBadAmount",
+    4: "ETooManyBuckets",
+    5: "EPenaltyAboveMax",
+    6: "EBadSchedule",
+    7: "ENoRoom",
+};
+export const MINT_CAP_ABORT_NAMES = {
+    0: "EBadParams",
+    1: "EFloorAboveKTenth",
+};
+export const MARKET_ABORT_MESSAGES = {
+    ETxBelowMinNotional: "The per-transaction notional cap is below the market's minimum notional",
+};
+export const GAME_ABORT_MESSAGES = {
+    EBadBatch: "Batch size must be at least 1",
+};
+export const FEE_MINT_ABORT_MESSAGES = {
+    EWrongMintWitness: "The mint witness is not from the reward coin's package",
+};
+export const ABORT_NAME_MAPS = {
+    trade: TRADE_ABORT_NAMES,
+    order: ORDER_ABORT_NAMES,
+    oracle: ORACLE_ABORT_NAMES,
+    game: GAME_ABORT_NAMES,
+    game_book: GAME_BOOK_ABORT_NAMES,
+    keeper: KEEPER_ABORT_NAMES,
+    event_guard: EVENT_GUARD_ABORT_NAMES,
+    fees: FEES_ABORT_NAMES,
+    market: MARKET_ABORT_NAMES,
+    fee_mint: FEE_MINT_ABORT_NAMES,
+    exchange: EXCHANGE_ABORT_NAMES,
+    access: ACCESS_ABORT_NAMES,
+    account: ACCOUNT_ABORT_NAMES,
+    holder_book: HOLDER_BOOK_ABORT_NAMES,
+    account_transfer: ACCOUNT_TRANSFER_ABORT_NAMES,
+    config: CONFIG_ABORT_NAMES,
+    timelock: TIMELOCK_ABORT_NAMES,
+    position: POSITION_ABORT_NAMES,
+    liq_book: LIQ_BOOK_ABORT_NAMES,
+    lp: LP_ABORT_NAMES,
+    authority: AUTHORITY_ABORT_NAMES,
+    adapter: ORACLE_ADAPTER_ABORT_NAMES,
+    referral: REFERRAL_ABORT_NAMES,
+    builder: BUILDER_ABORT_NAMES,
+    builder_book: BUILDER_BOOK_ABORT_NAMES,
+    referral_book: REFERRAL_BOOK_ABORT_NAMES,
+    staking: STAKING_ABORT_NAMES,
+    locked_mint: LOCKED_MINT_ABORT_NAMES,
+    mint_cap: MINT_CAP_ABORT_NAMES,
+    game_facade: GAME_ABORT_NAMES,
+};
+export const ABORT_MODULE_PATHS = {
+    trade: "parchment_trade::trade",
+    order: "parchment_trade::order",
+    oracle: "parchment_trade::oracle",
+    game: "parchment_game::game",
+    game_book: "parchment_game::game_book",
+    keeper: "parchment_trade::keeper",
+    event_guard: "parchment_trade::event_guard",
+    fees: "parchment_trade::fees",
+    market: "parchment::market",
+    fee_mint: "parchment_trade::fee_mint",
+    exchange: "parchment::exchange",
+    access: "parchment::access",
+    account: "parchment::account",
+    holder_book: "parchment_base::holder_book",
+    account_transfer: "parchment_trade::account_transfer",
+    config: "parchment::config",
+    timelock: "parchment::timelock",
+    position: "parchment_base::position",
+    liq_book: "parchment_base::liq_book",
+    lp: "parchment_base::lp",
+    authority: "parchment::authority",
+    adapter: "parchment_oracle::adapter",
+    referral: "parchment_trade::referral",
+    builder: "parchment_trade::builder",
+    builder_book: "parchment_base::builder_book",
+    referral_book: "parchment::referral_book",
+    staking: "parchment_token::staking",
+    locked_mint: "parchment_mint::locked_mint",
+    mint_cap: "parchment_mint::mint_cap",
+    game_facade: "parchment_trade::game",
+};
+export const UNCOVERED_MODULES = {
+    "oracle_aggregator::authority": "vendored aggregator (admin setup only); short name collides with parchment::authority",
+    "oracle_aggregator::config": "vendored aggregator (admin setup only); short name collides with parchment::config",
+    "oracle_aggregator::price": "vendored aggregator internals; Parchment reads prices through parchment_oracle::adapter",
+    "oracle_aggregator::price_feed": "vendored aggregator feed admin; not called by Parchment users",
+    "oracle_aggregator::price_feed_storage": "vendored aggregator storage auth; not called by Parchment users",
+    "oracle_aggregator::source": "vendored aggregator version check; not called by Parchment users",
+};
+const MODULE_KEY_BY_PATH = new Map(Object.entries(ABORT_MODULE_PATHS).map(([key, path]) => [path, key]));
+const MODULE_ABORT_MESSAGES = {
+    order: ORDER_ABORT_MESSAGES,
+    market: MARKET_ABORT_MESSAGES,
+    fee_mint: FEE_MINT_ABORT_MESSAGES,
+    game: GAME_ABORT_MESSAGES,
+};
+export function abortName(module, code) {
+    const key = MODULE_KEY_BY_PATH.get(module) ?? module;
+    const names = Object.hasOwn(ABORT_NAME_MAPS, key) ? ABORT_NAME_MAPS[key] : undefined;
+    const n = decodeAbortCode(code);
+    return names !== undefined && n !== undefined && Object.hasOwn(names, n) ? names[n] : undefined;
+}
+export function abortMessage(module, nameOrCode) {
+    if (module === "trade") {
+        if (typeof nameOrCode !== "string" || /^\d+$/.test(nameOrCode))
+            return tradeAbortMessage(nameOrCode);
+        const code = Object.keys(TRADE_ABORT_NAMES).find((n) => TRADE_ABORT_NAMES[Number(n)] === nameOrCode);
+        return code === undefined ? undefined : tradeAbortMessage(Number(code));
+    }
+    const messages = Object.hasOwn(MODULE_ABORT_MESSAGES, module) ? MODULE_ABORT_MESSAGES[module] : undefined;
+    if (messages === undefined)
+        return undefined;
+    const name = typeof nameOrCode === "string" && !/^\d+$/.test(nameOrCode) ? nameOrCode : abortName(module, nameOrCode);
+    return name !== undefined && Object.hasOwn(messages, name) ? messages[name] : undefined;
+}