@totalis/hip4-client 0.76.0 → 0.77.0

package/CHANGELOG.md

@@ -3,6 +3,43 @@
 `@totalis/hip4-client` follows [semantic versioning](https://semver.org).
 The contract version the generated types come from is `sdkVersion` in `./version`.
 
+## 0.77.0
+
+`openPosition` chooses its quote last and moves on to the next quote when an
+accept is refused, declined or times out (TT-2578, TT-2574). Makers replace
+quotes as they renew them, and an accept that took seconds to sign often found
+its quote gone (`QUOTE_REPLACED`). Additive: 0.76 code runs unchanged, but
+`openPosition` now sends up to `maxAttempts` accepts where it sent one or two.
+
+### Added
+
+- `prepareEntryFunding({ stake, core, cash, sourceDex, hypercoreNonce })`
+  plans and signs an entry's funding (the wallet's USDC authorization and any
+  bridge from Core) before a quote is chosen. `signEntry({ quote, prepared })`
+  then signs only the quote, so the accept can go straight out. A prepared
+  funding is for one accept.
+- `SignedEntry.refused`: the code of an accept the venue refused outright.
+  `recoverAcceptance` answers such a record `NOT_ADMITTED` from the record
+  alone, without reading the acceptance or cancelling the RFQ.
+- `openPosition` options `minPayout`, `refreshMs` (default 10 s) and
+  `maxAttempts` (default 4).
+
+### Changed
+
+- `openPosition` signs the funding first and chooses the quote after, then
+  signs it and sends the accept at once. Signing the funding counts against
+  `collectMs`.
+- On `QUOTE_REPLACED` or `QUOTE_EXPIRED`, `openPosition` hands `onSigned` the
+  record marked `refused`, then prepares the funding again and signs the best
+  other quote paying at least `minPayout` (left out: the first chosen quote's
+  payout). It keeps going until an accept is taken, `refreshMs` passes or
+  `maxAttempts` accepts were sent, and throws the last refusal. Before, it
+  retried once and took any payout.
+- A `DECLINED` or `TIMED_OUT` accept is followed the same way, within the
+  same `refreshMs` and `maxAttempts`: the maker's answer admitted nothing and
+  the RFQ stays open. With no other quote at or above `minPayout` in time,
+  `openPosition` returns that answer, as before.
+
 ## 0.76.0
 
 Vault agents (TT-2554), one Combo leg per question (TT-2605) and no legs on

package/README.md

@@ -66,8 +66,9 @@ if (opened.operationId) {
 totalis.close();
 ```
 
-`openPosition` creates the RFQ, takes the best quote, signs the acceptance and funds any shortfall from the
-wallet. Only `COMMITTED` means the trade happened. A decided position settles and pays out on its own.
+`openPosition` creates the RFQ, signs the funding for any shortfall from the wallet, then takes the best quote
+and signs the acceptance. If the maker replaced the quote first, declined it or didn't answer, it signs the best
+other quote paying at least the first one's payout (`minPayout`) and tries again. Only `COMMITTED` means the trade happened. A decided position settles and pays out on its own.
 
 ## Make markets
 

package/dist/client.d.ts

@@ -5,7 +5,7 @@ export type { components, operations, paths } from "./generated/client.js";
 export type { AccessToken, ApiClientOptions, PublicEnvironment } from "./base.js";
 /** The typed HTTP client for the `client` audience. `createTotalis` adds the flows. */
 export declare function createClient(environment: PublicEnvironment, options?: ApiClientOptions): import("openapi-fetch").Client<paths, `${string}/${string}`>;
-export { bestBid, bestQuote, createTotalis, EntryError, entryFailure, follow, type Acceptance, type AcceptanceResult, type Amount, type BridgeState, type CashoutBid, type Chooser, type Deployment, type DepositAccepted, type EntryCash, type EntryFailure, type EntryQuote, type CoreExit, type LegacySignedEntry, type Leg, type NotAdmitted, type RecordListener, type Operation, type Quote, type ResponseOf, type SellBackQuote, type SignedAcceptance, type SignedCashout, type SignedCoreExit, type SignedDeposit, type SignedEntry, type SignedReturnToCore, type Totalis, type TotalisOptions, type TransferQuote, type WalletCall, type Withdrawal, } from "./totalis.js";
+export { bestBid, bestQuote, createTotalis, EntryError, entryFailure, follow, type Acceptance, type AcceptanceResult, type Amount, type BridgeState, type CashoutBid, type Chooser, type Deployment, type DepositAccepted, type EntryCash, type EntryFailure, type EntryQuote, type CoreExit, type LegacySignedEntry, type Leg, type PreparedEntryFunding, type NotAdmitted, type RecordListener, type Operation, type Quote, type ResponseOf, type SellBackQuote, type SignedAcceptance, type SignedCashout, type SignedCoreExit, type SignedDeposit, type SignedEntry, type SignedReturnToCore, type Totalis, type TotalisOptions, type TransferQuote, type WalletCall, type Withdrawal, } from "./totalis.js";
 export { bridgeAction, bridgeGasBuffer, classifyHypercoreAnswer, hyperevmUsdcBridge, hyperliquidExchange, hyperliquidNetwork, hypercoreNonce, hypercoreSignature, sendAssetTypedData, settleHypercore, signSendAsset, submitHypercore, usdcText, type BridgedCash, type HypercoreAnswer, type HypercoreSignature, type HypercoreTransport, type HyperliquidNetwork, type SendAssetAction, type SignedSendAsset, } from "./hypercore.js";
 export { ApiError, envelope, NetworkError, randomBytes32, retryingFetch, sendOnce, unwrap, uuidv7, type Fetch, type Repaired, type RetryPolicy } from "./request.js";
 export { items, pages, type Page, type PageQuery } from "./pagination.js";

package/dist/totalis.d.ts

@@ -102,6 +102,27 @@ export type SignedEntry = RecordScope & {
     readonly command: AcceptCommand;
     readonly bridge?: SignedSendAsset;
     readonly bridgeState?: BridgeState;
+    /**
+     * Set when the venue refused this accept outright (`QUOTE_REPLACED`,
+     * `QUOTE_EXPIRED`): nothing was admitted, so `recoverAcceptance` answers
+     * `NOT_ADMITTED` without reading or cancelling the RFQ, which a later
+     * attempt may be using.
+     */
+    readonly refused?: string;
+};
+/**
+ * An entry's funding, signed before its quote is chosen
+ * (`prepareEntryFunding`). Pass it to `signEntry` as `prepared`, so only the
+ * quote is left to sign once it is chosen. It funds one accept: prepare again
+ * for another.
+ */
+export type PreparedEntryFunding = {
+    readonly stake: string;
+    readonly account: Hex;
+    readonly chainId: string;
+    readonly vault: Hex;
+    readonly funding?: Funding;
+    readonly bridge?: SignedSendAsset;
 };
 /** An entry record from SDK 0.63 or older, which sent its bridge before the accept: `recoverAcceptance` reads it and sends nothing, and `sendAcceptance` refuses it. */
 export type LegacySignedEntry = Omit<SignedEntry, "version" | "bridgeState">;
@@ -246,7 +267,7 @@ export declare function createTotalis(options: TotalisOptions): {
         readonly legs: readonly Leg[];
         readonly stake: Amount;
         readonly choose?: Chooser<EntryQuote>;
-        /** How long quotes may keep arriving after the first one `choose` would take, before it picks; 0 takes it at once. */
+        /** How long quotes may keep arriving after the first one `choose` would take, before it picks; 0 takes it at once. Time spent signing the funding counts. */
         readonly collectMs?: number;
         /** `"wallet"` (default) plans the shortfall from the wallet and `core`; `"none"` never funds; or pass a funding command. */
         readonly funding?: "wallet" | "none" | Funding;
@@ -254,9 +275,9 @@ export declare function createTotalis(options: TotalisOptions): {
         readonly core?: Amount | null;
         readonly sourceDex?: "spot" | "";
         readonly transport?: HypercoreTransport;
-        /** The cash to plan from (see `signEntry`); left out, the balances are read while the quotes arrive. */
+        /** The cash to plan from (see `signEntry`); left out, the balances are read while the RFQ is created, and again for each refresh. */
         readonly cash?: EntryCash;
-        /** Awaited with the signed record before anything is sent, then with each change to its bridge (`onRecord`): persist it to `recoverAcceptance` after a restart. */
+        /** Awaited with the signed record before anything is sent, then with each change to its bridge (`onRecord`) or its refusal: persist it to `recoverAcceptance` after a restart. */
         readonly onSigned?: RecordListener;
         /** Automatic-quote intent identity, as the Totalis app sends it. */
         readonly intent?: {
@@ -264,6 +285,12 @@ export declare function createTotalis(options: TotalisOptions): {
             readonly intent_generation: string;
         };
         readonly quoteTimeoutMs?: number;
+        /** The least payout a quote may pay, in USDC base units. Left out, it is the first chosen quote's: a refresh never takes less. */
+        readonly minPayout?: Amount;
+        /** How long after the first quote is chosen a refused, declined or timed-out accept may still be followed by another (default 10 s). */
+        readonly refreshMs?: number;
+        /** The most accepts sent, the first included (default 4); 1 never refreshes. */
+        readonly maxAttempts?: number;
         readonly signal?: AbortSignal;
     }) => Promise<{
         entry: {
@@ -297,6 +324,14 @@ export declare function createTotalis(options: TotalisOptions): {
         readonly quoteTimeoutMs?: number;
         readonly signal?: AbortSignal;
     }) => Promise<AcceptanceResult>;
+    prepareEntryFunding: (request: {
+        readonly stake: Amount;
+        readonly core?: Amount | null | undefined;
+        readonly cash?: EntryCash | undefined;
+        readonly sourceDex?: "spot" | "" | undefined;
+        readonly hypercoreNonce?: number | undefined;
+        readonly signal?: AbortSignal | undefined;
+    }) => Promise<PreparedEntryFunding>;
     signEntry: (request: {
         readonly quote: EntryQuote;
         readonly core?: Amount | null;
@@ -304,6 +339,7 @@ export declare function createTotalis(options: TotalisOptions): {
         readonly sourceDex?: "spot" | "";
         readonly acceptanceId?: string;
         readonly hypercoreNonce?: number;
+        readonly prepared?: PreparedEntryFunding;
     }) => Promise<SignedEntry>;
     signCashout: (request: {
         readonly quote: CashoutBid;

package/dist/totalis.js

@@ -87,6 +87,11 @@ const minimumDeposit = 1000000n;
  * best of them win instead of the fastest.
  */
 const defaultCollectMs = 1_000;
+const defaultRefreshMs = 10_000;
+const defaultMaxAttempts = 4;
+/** Accept refusals that mean the chosen quote went away before the accept, not that the position cannot open. */
+const refreshCodes = new Set(["QUOTE_EXPIRED", "QUOTE_REPLACED"]);
+const passedOn = new Set(["DECLINED", "TIMED_OUT"]);
 const timerSlackMs = 250;
 function termsOf(quote) {
     return quote.kind === "ENTRY" ? quote.entry : quote.kind === "SELL_BACK" ? quote.sell_back : quote.transfer;
@@ -641,11 +646,46 @@ export function createTotalis(options) {
             throw new EntryError("INSUFFICIENT_FUNDS", `${bridge - (routable > 0n ? routable : 0n)} USDC base units short for this stake`);
         return { wallet: shortfall, bridge };
     }
+    function signBridge(signer, chain, amount, request) {
+        return amount > 0n ? signSendAsset(signer, bridgeAction(hyperliquidNetwork(chain.chain_id), amount, {
+            ...(request.hypercoreNonce === undefined ? {} : { nonce: request.hypercoreNonce }),
+            ...(request.sourceDex === undefined ? {} : { sourceDex: request.sourceDex }),
+        })) : undefined;
+    }
+    /**
+     * Plan and sign an entry's funding before choosing its quote: the wallet's
+     * USDC authorization and any bridge from `core`, planned from `cash` or a
+     * fresh balances read as `signEntry` plans them. Neither names a quote, so
+     * once one is chosen `signEntry({ quote, prepared })` signs only the quote
+     * and the accept can go straight out.
+     */
+    async function prepareEntryFunding(request) {
+        const { signer, account, chain, scope } = await recordScope();
+        const stake = BigInt(request.stake);
+        const core = request.core === undefined || request.core === null ? request.core : BigInt(request.core);
+        const plan = planEntry(stake, core, request.cash ?? await readSpendableCash(request.signal));
+        const [bridge, funding] = await Promise.all([
+            signBridge(signer, chain, plan.bridge, request),
+            plan.wallet > 0n ? depositAuthorization(chain, account, plan.wallet) : undefined,
+        ]);
+        return { stake: stake.toString(), ...scope, ...(funding === undefined ? {} : { funding }), ...(bridge === undefined ? {} : { bridge }) };
+    }
     async function signEntryWith(request, funding) {
-        const { quote, cash } = request;
+        const { quote, cash, prepared } = request;
         const { signer, vaultSigner, account, chain, scope } = await recordScope();
         if (quote.entry.taker.toLowerCase() !== account)
             throw new Error("the quote is for another taker");
+        const record = (taker_signature, fundingCommand, bridge) => ({
+            kind: "ENTRY", version: 2, acceptanceId: request.acceptanceId ?? uuidv7(), rfqId: quote.rfq_id, quoteId: quote.quote_id, ...scope, expiry: quote.entry.expiry,
+            command: { taker_signature, ...(fundingCommand === undefined ? {} : { funding: fundingCommand }) },
+            ...(bridge === undefined ? {} : { bridge }),
+        });
+        if (prepared !== undefined) {
+            if (prepared.stake !== quote.entry.stake || prepared.account !== scope.account || prepared.chainId !== scope.chainId || prepared.vault !== scope.vault) {
+                throw new Error("the prepared funding is for another stake, account or deployment");
+            }
+            return record(await vaultSigner.signTypedData(takerAcceptTypedData(chain, quote.entry)), prepared.funding, prepared.bridge);
+        }
         const stake = BigInt(quote.entry.stake);
         const core = request.core === undefined || request.core === null ? request.core : BigInt(request.core);
         // Known cash is planned before any prompt, so a plan that fails asks the wallet for nothing.
@@ -664,18 +704,11 @@ export function createTotalis(options) {
         const walletAmount = plan?.wallet ?? 0n;
         const [taker_signature, bridge, walletFunding] = await Promise.all([
             signing,
-            bridgeAmount > 0n ? signSendAsset(signer, bridgeAction(hyperliquidNetwork(chain.chain_id), bridgeAmount, {
-                ...(request.hypercoreNonce === undefined ? {} : { nonce: request.hypercoreNonce }),
-                ...(request.sourceDex === undefined ? {} : { sourceDex: request.sourceDex }),
-            })) : undefined,
+            signBridge(signer, chain, bridgeAmount, request),
             walletAmount > 0n ? depositAuthorization(chain, account, walletAmount) : undefined,
         ]);
         const fundingCommand = plan === undefined ? (funding === "none" || funding === "plan" ? undefined : funding) : walletFunding;
-        return {
-            kind: "ENTRY", version: 2, acceptanceId: request.acceptanceId ?? uuidv7(), rfqId: quote.rfq_id, quoteId: quote.quote_id, ...scope, expiry: quote.entry.expiry,
-            command: { taker_signature, ...(fundingCommand === undefined ? {} : { funding: fundingCommand }) },
-            ...(bridge === undefined ? {} : { bridge }),
-        };
+        return record(taker_signature, fundingCommand, bridge);
     }
     /**
      * Sign a Combo entry for a quote without sending it. Funding is planned
@@ -691,7 +724,8 @@ export function createTotalis(options) {
      * shows them in turn. `sourceDex: ""` bridges from perps instead of spot.
      * Persist the record, then `sendAcceptance` it; after a restart,
      * `recoverAcceptance` it. Pass `hypercoreNonce` if your app reserves
-     * Hyperliquid nonces itself.
+     * Hyperliquid nonces itself. With `prepared` (`prepareEntryFunding`), only
+     * the quote is signed, and its funding is the prepared one.
      */
     function signEntry(request) {
         return signEntryWith(request, "plan");
@@ -773,9 +807,13 @@ export function createTotalis(options) {
      * record from SDK 0.63 or older is only read. One still `PENDING_CONFIRM`
      * is read again after the maker's deadline, or every 250 ms until 2 s past
      * it while a bridge is unsent; `wait: false` returns it as it stands instead.
+     * A record marked `refused` is `NOT_ADMITTED`, read from the record alone.
      */
     async function recoverAcceptance(signed, options = {}) {
         await checkScope(signed);
+        if (signed.kind === "ENTRY" && "refused" in signed && signed.refused !== undefined) {
+            return resultOf(signed, { status: "NOT_ADMITTED", quote_id: signed.quoteId, rfq_id: signed.rfqId }, {});
+        }
         const clock = venueClock();
         const outcome = await fenceAcceptance(signed, clock, undefined, options.wait ?? true, bridgeUnsent(signed));
         return resultOf(signed, outcome, await moveBridge(signed, outcome, clock, options));
@@ -791,21 +829,30 @@ export function createTotalis(options) {
         }
     }
     /**
-     * Open a combo position: create the RFQ, take a quote from those the stream
-     * pushes, sign it (`signEntry`), hand the record to `onSigned` to persist,
-     * then `sendAcceptance`. Returns the acceptance's status (`ACCEPTED` with
+     * Open a combo position: create the RFQ, sign its funding
+     * (`prepareEntryFunding`), then take a quote from those the stream pushes,
+     * sign it (`signEntry`), hand the record to `onSigned` to persist, and
+     * `sendAcceptance` at once: the quote is chosen last, so the one signed is
+     * as fresh as the book allows. Returns the acceptance's status (`ACCEPTED` with
      * `operationId`; `FILLED` or `FAILED`, also with it, when a lost answer was
      * read after the trade settled; `DECLINED` / `TIMED_OUT` / `CANCELLED`; or
      * `NOT_ADMITTED` when a lost accept never arrived). The position opens
      * under `positionId`, the quote's ID, once `waitForOperation(operationId)`
      * resolves `COMMITTED`; pass its operation and the result's `record` to
      * `entryFailure` to name a failure. Any vault shortfall is funded from the
-     * wallet, and from `core` by bridge, unless `funding` says otherwise. An accept refused with
-     * `QUOTE_EXPIRED` or `QUOTE_REPLACED` takes and signs a fresh quote once
-     * (`onSigned` gets the new record); a second refusal is thrown.
+     * wallet, and from `core` by bridge, unless `funding` says otherwise.
+     *
+     * Makers replace their quotes as they renew them, so an accept can find its
+     * quote gone (`QUOTE_REPLACED`, `QUOTE_EXPIRED`); then `onSigned` gets the
+     * record marked `refused`. A maker can also turn its quote down (`DECLINED`)
+     * or not answer in time (`TIMED_OUT`). Either way nothing was admitted, so
+     * the best other quote paying at least `minPayout` is signed and sent,
+     * funding first, until one is taken, `refreshMs` has passed since the first
+     * quote was chosen, or `maxAttempts` accepts were sent. Then the last
+     * refusal is thrown, or the last decline or timeout returned.
      */
     async function openPosition(request) {
-        const { legs, stake, choose = bestQuote(), collectMs = defaultCollectMs, funding = "wallet", intent, quoteTimeoutMs = 20_000, signal } = request;
+        const { legs, stake, choose = bestQuote(), collectMs = defaultCollectMs, funding = "wallet", intent, quoteTimeoutMs = 20_000, refreshMs = defaultRefreshMs, maxAttempts = defaultMaxAttempts, signal } = request;
         const reading = funding === "wallet" && request.cash === undefined ? readSpendableCash(signal) : undefined;
         reading?.catch(() => undefined);
         const account = await (await requireSigner()).address();
@@ -814,20 +861,32 @@ export function createTotalis(options) {
         const wanted = { taker: account, stake: String(stake), legs: [...legs].sort((a, b) => Number(a.outcome_id) - Number(b.outcome_id)).map(({ outcome_id, side }) => ({ outcome_id, side })) };
         const entry = { stake: wanted.stake, legs: wanted.legs };
         const rfqId = await createRfq(intent === undefined ? entry : { ...entry, ...intent });
-        // Only quotes for exactly this position are offered to the chooser, and the chosen one is checked again before signing.
-        const matches = (quote) => quote.kind === "ENTRY" && quote.rfq_id === rfqId &&
+        const createdAt = performance.now();
+        let floor = request.minPayout === undefined ? undefined : BigInt(request.minPayout);
+        const refused = new Set();
+        const offered = (quote) => quote.kind === "ENTRY" && quote.rfq_id === rfqId &&
             quote.entry.taker.toLowerCase() === wanted.taker && quote.entry.stake === wanted.stake &&
-            JSON.stringify(quote.entry.legs.map(({ outcome_id, side }) => ({ outcome_id, side }))) === JSON.stringify(wanted.legs);
-        const take = (refused) => signedOrCancel(rfqId, async () => {
-            const offered = (quote) => matches(quote) && quote.quote_id !== refused;
-            const selected = await awaitOffer(rfqId, offered, choose, collectMs, quoteTimeoutMs, signal);
+            JSON.stringify(quote.entry.legs.map(({ outcome_id, side }) => ({ outcome_id, side }))) === JSON.stringify(wanted.legs) &&
+            !refused.has(quote.quote_id) && (floor === undefined || BigInt(quote.entry.payout) >= floor);
+        // Counted from the first choice, not from its signature, so a slow wallet cannot stretch the window.
+        let refreshUntil;
+        const take = () => signedOrCancel(rfqId, async () => {
+            const prepared = funding === "wallet"
+                ? await prepareEntryFunding({ stake: wanted.stake, core: request.core, cash: request.cash ?? await (refreshUntil === undefined ? reading : readSpendableCash(signal)), sourceDex: request.sourceDex, signal })
+                : undefined;
+            const selected = refreshUntil === undefined
+                ? await awaitOffer(rfqId, offered, choose, Math.max(0, Math.round(collectMs - (performance.now() - createdAt))), quoteTimeoutMs, signal)
+                : await awaitOffer(rfqId, offered, choose, 0, Math.max(0, Math.round(refreshUntil - performance.now())), signal);
+            refreshUntil ??= performance.now() + refreshMs;
             if (!offered(selected))
                 throw new Error("the chosen quote is not for the requested position");
-            const signed = await signEntryWith({ quote: selected, core: request.core, cash: request.cash ?? await reading, sourceDex: request.sourceDex }, funding === "wallet" ? "plan" : funding);
+            const signed = await signEntryWith({ quote: selected, prepared }, funding === "wallet" ? "plan" : funding);
             await request.onSigned?.(signed);
             return { selected, signed };
         });
         let { selected, signed } = await take();
+        floor ??= BigInt(selected.entry.payout);
+        const refreshEnds = refreshUntil ?? 0;
         let record = signed;
         const send = () => sendAcceptance(signed, {
             ...(request.transport === undefined ? {} : { transport: request.transport }),
@@ -837,18 +896,56 @@ export function createTotalis(options) {
                 await request.onSigned?.(next);
             },
         });
-        let result;
-        try {
-            result = await send();
-        }
-        catch (error) {
-            if (!(error instanceof ApiError) || error.code !== "QUOTE_EXPIRED" && error.code !== "QUOTE_REPLACED")
-                throw error;
-            // The quote went away before the accept (sendAcceptance discarded its bridge): sign a fresh one, once. No fresh quote in time is still that refusal.
-            ({ selected, signed } = await take(signed.quoteId).catch((retried) => Promise.reject(retried instanceof Error && retried.name === "TimeoutError" ? error : retried)));
-            record = signed;
-            result = await send();
-        }
+        const settle = async () => {
+            for (let attempt = 1;; attempt += 1) {
+                // The maker turned the quote down, or never answered: nothing was admitted and the RFQ stays open.
+                let lost;
+                try {
+                    lost = await send();
+                    if (!passedOn.has(lost.status))
+                        return lost;
+                }
+                catch (error) {
+                    if (!(error instanceof ApiError) || !refreshCodes.has(error.code))
+                        throw error;
+                    // Refused outright, so nothing was admitted and sendAcceptance discarded any bridge.
+                    lost = error;
+                    record = { ...record, refused: error.code };
+                    await request.onSigned?.(record);
+                }
+                refused.add(signed.quoteId);
+                const last = record;
+                const end = async () => {
+                    if (record !== last) {
+                        record = last;
+                        await request.onSigned?.(last);
+                    }
+                    if (lost instanceof ApiError)
+                        throw lost;
+                    return lost;
+                };
+                if (attempt >= maxAttempts || performance.now() >= refreshEnds)
+                    return end();
+                let next;
+                try {
+                    next = await take();
+                }
+                catch (retried) {
+                    // No fresh quote at or above the floor in time leaves this outcome standing.
+                    if (retried instanceof Error && retried.name === "TimeoutError")
+                        return end();
+                    throw retried;
+                }
+                // Signing and persisting can outlast the window: a record signed too late is never sent, and the last sent one is persisted again.
+                if (performance.now() >= refreshEnds) {
+                    record = next.signed;
+                    return end();
+                }
+                ({ selected, signed } = next);
+                record = signed;
+            }
+        };
+        const result = await settle();
         const { bridged: _bridged, ...settled } = result;
         return {
             ...settled,
@@ -1265,6 +1362,7 @@ export function createTotalis(options) {
         spendableCash: readSpendableCash,
         openPosition,
         cashOut,
+        prepareEntryFunding,
         signEntry,
         signCashout,
         sendAcceptance,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totalis/hip4-client",
-  "version": "0.76.0",
+  "version": "0.77.0",
   "description": "Totalis HIP-4 SDK: typed HTTP clients, signer-agnostic typed data, a retrying request layer, pagination, a realtime stream and taker/maker flows",
   "type": "module",
   "files": [