@symmio/trading-core 1.1.0 → 2.0.0

package/dist/symmio-contracts/symmio/actions/get-pending-quotes.js

@@ -0,0 +1,29 @@
+import { symmioAbi as e } from "../../abi/v0.8.5/symmio.js";
+import { getPartyAPendingQuotes as t } from "./get-party-a-pending-quotes.js";
+//#region src/symmio-contracts/symmio/actions/get-pending-quotes.ts
+var n = 10;
+async function r(r, i) {
+	let { chainId: a, partyA: o, batchSize: s = n } = i, c = await t(r, {
+		chainId: a,
+		partyA: o
+	});
+	if (c.length === 0) return [];
+	let { addresses: l } = r.getChainConfig(a), u = r.getClient({ chainId: a }), d = [];
+	for (let t = 0; t < c.length; t += s) {
+		let n = c.slice(t, t + s), r = await u.multicall({
+			allowFailure: !1,
+			contracts: n.map((t) => ({
+				address: l.symmioAddress,
+				abi: e,
+				functionName: "getQuote",
+				args: [t]
+			}))
+		});
+		for (let e of r) e.id !== 0n && d.push(e);
+	}
+	return d;
+}
+//#endregion
+export { r as getPendingQuotes };
+
+//# sourceMappingURL=get-pending-quotes.js.map

package/dist/symmio-contracts/symmio/actions/get-pending-quotes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-pending-quotes.js","names":[],"sources":["../../../../src/symmio-contracts/symmio/actions/get-pending-quotes.ts"],"sourcesContent":["import type { Address } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport type { ChainIdParameter, Compute } from \"../../../shared/types/properties\";\nimport { symmioAbi } from \"../../abi/v0.8.5/symmio\";\nimport type { Quote } from \"../types\";\nimport { getPartyAPendingQuotes } from \"./get-party-a-pending-quotes\";\n\n/** Default number of `getQuote` reads per multicall batch. */\nconst DEFAULT_BATCH_SIZE = 10;\n\n/**\n * Parameters for {@link getPendingQuotes}.\n */\nexport type GetPendingQuotesParameters = Compute<\n  ChainIdParameter & {\n    /** PartyA (virtual account, or the sub-account for cross-margin) whose resting limit orders to read. */\n    partyA: Address;\n    /** How many `getQuote` reads to bundle per multicall. @default 10 */\n    batchSize?: number;\n  }\n>;\n\n/** Return type of {@link getPendingQuotes}: the hydrated resting limit-order {@link Quote} structs. */\nexport type GetPendingQuotesReturnType = Quote[];\n\n/**\n * Read a partyA's resting **LIMIT orders** as **full {@link Quote} structs**. A\n * pending quote is one that has not opened yet — in practice a limit order\n * waiting to fill (`PENDING` / `LOCKED` / `CANCEL_PENDING`), since a market order\n * never rests here.\n *\n * The contract exposes only the pending quote ids ({@link getPartyAPendingQuotes})\n * and a per-id `getQuote`, so this hydrates them: fetch the ids, then read the\n * quotes with `getQuote` bundled into **multicalls of `batchSize`** (default 10)\n * to keep each RPC round-trip small. Zeroed (`id === 0n`) entries are dropped.\n *\n * @param config - The SDK config.\n * @param parameters - PartyA, optional chain id and batch size.\n * @returns The hydrated limit orders (empty when partyA has none).\n * @throws {SymmError} when the chain is not supported.\n * @throws Viem's `ContractFunctionExecutionError` / multicall errors for on-chain failures.\n *\n * @example\n * ```ts\n * const limitOrders = await getPendingQuotes(config, { partyA: \"0xsub…\" });\n * ```\n */\nexport async function getPendingQuotes(\n  config: Config,\n  parameters: GetPendingQuotesParameters,\n): Promise<GetPendingQuotesReturnType> {\n  const { chainId, partyA, batchSize = DEFAULT_BATCH_SIZE } = parameters;\n\n  const ids = await getPartyAPendingQuotes(config, { chainId, partyA });\n  if (ids.length === 0) return [];\n\n  const { addresses } = config.getChainConfig(chainId);\n  const client = config.getClient({ chainId });\n\n  const quotes: Quote[] = [];\n  for (let start = 0; start < ids.length; start += batchSize) {\n    const batch = ids.slice(start, start + batchSize);\n    const results = await client.multicall({\n      allowFailure: false,\n      contracts: batch.map(\n        (quoteId) =>\n          ({\n            address: addresses.symmioAddress,\n            abi: symmioAbi,\n            functionName: \"getQuote\",\n            args: [quoteId],\n          }) as const,\n      ),\n    });\n    for (const quote of results) {\n      // `getQuote` returns a zeroed struct for an unknown id (ids are 1-based).\n      if (quote.id !== 0n) quotes.push(quote);\n    }\n  }\n\n  return quotes;\n}\n"],"mappings":";;;AAQA,IAAM,IAAqB;AAuC3B,eAAsB,EACpB,GACA,GACqC;CACrC,IAAM,EAAE,YAAS,WAAQ,eAAY,MAAuB,GAEtD,IAAM,MAAM,EAAuB,GAAQ;EAAE;EAAS;CAAO,CAAC;CACpE,IAAI,EAAI,WAAW,GAAG,OAAO,CAAC;CAE9B,IAAM,EAAE,iBAAc,EAAO,eAAe,CAAO,GAC7C,IAAS,EAAO,UAAU,EAAE,WAAQ,CAAC,GAErC,IAAkB,CAAC;CACzB,KAAK,IAAI,IAAQ,GAAG,IAAQ,EAAI,QAAQ,KAAS,GAAW;EAC1D,IAAM,IAAQ,EAAI,MAAM,GAAO,IAAQ,CAAS,GAC1C,IAAU,MAAM,EAAO,UAAU;GACrC,cAAc;GACd,WAAW,EAAM,KACd,OACE;IACC,SAAS,EAAU;IACnB,KAAK;IACL,cAAc;IACd,MAAM,CAAC,CAAO;GAChB,EACJ;EACF,CAAC;EACD,KAAK,IAAM,KAAS,GAElB,AAAI,EAAM,OAAO,MAAI,EAAO,KAAK,CAAK;CAE1C;CAEA,OAAO;AACT"}

package/dist/symmio-contracts/symmio/actions/request-to-cancel-close-request.d.ts

@@ -0,0 +1,41 @@
+import { Address, Hash } from 'viem';
+import { Config } from '../../../core/config/index.js';
+import { Compute, WriteContractParameter } from '../../../shared/types/properties.js';
+/**
+ * Parameters for {@link requestToCancelCloseRequest}.
+ */
+export type RequestToCancelCloseRequestParameters = Compute<WriteContractParameter & {
+    /**
+     * The subaccount (partyA) that owns the quote. The call is routed through the
+     * AccountLayer `_call` proxy so the core sees this subaccount as the caller;
+     * the connected wallet must be its on-chain `owner`.
+     */
+    account: Address;
+    /** The `CLOSE_PENDING` quote id whose close request to cancel. */
+    quoteId: bigint;
+}>;
+/** Return type of {@link requestToCancelCloseRequest}: the submitted transaction hash. */
+export type RequestToCancelCloseRequestReturnType = Hash;
+/**
+ * Request cancellation of a pending **close** (`requestToCancelCloseRequest`) —
+ * the way a partyA backs out of a resting close (e.g. a limit close) while the
+ * quote is `CLOSE_PENDING`.
+ *
+ * The core `requestToCancelCloseRequest(quoteId)` must be attributed to the
+ * sub-account, so it is encoded and routed through `AccountLayer._call(account, …)`;
+ * the connected wallet must be the sub-account's `owner`. If partyB accepts, the
+ * quote returns to `OPENED`; if partyB stalls, it enters `CANCEL_CLOSE_PENDING`
+ * until the force-cancel-close cooldown elapses (see `forceCancelCloseRequest`).
+ *
+ * @param config - The SDK config (must have a `getWalletClient` resolver).
+ * @param parameters - The owning subaccount, the quote id, optional `from` / pre-flight / chain id.
+ * @returns The submitted transaction hash.
+ * @throws {SymmError} when the chain is unsupported or no wallet client is available.
+ *
+ * @example
+ * ```ts
+ * const hash = await requestToCancelCloseRequest(config, { account: "0xsub…", quoteId: 42n });
+ * ```
+ */
+export declare function requestToCancelCloseRequest(config: Config, parameters: RequestToCancelCloseRequestParameters): Promise<RequestToCancelCloseRequestReturnType>;
+//# sourceMappingURL=request-to-cancel-close-request.d.ts.map

package/dist/symmio-contracts/symmio/actions/request-to-cancel-close-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-to-cancel-close-request.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/symmio/actions/request-to-cancel-close-request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,MAAM,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAIxF;;GAEG;AACH,MAAM,MAAM,qCAAqC,GAAG,OAAO,CACzD,sBAAsB,GAAG;IACvB;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;CACjB,CACF,CAAC;AAEF,0FAA0F;AAC1F,MAAM,MAAM,qCAAqC,GAAG,IAAI,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,qCAAqC,GAChD,OAAO,CAAC,qCAAqC,CAAC,CAgBhD"}

package/dist/symmio-contracts/symmio/actions/request-to-cancel-close-request.js

@@ -0,0 +1,22 @@
+import { symmioAbi as e } from "../../abi/v0.8.5/symmio.js";
+import { callAsSubAccount as t } from "../internal/call-as-sub-account.js";
+import { encodeFunctionData as n } from "viem";
+//#region src/symmio-contracts/symmio/actions/request-to-cancel-close-request.ts
+async function r(r, i) {
+	let { chainId: a, account: o, quoteId: s } = i;
+	return t(r, {
+		account: o,
+		data: n({
+			abi: e,
+			functionName: "requestToCancelCloseRequest",
+			args: [s]
+		}),
+		chainId: a,
+		from: i.from,
+		simulateBeforeWrite: i.simulateBeforeWrite
+	});
+}
+//#endregion
+export { r as requestToCancelCloseRequest };
+
+//# sourceMappingURL=request-to-cancel-close-request.js.map

package/dist/symmio-contracts/symmio/actions/request-to-cancel-close-request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-to-cancel-close-request.js","names":[],"sources":["../../../../src/symmio-contracts/symmio/actions/request-to-cancel-close-request.ts"],"sourcesContent":["import { encodeFunctionData, type Address, type Hash } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport type { Compute, WriteContractParameter } from \"../../../shared/types/properties\";\nimport { symmioAbi } from \"../../abi/v0.8.5/symmio\";\nimport { callAsSubAccount } from \"../internal/call-as-sub-account\";\n\n/**\n * Parameters for {@link requestToCancelCloseRequest}.\n */\nexport type RequestToCancelCloseRequestParameters = Compute<\n  WriteContractParameter & {\n    /**\n     * The subaccount (partyA) that owns the quote. The call is routed through the\n     * AccountLayer `_call` proxy so the core sees this subaccount as the caller;\n     * the connected wallet must be its on-chain `owner`.\n     */\n    account: Address;\n    /** The `CLOSE_PENDING` quote id whose close request to cancel. */\n    quoteId: bigint;\n  }\n>;\n\n/** Return type of {@link requestToCancelCloseRequest}: the submitted transaction hash. */\nexport type RequestToCancelCloseRequestReturnType = Hash;\n\n/**\n * Request cancellation of a pending **close** (`requestToCancelCloseRequest`) —\n * the way a partyA backs out of a resting close (e.g. a limit close) while the\n * quote is `CLOSE_PENDING`.\n *\n * The core `requestToCancelCloseRequest(quoteId)` must be attributed to the\n * sub-account, so it is encoded and routed through `AccountLayer._call(account, …)`;\n * the connected wallet must be the sub-account's `owner`. If partyB accepts, the\n * quote returns to `OPENED`; if partyB stalls, it enters `CANCEL_CLOSE_PENDING`\n * until the force-cancel-close cooldown elapses (see `forceCancelCloseRequest`).\n *\n * @param config - The SDK config (must have a `getWalletClient` resolver).\n * @param parameters - The owning subaccount, the quote id, optional `from` / pre-flight / chain id.\n * @returns The submitted transaction hash.\n * @throws {SymmError} when the chain is unsupported or no wallet client is available.\n *\n * @example\n * ```ts\n * const hash = await requestToCancelCloseRequest(config, { account: \"0xsub…\", quoteId: 42n });\n * ```\n */\nexport async function requestToCancelCloseRequest(\n  config: Config,\n  parameters: RequestToCancelCloseRequestParameters,\n): Promise<RequestToCancelCloseRequestReturnType> {\n  const { chainId, account, quoteId } = parameters;\n\n  const data = encodeFunctionData({\n    abi: symmioAbi,\n    functionName: \"requestToCancelCloseRequest\",\n    args: [quoteId],\n  });\n\n  return callAsSubAccount(config, {\n    account,\n    data,\n    chainId,\n    from: parameters.from,\n    simulateBeforeWrite: parameters.simulateBeforeWrite,\n  });\n}\n"],"mappings":";;;;AA8CA,eAAsB,EACpB,GACA,GACgD;CAChD,IAAM,EAAE,YAAS,YAAS,eAAY;CAQtC,OAAO,EAAiB,GAAQ;EAC9B;EACA,MARW,EAAmB;GAC9B,KAAK;GACL,cAAc;GACd,MAAM,CAAC,CAAO;EAChB,CAIE;EACA;EACA,MAAM,EAAW;EACjB,qBAAqB,EAAW;CAClC,CAAC;AACH"}

package/dist/symmio-contracts/symmio/actions/request-to-cancel-quote.d.ts

@@ -0,0 +1,39 @@
+import { Address, Hash } from 'viem';
+import { Config } from '../../../core/config/index.js';
+import { Compute, WriteContractParameter } from '../../../shared/types/properties.js';
+/**
+ * Parameters for {@link requestToCancelQuote}.
+ */
+export type RequestToCancelQuoteParameters = Compute<WriteContractParameter & {
+    /**
+     * The subaccount (partyA) that owns the quote. The call is routed through the
+     * AccountLayer `_call` proxy so the core sees this subaccount as the caller;
+     * the connected wallet must be its on-chain `owner`.
+     */
+    account: Address;
+    /** The pending quote id to cancel — e.g. a resting LIMIT order. */
+    quoteId: bigint;
+}>;
+/** Return type of {@link requestToCancelQuote}: the submitted transaction hash. */
+export type RequestToCancelQuoteReturnType = Hash;
+/**
+ * Request cancellation of a pending quote (`requestToCancelQuote`) — the way a
+ * partyA cancels a resting **LIMIT order** (or any not-yet-opened quote).
+ *
+ * The core `requestToCancelQuote(quoteId)` must be attributed to the sub-account,
+ * so it is encoded and routed through `AccountLayer._call(account, …)`; the
+ * connected wallet must be the sub-account's `owner`. A `PENDING` quote cancels
+ * immediately; a `LOCKED` one enters `CANCEL_PENDING` until partyB acknowledges.
+ *
+ * @param config - The SDK config (must have a `getWalletClient` resolver).
+ * @param parameters - The owning subaccount, the quote id, optional `from` / pre-flight / chain id.
+ * @returns The submitted transaction hash.
+ * @throws {SymmError} when the chain is unsupported or no wallet client is available.
+ *
+ * @example
+ * ```ts
+ * const hash = await requestToCancelQuote(config, { account: "0xsub…", quoteId: 42n });
+ * ```
+ */
+export declare function requestToCancelQuote(config: Config, parameters: RequestToCancelQuoteParameters): Promise<RequestToCancelQuoteReturnType>;
+//# sourceMappingURL=request-to-cancel-quote.d.ts.map

package/dist/symmio-contracts/symmio/actions/request-to-cancel-quote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-to-cancel-quote.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/symmio/actions/request-to-cancel-quote.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,MAAM,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAIxF;;GAEG;AACH,MAAM,MAAM,8BAA8B,GAAG,OAAO,CAClD,sBAAsB,GAAG;IACvB;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,mEAAmE;IACnE,OAAO,EAAE,MAAM,CAAC;CACjB,CACF,CAAC;AAEF,mFAAmF;AACnF,MAAM,MAAM,8BAA8B,GAAG,IAAI,CAAC;AAElD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,8BAA8B,GACzC,OAAO,CAAC,8BAA8B,CAAC,CAgBzC"}

package/dist/symmio-contracts/symmio/actions/request-to-cancel-quote.js

@@ -0,0 +1,22 @@
+import { symmioAbi as e } from "../../abi/v0.8.5/symmio.js";
+import { callAsSubAccount as t } from "../internal/call-as-sub-account.js";
+import { encodeFunctionData as n } from "viem";
+//#region src/symmio-contracts/symmio/actions/request-to-cancel-quote.ts
+async function r(r, i) {
+	let { chainId: a, account: o, quoteId: s } = i;
+	return t(r, {
+		account: o,
+		data: n({
+			abi: e,
+			functionName: "requestToCancelQuote",
+			args: [s]
+		}),
+		chainId: a,
+		from: i.from,
+		simulateBeforeWrite: i.simulateBeforeWrite
+	});
+}
+//#endregion
+export { r as requestToCancelQuote };
+
+//# sourceMappingURL=request-to-cancel-quote.js.map

package/dist/symmio-contracts/symmio/actions/request-to-cancel-quote.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-to-cancel-quote.js","names":[],"sources":["../../../../src/symmio-contracts/symmio/actions/request-to-cancel-quote.ts"],"sourcesContent":["import { encodeFunctionData, type Address, type Hash } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport type { Compute, WriteContractParameter } from \"../../../shared/types/properties\";\nimport { symmioAbi } from \"../../abi/v0.8.5/symmio\";\nimport { callAsSubAccount } from \"../internal/call-as-sub-account\";\n\n/**\n * Parameters for {@link requestToCancelQuote}.\n */\nexport type RequestToCancelQuoteParameters = Compute<\n  WriteContractParameter & {\n    /**\n     * The subaccount (partyA) that owns the quote. The call is routed through the\n     * AccountLayer `_call` proxy so the core sees this subaccount as the caller;\n     * the connected wallet must be its on-chain `owner`.\n     */\n    account: Address;\n    /** The pending quote id to cancel — e.g. a resting LIMIT order. */\n    quoteId: bigint;\n  }\n>;\n\n/** Return type of {@link requestToCancelQuote}: the submitted transaction hash. */\nexport type RequestToCancelQuoteReturnType = Hash;\n\n/**\n * Request cancellation of a pending quote (`requestToCancelQuote`) — the way a\n * partyA cancels a resting **LIMIT order** (or any not-yet-opened quote).\n *\n * The core `requestToCancelQuote(quoteId)` must be attributed to the sub-account,\n * so it is encoded and routed through `AccountLayer._call(account, …)`; the\n * connected wallet must be the sub-account's `owner`. A `PENDING` quote cancels\n * immediately; a `LOCKED` one enters `CANCEL_PENDING` until partyB acknowledges.\n *\n * @param config - The SDK config (must have a `getWalletClient` resolver).\n * @param parameters - The owning subaccount, the quote id, optional `from` / pre-flight / chain id.\n * @returns The submitted transaction hash.\n * @throws {SymmError} when the chain is unsupported or no wallet client is available.\n *\n * @example\n * ```ts\n * const hash = await requestToCancelQuote(config, { account: \"0xsub…\", quoteId: 42n });\n * ```\n */\nexport async function requestToCancelQuote(\n  config: Config,\n  parameters: RequestToCancelQuoteParameters,\n): Promise<RequestToCancelQuoteReturnType> {\n  const { chainId, account, quoteId } = parameters;\n\n  const data = encodeFunctionData({\n    abi: symmioAbi,\n    functionName: \"requestToCancelQuote\",\n    args: [quoteId],\n  });\n\n  return callAsSubAccount(config, {\n    account,\n    data,\n    chainId,\n    from: parameters.from,\n    simulateBeforeWrite: parameters.simulateBeforeWrite,\n  });\n}\n"],"mappings":";;;;AA4CA,eAAsB,EACpB,GACA,GACyC;CACzC,IAAM,EAAE,YAAS,YAAS,eAAY;CAQtC,OAAO,EAAiB,GAAQ;EAC9B;EACA,MARW,EAAmB;GAC9B,KAAK;GACL,cAAc;GACd,MAAM,CAAC,CAAO;EAChB,CAIE;EACA;EACA,MAAM,EAAW;EACjB,qBAAqB,EAAW;CAClC,CAAC;AACH"}

package/dist/symmio-contracts/symmio/actions/simulate-deallocate-and-initiate-withdraw.d.ts

@@ -0,0 +1,33 @@
+import { Config } from '../../../core/config/index.js';
+import { Compute, FromParameter } from '../../../shared/types/properties.js';
+import { SimulateCallAsSubAccountReturnType } from '../internal/simulate-call-as-sub-account.js';
+import { DeallocateAndInitiateWithdrawParameters } from './deallocate-and-initiate-withdraw.js';
+/**
+ * Parameters for {@link simulateDeallocateAndInitiateWithdraw}: the write's
+ * parameters plus an optional `from` (the address the dry-run runs as).
+ */
+export type SimulateDeallocateAndInitiateWithdrawParameters = Compute<DeallocateAndInitiateWithdrawParameters & FromParameter>;
+/**
+ * Return type of {@link simulateDeallocateAndInitiateWithdraw}: viem's
+ * `{ request, result }` for the routed AccountLayer `_call` (see
+ * {@link SimulateCallAsSubAccountReturnType}).
+ */
+export type SimulateDeallocateAndInitiateWithdrawReturnType = SimulateCallAsSubAccountReturnType;
+/**
+ * Dry-run {@link deallocateAndInitiateWithdraw} without sending a transaction.
+ * Encodes the same `deallocate` + `initiateWithdraw` calldatas as the write and
+ * dry-runs the batched `AccountLayer._call(account, [deallocateData, withdrawData])`
+ * through the public client — a faithful simulation of exactly what would be
+ * broadcast. A would-be revert on either leg (the deallocate debounce, an
+ * insolvent result, a stale `upnlSig`, ...) throws viem's call error.
+ *
+ * @param config - The SDK config.
+ * @param parameters - Subaccount, amount, receiver parts, optional speed-up /
+ *   provider data, optional Muon `upnlSig` (fetched automatically via
+ *   {@link getDeallocateUpnlSig} when omitted), optional `from`, optional chain id.
+ * @returns viem's `{ request, result }` for the routed `_call`.
+ * @throws {SymmError} when the chain is unsupported.
+ * @throws Viem's call errors when the routed call would revert.
+ */
+export declare function simulateDeallocateAndInitiateWithdraw(config: Config, parameters: SimulateDeallocateAndInitiateWithdrawParameters): Promise<SimulateDeallocateAndInitiateWithdrawReturnType>;
+//# sourceMappingURL=simulate-deallocate-and-initiate-withdraw.d.ts.map

package/dist/symmio-contracts/symmio/actions/simulate-deallocate-and-initiate-withdraw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulate-deallocate-and-initiate-withdraw.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/symmio/actions/simulate-deallocate-and-initiate-withdraw.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAE/E,OAAO,EAEL,KAAK,kCAAkC,EACxC,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,uCAAuC,EAAE,MAAM,oCAAoC,CAAC;AAElG;;;GAGG;AACH,MAAM,MAAM,+CAA+C,GAAG,OAAO,CACnE,uCAAuC,GAAG,aAAa,CACxD,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,+CAA+C,GAAG,kCAAkC,CAAC;AAEjG;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,qCAAqC,CACzD,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,+CAA+C,GAC1D,OAAO,CAAC,+CAA+C,CAAC,CAkB1D"}

package/dist/symmio-contracts/symmio/actions/simulate-deallocate-and-initiate-withdraw.js

@@ -0,0 +1,33 @@
+import { symmioAbi as e } from "../../abi/v0.8.5/symmio.js";
+import { simulateCallAsSubAccount as t } from "../internal/simulate-call-as-sub-account.js";
+import { getDeallocateUpnlSig as n } from "../../../muon/deallocate-upnl-sig/get-deallocate-upnl-sig.js";
+import { encodeFunctionData as r } from "viem";
+//#region src/symmio-contracts/symmio/actions/simulate-deallocate-and-initiate-withdraw.ts
+async function i(i, a) {
+	let { chainId: o, account: s, amount: c, parts: l, speedUp: u = !1, providerData: d = "0x", from: f } = a;
+	return t(i, {
+		account: s,
+		data: [r({
+			abi: e,
+			functionName: "deallocate",
+			args: [c, a.upnlSig ?? await n(i, {
+				virtualAccount: s,
+				chainId: o
+			})]
+		}), r({
+			abi: e,
+			functionName: "initiateWithdraw",
+			args: [
+				l,
+				u,
+				d
+			]
+		})],
+		from: f,
+		chainId: o
+	});
+}
+//#endregion
+export { i as simulateDeallocateAndInitiateWithdraw };
+
+//# sourceMappingURL=simulate-deallocate-and-initiate-withdraw.js.map

package/dist/symmio-contracts/symmio/actions/simulate-deallocate-and-initiate-withdraw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulate-deallocate-and-initiate-withdraw.js","names":[],"sources":["../../../../src/symmio-contracts/symmio/actions/simulate-deallocate-and-initiate-withdraw.ts"],"sourcesContent":["import { encodeFunctionData } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport { getDeallocateUpnlSig } from \"../../../muon/deallocate-upnl-sig/get-deallocate-upnl-sig\";\nimport type { Compute, FromParameter } from \"../../../shared/types/properties\";\nimport { symmioAbi } from \"../../abi/v0.8.5/symmio\";\nimport {\n  simulateCallAsSubAccount,\n  type SimulateCallAsSubAccountReturnType,\n} from \"../internal/simulate-call-as-sub-account\";\nimport type { DeallocateAndInitiateWithdrawParameters } from \"./deallocate-and-initiate-withdraw\";\n\n/**\n * Parameters for {@link simulateDeallocateAndInitiateWithdraw}: the write's\n * parameters plus an optional `from` (the address the dry-run runs as).\n */\nexport type SimulateDeallocateAndInitiateWithdrawParameters = Compute<\n  DeallocateAndInitiateWithdrawParameters & FromParameter\n>;\n\n/**\n * Return type of {@link simulateDeallocateAndInitiateWithdraw}: viem's\n * `{ request, result }` for the routed AccountLayer `_call` (see\n * {@link SimulateCallAsSubAccountReturnType}).\n */\nexport type SimulateDeallocateAndInitiateWithdrawReturnType = SimulateCallAsSubAccountReturnType;\n\n/**\n * Dry-run {@link deallocateAndInitiateWithdraw} without sending a transaction.\n * Encodes the same `deallocate` + `initiateWithdraw` calldatas as the write and\n * dry-runs the batched `AccountLayer._call(account, [deallocateData, withdrawData])`\n * through the public client — a faithful simulation of exactly what would be\n * broadcast. A would-be revert on either leg (the deallocate debounce, an\n * insolvent result, a stale `upnlSig`, ...) throws viem's call error.\n *\n * @param config - The SDK config.\n * @param parameters - Subaccount, amount, receiver parts, optional speed-up /\n *   provider data, optional Muon `upnlSig` (fetched automatically via\n *   {@link getDeallocateUpnlSig} when omitted), optional `from`, optional chain id.\n * @returns viem's `{ request, result }` for the routed `_call`.\n * @throws {SymmError} when the chain is unsupported.\n * @throws Viem's call errors when the routed call would revert.\n */\nexport async function simulateDeallocateAndInitiateWithdraw(\n  config: Config,\n  parameters: SimulateDeallocateAndInitiateWithdrawParameters,\n): Promise<SimulateDeallocateAndInitiateWithdrawReturnType> {\n  const { chainId, account, amount, parts, speedUp = false, providerData = \"0x\", from } = parameters;\n\n  const upnlSig = parameters.upnlSig ?? (await getDeallocateUpnlSig(config, { virtualAccount: account, chainId }));\n\n  const deallocateData = encodeFunctionData({\n    abi: symmioAbi,\n    functionName: \"deallocate\",\n    args: [amount, upnlSig],\n  });\n\n  const withdrawData = encodeFunctionData({\n    abi: symmioAbi,\n    functionName: \"initiateWithdraw\",\n    args: [parts, speedUp, providerData],\n  });\n\n  return simulateCallAsSubAccount(config, { account, data: [deallocateData, withdrawData], from, chainId });\n}\n"],"mappings":";;;;;AA0CA,eAAsB,EACpB,GACA,GAC0D;CAC1D,IAAM,EAAE,YAAS,YAAS,WAAQ,UAAO,aAAU,IAAO,kBAAe,MAAM,YAAS;CAgBxF,OAAO,EAAyB,GAAQ;EAAE;EAAS,MAAM,CAZlC,EAAmB;GACxC,KAAK;GACL,cAAc;GACd,MAAM,CAAC,GALO,EAAW,WAAY,MAAM,EAAqB,GAAQ;IAAE,gBAAgB;IAAS;GAAQ,CAAC,CAKtF;EACxB,CAQ0D,GANrC,EAAmB;GACtC,KAAK;GACL,cAAc;GACd,MAAM;IAAC;IAAO;IAAS;GAAY;EACrC,CAE0E,CAAY;EAAG;EAAM;CAAQ,CAAC;AAC1G"}

package/dist/symmio-contracts/symmio/actions/simulate-deallocate.d.ts

@@ -19,7 +19,8 @@ export type SimulateDeallocateReturnType = SimulateCallAsSubAccountReturnType;
  * an insolvent result, or a stale `upnlSig`) throws viem's call error.
  *
  * @param config - The SDK config.
- * @param parameters - Subaccount, amount, Muon `upnlSig`, optional `from`, optional chain id.
+ * @param parameters - Subaccount, amount, optional Muon `upnlSig` (fetched
+ *   automatically via {@link getDeallocateUpnlSig} when omitted), optional `from`, optional chain id.
  * @returns viem's `{ request, result }` for the routed `_call`.
  * @throws {SymmError} when the chain is unsupported.
  * @throws Viem's call errors when the routed call would revert.

package/dist/symmio-contracts/symmio/actions/simulate-deallocate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"simulate-deallocate.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/symmio/actions/simulate-deallocate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAE/E,OAAO,EAEL,KAAK,kCAAkC,EACxC,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEzD;;;GAGG;AACH,MAAM,MAAM,4BAA4B,GAAG,OAAO,CAAC,oBAAoB,GAAG,aAAa,CAAC,CAAC;AAEzF;;;GAGG;AACH,MAAM,MAAM,4BAA4B,GAAG,kCAAkC,CAAC;AAE9E;;;;;;;;;;;GAWG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,4BAA4B,GACvC,OAAO,CAAC,4BAA4B,CAAC,CAUvC"}
+{"version":3,"file":"simulate-deallocate.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/symmio/actions/simulate-deallocate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAE/E,OAAO,EAEL,KAAK,kCAAkC,EACxC,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEzD;;;GAGG;AACH,MAAM,MAAM,4BAA4B,GAAG,OAAO,CAAC,oBAAoB,GAAG,aAAa,CAAC,CAAC;AAEzF;;;GAGG;AACH,MAAM,MAAM,4BAA4B,GAAG,kCAAkC,CAAC;AAE9E;;;;;;;;;;;;GAYG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,4BAA4B,GACvC,OAAO,CAAC,4BAA4B,CAAC,CAavC"}

package/dist/symmio-contracts/symmio/actions/simulate-deallocate.js

@@ -1,21 +1,25 @@
 import { symmioAbi as e } from "../../abi/v0.8.5/symmio.js";
 import { simulateCallAsSubAccount as t } from "../internal/simulate-call-as-sub-account.js";
-import { encodeFunctionData as n } from "viem";
+import { getDeallocateUpnlSig as n } from "../../../muon/deallocate-upnl-sig/get-deallocate-upnl-sig.js";
+import { encodeFunctionData as r } from "viem";
 //#region src/symmio-contracts/symmio/actions/simulate-deallocate.ts
-async function r(r, i) {
-	let { chainId: a, account: o, amount: s, upnlSig: c, from: l } = i;
-	return t(r, {
-		account: o,
-		data: n({
+async function i(i, a) {
+	let { chainId: o, account: s, amount: c, from: l } = a;
+	return t(i, {
+		account: s,
+		data: r({
 			abi: e,
 			functionName: "deallocate",
-			args: [s, c]
+			args: [c, a.upnlSig ?? await n(i, {
+				virtualAccount: a.account,
+				chainId: o
+			})]
 		}),
 		from: l,
-		chainId: a
+		chainId: o
 	});
 }
 //#endregion
-export { r as simulateDeallocate };
+export { i as simulateDeallocate };
 
 //# sourceMappingURL=simulate-deallocate.js.map

package/dist/symmio-contracts/symmio/actions/simulate-deallocate.js.map

@@ -1 +1 @@
-{"version":3,"file":"simulate-deallocate.js","names":[],"sources":["../../../../src/symmio-contracts/symmio/actions/simulate-deallocate.ts"],"sourcesContent":["import { encodeFunctionData } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport type { Compute, FromParameter } from \"../../../shared/types/properties\";\nimport { symmioAbi } from \"../../abi/v0.8.5/symmio\";\nimport {\n  simulateCallAsSubAccount,\n  type SimulateCallAsSubAccountReturnType,\n} from \"../internal/simulate-call-as-sub-account\";\nimport type { DeallocateParameters } from \"./deallocate\";\n\n/**\n * Parameters for {@link simulateDeallocate}: the write's parameters plus an\n * optional `from` (the address the dry-run runs as).\n */\nexport type SimulateDeallocateParameters = Compute<DeallocateParameters & FromParameter>;\n\n/**\n * Return type of {@link simulateDeallocate}: viem's `{ request, result }` for the\n * routed AccountLayer `_call` (see {@link SimulateCallAsSubAccountReturnType}).\n */\nexport type SimulateDeallocateReturnType = SimulateCallAsSubAccountReturnType;\n\n/**\n * Dry-run {@link deallocate} without sending a transaction. Encodes the same core\n * `deallocate` calldata as the write and dry-runs it through the AccountLayer\n * `_call` proxy via the public client. A would-be revert (the deallocate debounce,\n * an insolvent result, or a stale `upnlSig`) throws viem's call error.\n *\n * @param config - The SDK config.\n * @param parameters - Subaccount, amount, Muon `upnlSig`, optional `from`, optional chain id.\n * @returns viem's `{ request, result }` for the routed `_call`.\n * @throws {SymmError} when the chain is unsupported.\n * @throws Viem's call errors when the routed call would revert.\n */\nexport async function simulateDeallocate(\n  config: Config,\n  parameters: SimulateDeallocateParameters,\n): Promise<SimulateDeallocateReturnType> {\n  const { chainId, account, amount, upnlSig, from } = parameters;\n\n  const data = encodeFunctionData({\n    abi: symmioAbi,\n    functionName: \"deallocate\",\n    args: [amount, upnlSig],\n  });\n\n  return simulateCallAsSubAccount(config, { account, data, from, chainId });\n}\n"],"mappings":";;;;AAkCA,eAAsB,EACpB,GACA,GACuC;CACvC,IAAM,EAAE,YAAS,YAAS,WAAQ,YAAS,YAAS;CAQpD,OAAO,EAAyB,GAAQ;EAAE;EAAS,MANtC,EAAmB;GAC9B,KAAK;GACL,cAAc;GACd,MAAM,CAAC,GAAQ,CAAO;EACxB,CAEmD;EAAM;EAAM;CAAQ,CAAC;AAC1E"}
+{"version":3,"file":"simulate-deallocate.js","names":[],"sources":["../../../../src/symmio-contracts/symmio/actions/simulate-deallocate.ts"],"sourcesContent":["import { encodeFunctionData } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport { getDeallocateUpnlSig } from \"../../../muon/deallocate-upnl-sig/get-deallocate-upnl-sig\";\nimport type { Compute, FromParameter } from \"../../../shared/types/properties\";\nimport { symmioAbi } from \"../../abi/v0.8.5/symmio\";\nimport {\n  simulateCallAsSubAccount,\n  type SimulateCallAsSubAccountReturnType,\n} from \"../internal/simulate-call-as-sub-account\";\nimport type { DeallocateParameters } from \"./deallocate\";\n\n/**\n * Parameters for {@link simulateDeallocate}: the write's parameters plus an\n * optional `from` (the address the dry-run runs as).\n */\nexport type SimulateDeallocateParameters = Compute<DeallocateParameters & FromParameter>;\n\n/**\n * Return type of {@link simulateDeallocate}: viem's `{ request, result }` for the\n * routed AccountLayer `_call` (see {@link SimulateCallAsSubAccountReturnType}).\n */\nexport type SimulateDeallocateReturnType = SimulateCallAsSubAccountReturnType;\n\n/**\n * Dry-run {@link deallocate} without sending a transaction. Encodes the same core\n * `deallocate` calldata as the write and dry-runs it through the AccountLayer\n * `_call` proxy via the public client. A would-be revert (the deallocate debounce,\n * an insolvent result, or a stale `upnlSig`) throws viem's call error.\n *\n * @param config - The SDK config.\n * @param parameters - Subaccount, amount, optional Muon `upnlSig` (fetched\n *   automatically via {@link getDeallocateUpnlSig} when omitted), optional `from`, optional chain id.\n * @returns viem's `{ request, result }` for the routed `_call`.\n * @throws {SymmError} when the chain is unsupported.\n * @throws Viem's call errors when the routed call would revert.\n */\nexport async function simulateDeallocate(\n  config: Config,\n  parameters: SimulateDeallocateParameters,\n): Promise<SimulateDeallocateReturnType> {\n  const { chainId, account, amount, from } = parameters;\n\n  const upnlSig =\n    parameters.upnlSig ?? (await getDeallocateUpnlSig(config, { virtualAccount: parameters.account, chainId }));\n\n  const data = encodeFunctionData({\n    abi: symmioAbi,\n    functionName: \"deallocate\",\n    args: [amount, upnlSig],\n  });\n\n  return simulateCallAsSubAccount(config, { account, data, from, chainId });\n}\n"],"mappings":";;;;;AAoCA,eAAsB,EACpB,GACA,GACuC;CACvC,IAAM,EAAE,YAAS,YAAS,WAAQ,YAAS;CAW3C,OAAO,EAAyB,GAAQ;EAAE;EAAS,MANtC,EAAmB;GAC9B,KAAK;GACL,cAAc;GACd,MAAM,CAAC,GALP,EAAW,WAAY,MAAM,EAAqB,GAAQ;IAAE,gBAAgB,EAAW;IAAS;GAAQ,CAAC,CAKnF;EACxB,CAEmD;EAAM;EAAM;CAAQ,CAAC;AAC1E"}

package/dist/symmio-contracts/symmio/actions/withdraw-auto.d.ts

@@ -0,0 +1,96 @@
+import { Address, Hash, Hex } from 'viem';
+import { Config } from '../../../core/config/index.js';
+import { Compute, WriteContractParameter } from '../../../shared/types/properties.js';
+import { SingleUpnlSig, SubAccountIsolationType } from '../../account-layer/types.js';
+/**
+ * Parameters for {@link withdrawAuto}.
+ */
+export type WithdrawAutoParameters = Compute<WriteContractParameter & {
+    /**
+     * The subaccount to withdraw from. The action routes the call through the
+     * AccountLayer `_call` proxy so the core attributes it to this subaccount; the
+     * connected wallet must be its on-chain `owner`.
+     */
+    account: Address;
+    /**
+     * Amount to withdraw, in the **collateral token's decimals** (e.g. 6 for a
+     * USDC-collateralized chain). The action builds the withdraw part from this
+     * amount as-is and, on the `CUSTOM` (cross-margin) path, scales it to the
+     * 18-decimal amount the `deallocate` leg needs.
+     */
+    amount: bigint;
+    /** Destination EVM address the freed collateral is withdrawn to. */
+    receiver: Address;
+    /**
+     * Opt into the cooldown speed-up flow. Only effective for speed-up-eligible
+     * users; ignored otherwise.
+     * @default false
+     */
+    speedUp?: boolean;
+    /**
+     * Opaque provider data forwarded to express/virtual providers (e.g. a signed
+     * option). Pass `0x` for a classic withdrawal.
+     * @default "0x"
+     */
+    providerData?: Hex;
+    /**
+     * A fresh Muon uPnL (`uPnl_A`) attestation for `account`, used only by the
+     * `CUSTOM` (deallocate) path. Omit it to have the action fetch a fresh one;
+     * pass one only to reuse a signature you already fetched. Ignored on the
+     * `MARKET` / `MARKET_DIRECTION` path.
+     */
+    upnlSig?: SingleUpnlSig;
+    /**
+     * The subaccount's isolation type. Pass it to **skip the `getSubAccount` read**
+     * — the React layer already holds it (cached via `useSubAccount`), so passing it
+     * avoids a redundant RPC. Omit it and the action fetches the subaccount to
+     * resolve it.
+     */
+    isolationType?: SubAccountIsolationType;
+}>;
+/** Return type of {@link withdrawAuto}: the submitted transaction hash. */
+export type WithdrawAutoReturnType = Hash;
+/**
+ * Withdraw from a subaccount from a **minimal, collateral-decimals input** — the
+ * high-level entry point that does all the plumbing so callers pass only
+ * `{ account, amount, receiver }` and never touch isolation, parts, or scaling.
+ *
+ * The action resolves the subaccount's {@link SubAccountIsolationType} — from the
+ * passed `isolationType`, or by reading the subaccount when it is omitted — builds
+ * the classic same-chain withdraw part from `amount` (in the collateral token's
+ * decimals), scales that amount to 18 decimals for the deallocate leg, and hands
+ * off to {@link withdraw} — which dispatches on the resolved isolation:
+ *
+ * | `isolationType`                     | Balance   | What runs                             |
+ * | ----------------------------------- | --------- | ------------------------------------- |
+ * | `CUSTOM` (cross-margin)             | allocated | deallocate + initiate in one atomic tx |
+ * | `MARKET` / `MARKET_DIRECTION` (VA)  | available | initiate the withdraw request only     |
+ *
+ * @remarks
+ * Account-layer balances are `1e18`-scaled regardless of the collateral token's
+ * decimals, so the `CUSTOM` deallocate leg needs the 18-decimal amount; this action
+ * derives it as `amount * 10 ** (18 - collateralDecimals)` (assumes
+ * `collateralDecimals <= 18`). On the `CUSTOM` path it also fetches a fresh Muon
+ * `upnlSig` for the deallocate leg unless one is passed. Reach for {@link withdraw}
+ * directly when you already hold the subaccount's `isolationType` and want to skip
+ * the extra read, or need custom (multi-part / cross-chain) withdraw parts.
+ *
+ * @param config - The SDK config (must have a `getWalletClient` resolver).
+ * @param parameters - Subaccount, `amount` (collateral decimals), `receiver`,
+ *   optional speed-up / provider data, optional Muon `upnlSig`, optional chain id.
+ * @returns The submitted transaction hash. The caller waits on the receipt.
+ * @throws {SymmError} when the chain is unsupported or no wallet is available.
+ * @throws Viem's write errors (`ContractFunctionExecutionError`, ...).
+ *
+ * @example
+ * ```ts
+ * // amount in the collateral token's decimals (6-dec USDC → 1 USDC):
+ * const hash = await withdrawAuto(config, {
+ *   account: "0xsub…",
+ *   amount: 1_000000n,
+ *   receiver: "0xabc…",
+ * });
+ * ```
+ */
+export declare function withdrawAuto(config: Config, parameters: WithdrawAutoParameters): Promise<WithdrawAutoReturnType>;
+//# sourceMappingURL=withdraw-auto.d.ts.map

package/dist/symmio-contracts/symmio/actions/withdraw-auto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withdraw-auto.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/symmio/actions/withdraw-auto.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC/C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAExF,OAAO,KAAK,EAAE,aAAa,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAIxF;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,OAAO,CAC1C,sBAAsB,GAAG;IACvB;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,MAAM,EAAE,MAAM,CAAC;IACf,oEAAoE;IACpE,QAAQ,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,YAAY,CAAC,EAAE,GAAG,CAAC;IACnB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,uBAAuB,CAAC;CACzC,CACF,CAAC;AAEF,2EAA2E;AAC3E,MAAM,MAAM,sBAAsB,GAAG,IAAI,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,sBAAsB,GACjC,OAAO,CAAC,sBAAsB,CAAC,CAgCjC"}

package/dist/symmio-contracts/symmio/actions/withdraw-auto.js

@@ -0,0 +1,31 @@
+import { getSubAccount as e } from "../../account-layer/actions/get-sub-account.js";
+import { withdraw as t } from "./withdraw.js";
+import { createClassicWithdrawPart as n } from "../parts.js";
+//#region src/symmio-contracts/symmio/actions/withdraw-auto.ts
+async function r(r, i) {
+	let a = i.chainId ?? r.defaultChainId, o = i.isolationType ?? (await e(r, {
+		account: i.account,
+		chainId: a
+	})).isolationType, { addresses: s } = r.getChainConfig(a), c = n({
+		id: 0n,
+		amount: i.amount,
+		receiver: i.receiver,
+		chainId: BigInt(a)
+	}), l = i.amount * 10n ** BigInt(18 - s.collateralDecimals);
+	return t(r, {
+		account: i.account,
+		isolationType: o,
+		parts: [c],
+		amount: l,
+		speedUp: i.speedUp,
+		providerData: i.providerData,
+		upnlSig: i.upnlSig,
+		chainId: a,
+		from: i.from,
+		simulateBeforeWrite: i.simulateBeforeWrite
+	});
+}
+//#endregion
+export { r as withdrawAuto };
+
+//# sourceMappingURL=withdraw-auto.js.map

package/dist/symmio-contracts/symmio/actions/withdraw-auto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withdraw-auto.js","names":[],"sources":["../../../../src/symmio-contracts/symmio/actions/withdraw-auto.ts"],"sourcesContent":["import type { Address, Hash, Hex } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport type { Compute, WriteContractParameter } from \"../../../shared/types/properties\";\nimport { getSubAccount } from \"../../account-layer/actions/get-sub-account\";\nimport type { SingleUpnlSig, SubAccountIsolationType } from \"../../account-layer/types\";\nimport { createClassicWithdrawPart } from \"../parts\";\nimport { withdraw } from \"./withdraw\";\n\n/**\n * Parameters for {@link withdrawAuto}.\n */\nexport type WithdrawAutoParameters = Compute<\n  WriteContractParameter & {\n    /**\n     * The subaccount to withdraw from. The action routes the call through the\n     * AccountLayer `_call` proxy so the core attributes it to this subaccount; the\n     * connected wallet must be its on-chain `owner`.\n     */\n    account: Address;\n    /**\n     * Amount to withdraw, in the **collateral token's decimals** (e.g. 6 for a\n     * USDC-collateralized chain). The action builds the withdraw part from this\n     * amount as-is and, on the `CUSTOM` (cross-margin) path, scales it to the\n     * 18-decimal amount the `deallocate` leg needs.\n     */\n    amount: bigint;\n    /** Destination EVM address the freed collateral is withdrawn to. */\n    receiver: Address;\n    /**\n     * Opt into the cooldown speed-up flow. Only effective for speed-up-eligible\n     * users; ignored otherwise.\n     * @default false\n     */\n    speedUp?: boolean;\n    /**\n     * Opaque provider data forwarded to express/virtual providers (e.g. a signed\n     * option). Pass `0x` for a classic withdrawal.\n     * @default \"0x\"\n     */\n    providerData?: Hex;\n    /**\n     * A fresh Muon uPnL (`uPnl_A`) attestation for `account`, used only by the\n     * `CUSTOM` (deallocate) path. Omit it to have the action fetch a fresh one;\n     * pass one only to reuse a signature you already fetched. Ignored on the\n     * `MARKET` / `MARKET_DIRECTION` path.\n     */\n    upnlSig?: SingleUpnlSig;\n    /**\n     * The subaccount's isolation type. Pass it to **skip the `getSubAccount` read**\n     * — the React layer already holds it (cached via `useSubAccount`), so passing it\n     * avoids a redundant RPC. Omit it and the action fetches the subaccount to\n     * resolve it.\n     */\n    isolationType?: SubAccountIsolationType;\n  }\n>;\n\n/** Return type of {@link withdrawAuto}: the submitted transaction hash. */\nexport type WithdrawAutoReturnType = Hash;\n\n/**\n * Withdraw from a subaccount from a **minimal, collateral-decimals input** — the\n * high-level entry point that does all the plumbing so callers pass only\n * `{ account, amount, receiver }` and never touch isolation, parts, or scaling.\n *\n * The action resolves the subaccount's {@link SubAccountIsolationType} — from the\n * passed `isolationType`, or by reading the subaccount when it is omitted — builds\n * the classic same-chain withdraw part from `amount` (in the collateral token's\n * decimals), scales that amount to 18 decimals for the deallocate leg, and hands\n * off to {@link withdraw} — which dispatches on the resolved isolation:\n *\n * | `isolationType`                     | Balance   | What runs                             |\n * | ----------------------------------- | --------- | ------------------------------------- |\n * | `CUSTOM` (cross-margin)             | allocated | deallocate + initiate in one atomic tx |\n * | `MARKET` / `MARKET_DIRECTION` (VA)  | available | initiate the withdraw request only     |\n *\n * @remarks\n * Account-layer balances are `1e18`-scaled regardless of the collateral token's\n * decimals, so the `CUSTOM` deallocate leg needs the 18-decimal amount; this action\n * derives it as `amount * 10 ** (18 - collateralDecimals)` (assumes\n * `collateralDecimals <= 18`). On the `CUSTOM` path it also fetches a fresh Muon\n * `upnlSig` for the deallocate leg unless one is passed. Reach for {@link withdraw}\n * directly when you already hold the subaccount's `isolationType` and want to skip\n * the extra read, or need custom (multi-part / cross-chain) withdraw parts.\n *\n * @param config - The SDK config (must have a `getWalletClient` resolver).\n * @param parameters - Subaccount, `amount` (collateral decimals), `receiver`,\n *   optional speed-up / provider data, optional Muon `upnlSig`, optional chain id.\n * @returns The submitted transaction hash. The caller waits on the receipt.\n * @throws {SymmError} when the chain is unsupported or no wallet is available.\n * @throws Viem's write errors (`ContractFunctionExecutionError`, ...).\n *\n * @example\n * ```ts\n * // amount in the collateral token's decimals (6-dec USDC → 1 USDC):\n * const hash = await withdrawAuto(config, {\n *   account: \"0xsub…\",\n *   amount: 1_000000n,\n *   receiver: \"0xabc…\",\n * });\n * ```\n */\nexport async function withdrawAuto(\n  config: Config,\n  parameters: WithdrawAutoParameters,\n): Promise<WithdrawAutoReturnType> {\n  const chainId = parameters.chainId ?? config.defaultChainId;\n\n  // Use the caller-supplied isolation type when present (the React layer reads it\n  // from cache); otherwise fetch the subaccount to resolve it.\n  const isolationType =\n    parameters.isolationType ?? (await getSubAccount(config, { account: parameters.account, chainId })).isolationType;\n  const { addresses } = config.getChainConfig(chainId);\n\n  const part = createClassicWithdrawPart({\n    id: 0n,\n    amount: parameters.amount,\n    receiver: parameters.receiver,\n    chainId: BigInt(chainId),\n  });\n\n  // Account-layer balances are 1e18-scaled regardless of collateral decimals; the\n  // deallocate leg needs the 18-dec amount. (Assumes collateralDecimals <= 18.)\n  const amount18 = parameters.amount * 10n ** BigInt(18 - addresses.collateralDecimals);\n\n  return withdraw(config, {\n    account: parameters.account,\n    isolationType,\n    parts: [part],\n    amount: amount18,\n    speedUp: parameters.speedUp,\n    providerData: parameters.providerData,\n    upnlSig: parameters.upnlSig,\n    chainId,\n    from: parameters.from,\n    simulateBeforeWrite: parameters.simulateBeforeWrite,\n  });\n}\n"],"mappings":";;;;AAsGA,eAAsB,EACpB,GACA,GACiC;CACjC,IAAM,IAAU,EAAW,WAAW,EAAO,gBAIvC,IACJ,EAAW,kBAAkB,MAAM,EAAc,GAAQ;EAAE,SAAS,EAAW;EAAS;CAAQ,CAAC,GAAG,eAChG,EAAE,iBAAc,EAAO,eAAe,CAAO,GAE7C,IAAO,EAA0B;EACrC,IAAI;EACJ,QAAQ,EAAW;EACnB,UAAU,EAAW;EACrB,SAAS,OAAO,CAAO;CACzB,CAAC,GAIK,IAAW,EAAW,SAAS,OAAO,OAAO,KAAK,EAAU,kBAAkB;CAEpF,OAAO,EAAS,GAAQ;EACtB,SAAS,EAAW;EACpB;EACA,OAAO,CAAC,CAAI;EACZ,QAAQ;EACR,SAAS,EAAW;EACpB,cAAc,EAAW;EACzB,SAAS,EAAW;EACpB;EACA,MAAM,EAAW;EACjB,qBAAqB,EAAW;CAClC,CAAC;AACH"}

package/dist/symmio-contracts/symmio/actions/withdraw.d.ts

@@ -0,0 +1,109 @@
+import { Address, Hash, Hex } from 'viem';
+import { Config } from '../../../core/config/index.js';
+import { Compute, WriteContractParameter } from '../../../shared/types/properties.js';
+import { SubAccountIsolationType, SingleUpnlSig } from '../../account-layer/types.js';
+import { WithdrawReceiverPart } from '../types.js';
+/**
+ * Parameters for {@link withdraw}.
+ */
+export type WithdrawParameters = Compute<WriteContractParameter & {
+    /**
+     * The subaccount to withdraw from. Both underlying actions route the call
+     * through the AccountLayer `_call` proxy so the core attributes it to this
+     * subaccount; the connected wallet must be its on-chain `owner`.
+     */
+    account: Address;
+    /**
+     * The subaccount's isolation strategy, which selects the withdraw path:
+     * `CUSTOM` (cross-margin) deallocates then initiates; `MARKET` /
+     * `MARKET_DIRECTION` (VA / lowcap) initiate only. Read it from the
+     * subaccount detail (`getSubAccount` → `isolationType`).
+     */
+    isolationType: SubAccountIsolationType;
+    /**
+     * The receiver parts the withdrawal is split into. A plain same-chain
+     * withdrawal is a single part with both provider fields set to the zero
+     * address — see `createClassicWithdrawPart`.
+     */
+    parts: readonly WithdrawReceiverPart[];
+    /**
+     * Amount to move from the allocated balance back into the available balance,
+     * in **18 decimals** (not the collateral token's decimals). Consumed only by
+     * the `deallocate` leg, so it is **required when `isolationType` is `CUSTOM`**
+     * and ignored otherwise.
+     */
+    amount?: bigint;
+    /**
+     * Opt into the cooldown speed-up flow. Only effective for speed-up-eligible
+     * users; ignored otherwise.
+     * @default false
+     */
+    speedUp?: boolean;
+    /**
+     * Opaque provider data forwarded to express/virtual providers (e.g. a signed
+     * option). Pass `0x` for a classic withdrawal.
+     * @default "0x"
+     */
+    providerData?: Hex;
+    /**
+     * A fresh Muon uPnL (`uPnl_A`) attestation for `account`, used only by the
+     * `CUSTOM` (deallocate) path. Omit it to have the action fetch a fresh one;
+     * pass one only to reuse a signature you already fetched. Ignored on the
+     * `MARKET` / `MARKET_DIRECTION` path.
+     */
+    upnlSig?: SingleUpnlSig;
+}>;
+/** Return type of {@link withdraw}: the submitted transaction hash. */
+export type WithdrawReturnType = Hash;
+/**
+ * Withdraw from a subaccount, dispatching on its isolation strategy so callers
+ * do not have to branch on where the collateral currently sits.
+ *
+ * The subaccount's {@link SubAccountIsolationType} determines which balance the
+ * funds are in and therefore which underlying action runs:
+ *
+ * | `isolationType`                     | Balance   | Action                               |
+ * | ----------------------------------- | --------- | ------------------------------------ |
+ * | `CUSTOM` (cross-margin)             | allocated | {@link deallocateAndInitiateWithdraw} |
+ * | `MARKET` / `MARKET_DIRECTION` (VA)  | available | {@link initiateWithdraw}              |
+ *
+ * `CUSTOM` funds sit in the **allocated** balance, so they must first be
+ * deallocated into the available balance; this path batches the `deallocate` and
+ * `initiateWithdraw` legs into one atomic transaction and therefore **requires**
+ * `amount` (the 18-decimal deallocate amount). The VA paths (`MARKET` /
+ * `MARKET_DIRECTION`) already hold their funds in the **available** balance, so
+ * they only initiate the withdraw request and ignore `amount`.
+ *
+ * @remarks
+ * Both underlying actions route through the AccountLayer `_call` proxy and dry-run
+ * before writing unless `simulateBeforeWrite` is `false`. The `CUSTOM` path also
+ * fetches a fresh Muon `upnlSig` for its `deallocate` leg when one is not passed —
+ * see {@link deallocateAndInitiateWithdraw}. Reach for the underlying actions
+ * directly when you already know the subaccount's isolation and want to skip the
+ * dispatch.
+ *
+ * @param config - The SDK config (must have a `getWalletClient` resolver).
+ * @param parameters - Subaccount, its `isolationType`, receiver parts, optional
+ *   speed-up / provider data, optional Muon `upnlSig`, optional chain id, and
+ *   `amount` (18 decimals) — required for `CUSTOM`, ignored otherwise.
+ * @returns The submitted transaction hash. The caller waits on the receipt.
+ * @throws {SymmError} `validation` / `WITHDRAW_AMOUNT_REQUIRED` when
+ *   `isolationType` is `CUSTOM` but `amount` is omitted; also the config/wallet
+ *   errors the underlying actions throw.
+ * @throws Viem's write errors (`ContractFunctionExecutionError`, ...).
+ *
+ * @example
+ * ```ts
+ * const { isolationType } = await getSubAccount(config, { account: "0xsub…" });
+ * const part = createClassicWithdrawPart({ id: 0n, amount: 1_000000n, receiver: "0xabc…", chainId: 999n });
+ * const hash = await withdraw(config, {
+ *   account: "0xsub…",
+ *   isolationType,
+ *   parts: [part],
+ *   // required only when isolationType === SubAccountIsolationType.CUSTOM:
+ *   amount: 1_000000000000000000n,
+ * });
+ * ```
+ */
+export declare function withdraw(config: Config, parameters: WithdrawParameters): Promise<WithdrawReturnType>;
+//# sourceMappingURL=withdraw.d.ts.map

package/dist/symmio-contracts/symmio/actions/withdraw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withdraw.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/symmio/actions/withdraw.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC/C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,KAAK,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AACxF,OAAO,EAAE,uBAAuB,EAAE,KAAK,aAAa,EAAE,MAAM,2BAA2B,CAAC;AACxF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAIrD;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,CACtC,sBAAsB,GAAG;IACvB;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,aAAa,EAAE,uBAAuB,CAAC;IACvC;;;;OAIG;IACH,KAAK,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACvC;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,YAAY,CAAC,EAAE,GAAG,CAAC;IACnB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB,CACF,CAAC;AAEF,uEAAuE;AACvE,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAsB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA+B1G"}