@hyperbridge/simplex 0.16.12 → 0.17.0

package/dist/index.d.cts

@@ -2,8 +2,8 @@ import { EventEmitter as EventEmitter$1 } from 'node:events';
 import { HexString, ERC7821Call, ChainConfig, Order, TokenInfo, IntentsCoprocessor, ExecutionResult, IntentGateway, FillOptions, FillerConfig as FillerConfig$1 } from '@hyperbridge/sdk';
 import { PublicClient, Hash, AbiEvent, BlockNumber, BlockTag, GetLogsParameters, GetLogsReturnType, WalletClient, Transport, Chain } from 'viem';
 import { LocalAccount, Account } from 'viem/accounts';
-import { L as LoggerContext, a as LogLevel, b as Logger, A as ActivityStore, c as ActivityInsert, d as ActivityEvent, O as OrderHistoryPage, W as WalletTx, e as LimitOrderStore, f as LimitOrder, g as LimitOrderFilter, B as BidStore, S as SimplexDataStore, h as LimitOrderFill, i as StoredBid, j as LogSink, k as BidStats, l as StateStore } from './types-B5zkFhxR.cjs';
-export { m as ActivityType, n as BidInsert, o as LimitOrderFillInsert, p as LimitOrderHold, q as LimitOrderInsert, r as LimitOrderPosting, s as LimitOrderSide, t as LimitOrderStatus, u as OperatorNotification, R as RuntimeState, v as WalletTxKind, w as addLogSink, x as configureLogger, y as getLogger } from './types-B5zkFhxR.cjs';
+import { L as LoggerContext, a as LogLevel, b as Logger, A as ActivityStore, c as ActivityInsert, d as ActivityEvent, O as OrderHistoryPage, W as WalletTx, e as LimitOrderStore, f as LimitOrder, g as LimitOrderFilter, B as BidStore, S as SimplexDataStore, h as LimitOrderFill, i as StoredBid, j as LogSink, k as BidStats, l as StateStore, I as InventoryStore } from './types-BPyUX8qu.cjs';
+export { m as ActivityType, n as BidInsert, o as InventorySnapshot, p as LimitOrderFillInsert, q as LimitOrderFillRecord, r as LimitOrderHold, s as LimitOrderInsert, t as LimitOrderPosting, u as LimitOrderSide, v as LimitOrderStatus, w as OperatorNotification, R as RuntimeState, x as WalletTxKind, y as addLogSink, z as configureLogger, C as getLogger } from './types-BPyUX8qu.cjs';
 import { ChannelCredentials } from '@grpc/grpc-js';
 import { EventEmitter } from 'events';
 import Decimal$1, { Decimal } from 'decimal.js';
@@ -936,7 +936,11 @@ declare class UserOpSender {
      */
     private estimateGas;
     private buildSignedUserOp;
-    /** Mirrors the gas-price selection used by the delegation and fill paths. */
+    /**
+     * Mirrors the gas-price selection used by the delegation and fill paths: Pimlico's and
+     * Alchemy's own pricing, otherwise the chain's gas price raised to the priority fee a
+     * rundler bundler requires, when the bundler gives one.
+     */
     private getGasPrice;
     private sendBundlerRpc;
     private waitForUserOpReceipt;
@@ -1419,10 +1423,10 @@ declare function validateAssetDefinitions(assets: Record<string, AssetDefinition
  *  1. the user's `[assets]` table — an *escape hatch* for assets the registry
  *     doesn't ship (or per-deployment overrides), never required for shipped
  *     symbols;
- *  2. shipped symbols (USDC, USDT, DAI, CNGN, USDR, ZARP, EURC, XSGD, TRYB)
- *     resolved per chain from the SDK chain registry (`chain.ts`) — the single
- *     source of truth shared with the rest of the SDK, so an address
- *     correction there is never shadowed by a parallel table here.
+ *  2. shipped symbols (USDC, USDT, DAI, CNGN, USDR, ZARP, EURC, XSGD, TRYB,
+ *     BRIDGE) resolved per chain from the SDK chain registry (`chain.ts`) —
+ *     the single source of truth shared with the rest of the SDK, so an
+ *     address correction there is never shadowed by a parallel table here.
  *
  * Address lookups are per `(symbol, chain)` — a chain where no layer knows the
  * asset simply doesn't trade pairs involving it. The registry holds addresses
@@ -1605,6 +1609,85 @@ declare class BalanceProvider extends EventEmitter$1 {
     private trackHyperbridgeBalance;
 }
 
+/** The stretch of time a summary covers. Each is cut into buckets of one size. */
+type ProfitPeriod = "7d" | "30d" | "12w" | "12m" | "all";
+type ProfitBucket = "day" | "week" | "month" | "year";
+/** What a stretch of fills came to, in dollars at the latest rate. Unpriced tokens are left out. */
+interface ProfitFigures {
+    /** What the stretch's fills added to inventory, less what they took out of it. */
+    profitUsd: number;
+    /** The inventory held when the stretch began. Null when nothing within reach of then records it. */
+    startInventoryUsd: number | null;
+    /** `profitUsd` over `startInventoryUsd`, as a percentage. Null without a starting inventory. */
+    returnPct: number | null;
+    /**
+     * What moved in and out over the stretch other than through fills, net: deposits, withdrawals,
+     * fees and vault yield. Null when the indexer has no reading for both ends of the stretch.
+     */
+    transfersUsd: number | null;
+    boughtUsd: number;
+    soldUsd: number;
+    buys: number;
+    sells: number;
+}
+interface ProfitBucketFigures extends ProfitFigures {
+    /** When the bucket starts, in milliseconds since the epoch. */
+    start: number;
+}
+/** One book's buys against its sells over the period, in the book's own tokens. */
+interface BookProfit {
+    book: string;
+    base: string;
+    quote: string;
+    /** Base bought and sold in the period. */
+    bought: number;
+    sold: number;
+    /** Quote per base, averaged over the period's buys and its sells. Null for a side with none. */
+    averageBuy: number | null;
+    averageSell: number | null;
+    /** How far the average sell sits above the average buy, as a percentage. Null without both. */
+    spreadPct: number | null;
+    /** What the period's fills did to the base and the quote held: positive is more than before. */
+    baseChange: number;
+    quoteChange: number;
+    /** The rate the book's tokens are valued at: midway between its latest buy and latest sell. */
+    rate: number | null;
+    /** Both changes in dollars. Null when the book's tokens have no dollar price. */
+    profitUsd: number | null;
+}
+/** The inventory a period began with, token by token. */
+interface StartingInventory {
+    /** The instant it describes, in milliseconds since the epoch. */
+    at: number;
+    /** A stored snapshot, or the balances as they stand now. Either is adjusted by what happened between. */
+    source: "snapshot" | "balances";
+    /** When that record was taken. */
+    recordedAt: number;
+    usd: number;
+    tokens: Array<{
+        symbol: string;
+        amount: number;
+        usd: number | null;
+    }>;
+}
+interface Profitability {
+    period: ProfitPeriod;
+    bucket: ProfitBucket;
+    /** The start of the first bucket and the moment the summary was taken, in milliseconds. */
+    from: number;
+    to: number;
+    totals: ProfitFigures;
+    /** One entry per bucket, oldest first, including buckets nothing happened in. */
+    series: ProfitBucketFigures[];
+    books: BookProfit[];
+    /** Null when there is no snapshot, and the period began more than {@link BALANCES_REACH_MS} ago. */
+    startInventory: StartingInventory | null;
+    /** Fills in the period priced at their order's rate, because they kept no record of what they took in. */
+    estimatedFills: number;
+    /** Tokens the period touched that have no dollar price, and so are in none of the dollar figures. */
+    unpricedTokens: string[];
+}
+
 /**
  * Wire contracts between the UI server and the browser bundle. The server
  * types its response literals with these and `ui/src` imports them type-only,
@@ -1751,7 +1834,7 @@ interface FillerTomlConfig {
      * Optional asset-registry escape hatch: symbol → { chain → address }. Only
      * needed for assets the built-in registry does not ship, or to override a
      * shipped address for a deployment. Shipped symbols: USDC, USDT, DAI, CNGN
-     * (SDK chain registry) + curated USDR, ZARP, EURC, XSGD and TRYB.
+     * (SDK chain registry) + curated USDR, ZARP, EURC, XSGD, TRYB and BRIDGE.
      */
     assets?: Record<string, AssetDefinition>;
     /**
@@ -2044,6 +2127,8 @@ interface BidPlan {
     fillerOutputs: TokenInfo[];
     /** The take signed beside each output: the escrow this bid's fill earns. */
     fillerInputs: TokenInfo[];
+    /** The decimals `fillerInputs[leg]` is counted in: the input token's, on the order's source chain. */
+    inputDecimals?: number;
     fundingCalls: ERC7821Call[];
     partialFill: boolean;
     profit: number;
@@ -2167,6 +2252,7 @@ declare class ContractInteractionService {
     cacheService: CacheService;
     private logger;
     private sdkHelperCache;
+    private blockTimes;
     private solverAccountAddress;
     private signer;
     constructor(clientManager: ChainClientManager, configService: FillerConfigService, signer: Signer, sharedCacheService?: CacheService);
@@ -2325,11 +2411,28 @@ declare class ContractInteractionService {
      *
      * Operators configure seconds because that is the unit the risk is actually in, but the
      * contract compares against block numbers so `order.deadline` and this read the same
-     * clock. The conversion uses the chain's nominal block time; it is deliberately rounded
-     * up, since erring long costs a slightly stale quote while erring short silently drops
-     * winnable bids.
+     * clock. The conversion uses the chain's block time from {@link blockTimeSeconds}; it is
+     * deliberately rounded up, since erring long costs a slightly stale quote while erring
+     * short silently drops winnable bids.
      */
     private bidValidUntilBlock;
+    /**
+     * Seconds per block on `chain`. Measured once, when simplex starts ({@link initCache}), and
+     * kept until it stops. A chain with no measurement yet, because it was added later or its
+     * blocks could not be read at startup, is measured at its first bid.
+     *
+     * The nominal `Chain.blockTime` cannot be relied on alone: it goes stale when a chain
+     * speeds up (BSC makes a block every 0.45s against a declared 0.75s) and some chains
+     * declare none. Converting at a slower block time than the chain's ends a bid early, so
+     * the faster of the measured and the declared figure is used, and a stalled or idle
+     * stretch in the sample never shortens a bid.
+     *
+     * Blocks that cannot be read fall back to the declared figure, then to
+     * {@link FALLBACK_BLOCK_TIME_SECONDS}. That answer is not kept.
+     */
+    private blockTimeSeconds;
+    /** The average block time over the chain's last {@link BLOCK_TIME_SAMPLE_BLOCKS} blocks, in seconds. */
+    private measureBlockTimeSeconds;
     /**
      * Builds the signed, never-executed UserOperation that carries one limit order
      * to the HyperFX orderbook.
@@ -2701,6 +2804,52 @@ interface Book {
     base: string;
     quote: string;
 }
+/** Live price levels. All prices and sizes are decimal integer strings at 1e18. */
+interface OrderbookLevel {
+    fillChain: string;
+    priceBucket: string;
+    price: string;
+    worstPrice: string;
+    baseSize: string;
+    quoteSize: string;
+    orderCount: number;
+    solverCount: number;
+}
+interface OrderbookSnapshot extends Book {
+    /** Best first: bids descending, asks ascending. */
+    bids: OrderbookLevel[];
+    asks: OrderbookLevel[];
+    /** True backing liquidity, in quote for bids and base for asks. */
+    bidLiquidity: string;
+    askLiquidity: string;
+    /** Price bucket width, quote per 1 base at 1e18; null when the orderbook does not report one. */
+    granularity: string | null;
+}
+/** One solver's order inside a price level. Prices and sizes are decimal integer strings at 1e18. */
+interface OrderbookLevelOrder {
+    solver: string;
+    commitment: string;
+    fillChain: string;
+    price: string;
+    /** What the order publishes as depth, in the token its side pays out: quote for bids, base for asks. */
+    advertisedSize: string;
+    /** The signed output before any balance cap, in the same token as `advertisedSize`. */
+    quotedAmount: string;
+    /** True when the solver's balance, not the quote, binds `advertisedSize`. */
+    resized: boolean;
+    expiresAt: string;
+    acceptedSources: string[];
+}
+interface OrderbookLevelQuery {
+    side: "BID" | "ASK";
+    fillChain: string;
+    priceBucket: string;
+    sourceChain?: string;
+}
+interface OrderbookFilters {
+    sourceChain?: string;
+    fillChain?: string;
+}
 interface TokenMinSize {
     symbol: string;
     size: string;
@@ -2851,6 +3000,14 @@ declare class OrderbookClient {
     constructor(url: string, requestTimeoutMs: number, loggers?: LoggerContext);
     /** The limits to validate against before posting, plus the books on offer. */
     limits(): Promise<OrderbookLimits>;
+    /** The public book across all solvers, restricted to the selected route. */
+    snapshot(id: string, filters?: OrderbookFilters): Promise<OrderbookSnapshot | null>;
+    /**
+     * The orders behind one price level. The orderbook filters orders by side and route but not by
+     * price bucket, so this walks the side's orders on the level's fill chain and keeps the bucket.
+     * Null when the book does not exist.
+     */
+    levelOrders(id: string, level: OrderbookLevelQuery): Promise<OrderbookLevelOrder[] | null>;
     submitOrder(userOp: HexString): Promise<SubmitOrderResult>;
     /**
      * The entry this solver holds at `commitment`, or null when it holds none.
@@ -2949,7 +3106,10 @@ interface CancelledLimitOrder {
 interface ReconcileReport {
     /** Orderbook entries no limit order here owns, now withdrawn. */
     cancelled: number;
-    /** Limit orders whose entry had gone, now posted again. */
+    /**
+     * Limit orders posted again: their entry had gone, or it was signed for an
+     * EntryPoint the fill chain no longer uses.
+     */
     reposted: number;
     /** Postings the orderbook is not backing in full, left alone and surfaced. */
     underFunded: number;
@@ -2985,6 +3145,8 @@ declare class LimitOrderService {
     private logger;
     private cachedLimits?;
     private onEvent?;
+    /** Re-signs in flight, by order id. A fill's resize waits one out rather than reposting alongside it. */
+    private readonly resigning;
     constructor(store: LimitOrderStore, client: OrderbookClient, contractService: ContractInteractionService, configService: FillerConfigService, assetRegistry: AssetRegistry, signer: Signer, defaultTtlSecs: number, delegationService?: DelegationService | undefined, loggers?: LoggerContext, 
     /** Where a new order's nonce starts; tests pin it, production draws it at random. */
     startingNonce?: () => bigint, 
@@ -3025,6 +3187,10 @@ declare class LimitOrderService {
      */
     private withdraw;
     private signAndCancel;
+    /** Public market levels read through the configured orderbook client. */
+    orderbookSnapshot(book: string, filters?: OrderbookFilters): Promise<OrderbookSnapshot | null>;
+    /** Every solver's order behind one public price level. */
+    orderbookLevelOrders(book: string, level: OrderbookLevelQuery): Promise<OrderbookLevelOrder[] | null>;
     /**
      * The pairs an order can be written against, the smallest payout each token may carry, and
      * the tokens the orderbook registers on each chain.
@@ -3130,9 +3296,25 @@ declare class LimitOrderService {
      * They drift apart when a request never got an answer or the process died
      * between two of them: an entry the orderbook still lists that nothing here
      * owns, an order here whose entry has gone, or an entry the orderbook has cut
-     * down because the solver cannot cover what it quoted.
+     * down because the solver cannot cover what it quoted. A posted op is also
+     * signed over one EntryPoint, so when the fill chain moves to another, every
+     * entry signed before the move is withdrawn and posted again.
      */
     reconcile(now?: Date): Promise<ReconcileReport>;
+    /**
+     * Withdraws a posting signed for an EntryPoint its fill chain no longer uses,
+     * and posts it again signed for the one it uses now. Answers whether a new
+     * posting landed.
+     *
+     * The row is read again and claimed out of `open` first: a fill can have worked
+     * it down or started its own repost since reconciliation listed it, and that
+     * write is the one to follow. A fill that lands once the claim is taken waits
+     * in `resize` for this to finish. The EntryPoint is only written with a posting
+     * that landed, so a pass cut short anywhere leaves a row the next pass still
+     * reads as stale, or as having no entry, and finishes the job.
+     */
+    private resign;
+    private signAgain;
     /**
      * Lowers every open order's `remaining` to what the solver's account will still
      * pay for it, and puts the order back on the book at that size.
@@ -3191,6 +3373,8 @@ declare class LimitOrderService {
      * only the second one.
      */
     private submit;
+    /** The EntryPoint a posting on `chain` is signed for now. */
+    private entryPointFor;
     /**
      * The entry the orderbook holds at `commitment`, if it holds one. A lookup that
      * fails answers null, which sends the caller down the nonce-bump path it would
@@ -3769,6 +3953,10 @@ interface FillerRuntime {
     rebalancingService?: RebalancingService;
     resolvedChains: ResolvedChainConfig[];
     fillerAddress: HexString;
+    /** The indexer this filler reads history from: order details, and what it held at past moments. */
+    indexerUrl: string;
+    /** A token's registry symbol and on-chain decimals, where either can be had. */
+    describeToken: TokenDescriber;
     watchOnly?: Record<number, boolean>;
     config: FillerTomlConfig;
     /** Where the config came from, when it came from a file. */
@@ -3977,6 +4165,7 @@ interface SimplexStatus {
 declare class LimitOrderController {
     private runtime;
     private emit;
+    private indexed?;
     constructor(runtime: FillerRuntime, emit: LimitOrderEmitter);
     private get service();
     list(filter?: LimitOrderFilter): Promise<LimitOrder[]>;
@@ -3993,12 +4182,32 @@ declare class LimitOrderController {
         fills: LimitOrderFill[];
         bids: StoredBid[];
     } | null>;
+    /**
+     * What the operator's buys and sells earned over `period`, bucketed on a clock
+     * `tzOffsetMinutes` behind UTC.
+     *
+     * Profit is the change the period's fills made to what the solver holds, and
+     * it is compared with the inventory the period began with. That inventory
+     * comes from the stored snapshots and, when the balances have been read in
+     * full, from what is held now, each carried to the period's start by what
+     * moved between. The indexer says what moved, deposits and withdrawals
+     * included, wherever it has followed the solver; elsewhere the fills and
+     * sends on record stand in. It answers whether or not an orderbook is
+     * configured, and whether or not the indexer does.
+     */
+    profitability(period: ProfitPeriod, tzOffsetMinutes?: number): Promise<Profitability>;
+    /** One reader for the life of the filler, so the readings it has already fetched are kept. */
+    private indexerInventory;
     /** The pairs the orderbook lists, the smallest payout each token may carry, and its tokens per chain. */
     books(): Promise<{
         books: Book[];
         minOrderSizes: TokenMinSize[];
         chains: ChainInfo[];
     }>;
+    /** Public bids and asks across solvers, optionally restricted to a route. */
+    orderbookSnapshot(book: string, filters?: OrderbookFilters): Promise<OrderbookSnapshot | null>;
+    /** Every solver's order behind one public price level. */
+    orderbookLevelOrders(book: string, level: OrderbookLevelQuery): Promise<OrderbookLevelOrder[] | null>;
     /** Creates the order, posts it, and reports what the orderbook made of it. */
     create(request: CreateLimitOrderRequest): Promise<PostedLimitOrder>;
     cancel(id: string): Promise<CancelledLimitOrder>;
@@ -4240,20 +4449,12 @@ declare class Simplex extends EventEmitter$1 {
     get internals(): FillerRuntime;
 }
 
-/**
- * Process-local data store — the default when `Simplex.start` is given no
- * `data` option.
- *
- * Nothing survives the process. That is fine for tests, short-lived embedded
- * fillers and watch-only observers, but a filler that submits bids should use a
- * durable store: a lost bid record is a Hyperbridge deposit nobody retracts.
- * Settled rows are evicted past a cap; live bids (deposits still reclaimable) are never dropped.
- */
 declare class MemoryDataStore implements SimplexDataStore {
     readonly bids: BidStore;
     readonly activity: ActivityStore;
     readonly state: StateStore;
     readonly limitOrders: LimitOrderStore;
+    readonly inventory: InventoryStore;
 }
 
 /**
@@ -4320,4 +4521,4 @@ declare class OrderScanner implements OrderScanner$1 {
     private closeNow;
 }
 
-export { ActivityEvent, ActivityInsert, ActivityStore, type AllowlistConfig, type AssetBalanceRow, AssetController, type AssetDefinition, type AuthorizationRequest, type BalanceIssue, type BalanceSnapshot, BidStats, BidStore, type BinanceConfig, type CancelledLimitOrder, type ChainBalanceRow, type ChainConfirmationPolicy, ChainController, type ChainInput, type ChainView, type CreateLimitOrderRequest, type CurveConfig, type CurvePoint, type DerivingSigner, type Eip7702Authorization$1 as Eip7702Authorization, type FillerConfigFile, type FillerTomlConfig, type HyperbridgeBalance, LimitOrder, LimitOrderController, LimitOrderFill, LimitOrderFilter, LimitOrderStore, LimitOrderValidationError, LogLevel, LogSink, Logger, LoggerContext, MemoryDataStore, type MpcVaultSignerConfig, OrderScanner, type OrderScanner$1 as OrderScannerContract, type OrderScannerHandlers, type OrderScannerOptions, type PairConfig, PairController, type PairView, type PostedLimitOrder, type PostingOutcome, type PrivateKeySignerConfig, type QueueConfig, RebalanceController, type RebalancingConfig, type ResolvedChainConfig, type ScannedFill, type ScannedOrder, type ScannerChainConfig, type SecretPhraseSignerConfig, type Signature, type Signer, type SignerConfig, type SignerTransaction, SignerType, Simplex, type SimplexConfig, SimplexDataStore, type SimplexEvents, type SimplexOptions, type SimplexStatus, type SolverWork, StateStore, StoredBid, type Subscription, type TurnkeySignerConfig, type TypedDataPayload, USD_STABLE_SYMBOLS, type UserProvidedChainConfig, type VaultBalanceRow, VaultController, type VaultSweepDeposit, type VaultSweepResult, type VaultSweepSkip, type VaultSweepSkipReason, type VaultSweepSubmission, type VaultToml, type VaultTomlConfig, WalletController, WalletTx, assertConfirmationCoverage, canDerive, createSigner, digestSigner, formatChainKey, isRegistrySymbol, mpcVaultSigner, normalizeSymbol, parseChainKey, pickAnchorStable, privateKeySigner, registrySymbols, secretPhraseSigner, turnkeySigner, validateAssetDefinitions, validateConfig, validatePairConfigs, validateSecretPhrase, validateSignerConfig, validateVaultToml, viemSigner };
+export { ActivityEvent, ActivityInsert, ActivityStore, type AllowlistConfig, type AssetBalanceRow, AssetController, type AssetDefinition, type AuthorizationRequest, type BalanceIssue, type BalanceSnapshot, BidStats, BidStore, type BinanceConfig, type BookProfit, type CancelledLimitOrder, type ChainBalanceRow, type ChainConfirmationPolicy, ChainController, type ChainInput, type ChainView, type CreateLimitOrderRequest, type CurveConfig, type CurvePoint, type DerivingSigner, type Eip7702Authorization$1 as Eip7702Authorization, type FillerConfigFile, type FillerTomlConfig, type HyperbridgeBalance, InventoryStore, LimitOrder, LimitOrderController, LimitOrderFill, LimitOrderFilter, LimitOrderStore, LimitOrderValidationError, LogLevel, LogSink, Logger, LoggerContext, MemoryDataStore, type MpcVaultSignerConfig, OrderScanner, type OrderScanner$1 as OrderScannerContract, type OrderScannerHandlers, type OrderScannerOptions, type PairConfig, PairController, type PairView, type PostedLimitOrder, type PostingOutcome, type PrivateKeySignerConfig, type ProfitBucket, type ProfitBucketFigures, type ProfitFigures, type ProfitPeriod, type Profitability, type QueueConfig, RebalanceController, type RebalancingConfig, type ResolvedChainConfig, type ScannedFill, type ScannedOrder, type ScannerChainConfig, type SecretPhraseSignerConfig, type Signature, type Signer, type SignerConfig, type SignerTransaction, SignerType, Simplex, type SimplexConfig, SimplexDataStore, type SimplexEvents, type SimplexOptions, type SimplexStatus, type SolverWork, type StartingInventory, StateStore, StoredBid, type Subscription, type TurnkeySignerConfig, type TypedDataPayload, USD_STABLE_SYMBOLS, type UserProvidedChainConfig, type VaultBalanceRow, VaultController, type VaultSweepDeposit, type VaultSweepResult, type VaultSweepSkip, type VaultSweepSkipReason, type VaultSweepSubmission, type VaultToml, type VaultTomlConfig, WalletController, WalletTx, assertConfirmationCoverage, canDerive, createSigner, digestSigner, formatChainKey, isRegistrySymbol, mpcVaultSigner, normalizeSymbol, parseChainKey, pickAnchorStable, privateKeySigner, registrySymbols, secretPhraseSigner, turnkeySigner, validateAssetDefinitions, validateConfig, validatePairConfigs, validateSecretPhrase, validateSignerConfig, validateVaultToml, viemSigner };