@spicenet-io/spiceflow-ui 4.9.3-extmode.5 → 4.10.0-next.1

package/README.md

@@ -108,49 +108,6 @@ it becomes a `protocol` everyone can name.
 
 ## Development
 
-### Rollup balance pricing
-
-Rollup USD values use the host-configured RPC provider's pricing capability when the balance API has no valid value. The built-in account panel and withdrawal modal enable this while open; custom `useSpiceAssets` consumers can opt in with `priceEnabled`. Quantities arrive independently. Lookups follow receipt mappings, prefer `nativeChainId`, and fall back to other supported chains with a configured Alchemy endpoint. Explicit account `tokenPrices` overrides still take precedence over provider quotes.
-
-Wallet discovery and rollup balances share a one-minute quote cache. Pricing polls only while the view is open and the page is visible. A failed refresh can retain a marked stale quote for up to five minutes; an unavailable quote displays `—`. No extra key, internal RPC, or symbol-based ERC-20 price fallback is used.
-
-### Direct withdrawal in a custom balance row
-
-`useSpiceDirectWithdraw()` uses the same embedded-wallet transfer and fee path as the account panel's direct Withdraw buttons. It selects the connected external wallet as recipient, exposes `canWithdraw` and `state`, and rejects duplicate submissions while pending. Pass the raw `bigint` balance to `withdraw({ tokenAddress, chainId, balance })` and refresh the host's balance after it resolves. Rejections are available as `state.message` for the host to render.
-
-Custom account rows accept React content in `displayValue`, so a host can render its own button with that controller. Set the row's `asset: { tokenAddress, chainId }` when it represents an on-chain balance; the account panel then omits that token from discovered idle balances. Existing string values continue to work.
-
-### Withdraw from an account balance
-
-`AccountDisplay.onWithdrawClick` receives the rollup receipt-token ID when a
-user clicks Withdraw on an idle rollup balance. The main Withdraw button calls
-it without an ID. Pass the ID to `SpiceWithdraw.initialSourceAssetId` to open
-the existing modal with that asset selected; the user chooses the destination
-network inside the modal. Existing callbacks that take no arguments continue
-to work.
-
-```tsx
-const [withdrawOpen, setWithdrawOpen] = useState(false);
-const [withdrawAssetId, setWithdrawAssetId] = useState<string>();
-
-<AccountDisplay
-  onWithdrawClick={(receiptTokenId) => {
-    setWithdrawAssetId(receiptTokenId);
-    setWithdrawOpen(true);
-  }}
-/>
-<SpiceWithdraw
-  isOpen={withdrawOpen}
-  onClose={() => setWithdrawOpen(false)}
-  initialSourceAssetId={withdrawAssetId}
-  buildSpicenetBatch={buildSpicenetWithdrawalBatch}
-/>
-```
-
-Keep the integration's existing withdrawal batch builder and callbacks.
-`initialSourceAssetId` selects a current balance by ID; it does not supply a
-cached balance or change the receipt's supported withdrawal routes.
-
 ### Fee-Charging Intent Flows
 
 - `SpiceSupply` and `SpicePay` are fee-charging intent-execution flows and must surface fee estimation before enabling submission.

package/dist/auth-privy.js

@@ -1,2 +1,2 @@
 "use client";
-import{P as g}from"./privy-DsMpmEiz.js";import"react/jsx-runtime";import"react";import"@spicenet-io/spiceflow-core";import"viem";import"viem/actions";import"@privy-io/react-auth";import"wagmi";import"@tanstack/react-query";export{g as PrivyLogin};
+import{P as g}from"./privy-D5qswtTm.js";import"react/jsx-runtime";import"react";import"@spicenet-io/spiceflow-core";import"viem";import"viem/actions";import"@privy-io/react-auth";import"wagmi";import"@tanstack/react-query";export{g as PrivyLogin};

package/dist/components/AccountDisplay/parts/AccountIdleBalances.d.ts

@@ -1,7 +1,11 @@
 import React from "react";
 import { SpiceAsset } from "../types";
 import type { ResolvedDarkPalette } from "../../../utils/theme";
-import type { DirectWithdrawState } from "../../../hooks/useDirectWithdraw";
+export interface DirectWithdrawState {
+    key: string;
+    step: "pending" | "error";
+    message?: string;
+}
 interface AccountIdleBalancesProps {
     spiceAssets: SpiceAsset[];
     loading: boolean;
@@ -10,7 +14,6 @@ interface AccountIdleBalancesProps {
     canDirectWithdraw?: boolean;
     onDirectWithdraw?: (asset: SpiceAsset) => void;
     directWithdrawState?: DirectWithdrawState | null;
-    onWithdrawClick?: (receiptTokenId?: string) => void;
 }
 export declare const AccountIdleBalances: React.NamedExoticComponent<AccountIdleBalancesProps>;
 export {};

package/dist/components/AccountDisplay/parts/AccountPanel.d.ts

@@ -2,7 +2,7 @@ import React from "react";
 import { SpiceAsset, CustomSection, AccountNotice } from "../types";
 import { VerifiedPendingDeposit } from "../../../hooks/usePendingDeposit";
 import type { ResolvedDarkPalette } from "../../../utils/theme";
-import type { DirectWithdrawState } from "../../../hooks/useDirectWithdraw";
+import { type DirectWithdrawState } from "./AccountIdleBalances";
 interface AccountPanelProps {
     appName: string;
     status: "active" | "inactive";
@@ -17,7 +17,7 @@ interface AccountPanelProps {
     customSections: CustomSection[];
     notice?: AccountNotice | null;
     onDepositClick?: () => void;
-    onWithdrawClick?: (receiptTokenId?: string) => void;
+    onWithdrawClick?: () => void;
     depositDisabled?: boolean;
     onCompleteDeposit?: (deposit: VerifiedPendingDeposit) => void;
     primaryColor?: string;

package/dist/components/AccountDisplay/types.d.ts

@@ -5,8 +5,7 @@ export interface CustomSectionItem {
     tokenSymbol: string;
     tokenLogoURI?: string;
     label: string;
-    displayValue: React.ReactNode;
-    asset?: Pick<SpiceAsset, "tokenAddress" | "chainId">;
+    displayValue: string;
     valueColor?: "green" | "red" | "default";
 }
 export interface CustomSection {
@@ -25,9 +24,7 @@ export interface SpiceAsset {
     balance: string;
     balanceFormatted: number;
     usdValue: number;
-    priceStatus?: "fresh" | "stale" | "unavailable";
     logoURI?: string;
-    receiptTokenId?: string;
     directWithdraw?: boolean;
 }
 export interface BreakdownLabel {
@@ -51,7 +48,7 @@ export interface AccountDisplayProps {
     dark?: boolean;
     onDepositSuccess?: () => void;
     onDepositClick?: () => void;
-    onWithdrawClick?: (receiptTokenId?: string) => void;
+    onWithdrawClick?: () => void;
     onCompleteDeposit?: (deposit: VerifiedPendingDeposit) => void;
     showModeToggle?: boolean;
     defaultMode?: "7702" | "non7702";

package/dist/components/SpiceSupply/lib/buildBatches.d.ts

@@ -7,9 +7,11 @@ import type { ResolvedExactOutputSwap } from "../../../utils/swapQuotes";
 import type { ExecutionOptions } from "../../../hooks/useSpiceExecution";
 import type { FeeEstimateSummary } from "@spicenet-io/spiceflow-core";
 type EstimateFn = (chainBatches: ChainBatch[], tokenAddress: string, tokenTransferAmount: bigint, options?: ExecutionOptions) => Promise<FeeEstimateSummary>;
-export declare function isExternalInPlacePaySource(selectedAsset: SelectedAsset | null, isNon7702: boolean, resolvedChainId: number): boolean;
+export declare function buildEmbeddedEscrowDepositBatch(token: Address, amount: bigint, chainId: number): ChainBatch;
+export declare function isExternalSource(asset: SelectedAsset["asset"] | null | undefined, isNon7702: boolean): boolean;
 export declare function stripSpicenetFundingBatches(batches: ChainBatch[]): ChainBatch[];
 export declare function scaleTokenAmount(amount: bigint, fromDecimals: number, toDecimals: number): bigint;
+export declare function resolveSupplyTokenDecimals(asset: SelectedAsset["asset"], destination: SpiceSupplyProps["destinationToken"], token: Address): Promise<number>;
 export interface BatchBuilderContext {
     currentPaymentAmount: string;
     destinationToken: SpiceSupplyProps["destinationToken"];
@@ -18,8 +20,10 @@ export interface BatchBuilderContext {
     externalWalletAddress: string | null | undefined;
     address: string | null | undefined;
     recipient?: Address;
+    swapOutputRecipient?: Address;
     isNon7702: boolean;
     isPayMode: boolean;
+    feeOnlyAction?: boolean;
     resolvedChainId: number;
     buildActionCalls: SpiceSupplyProps["buildActionCalls"];
     feeExecutionMode: SpiceSupplyProps["feeExecutionMode"];
@@ -27,7 +31,6 @@ export interface BatchBuilderContext {
     selectedAsset: SelectedAsset | null;
     needsSwap: boolean;
     resolvedSwap: ResolvedSwap | null;
-    resolveInputSwap?: (amountIn: bigint) => Promise<ResolvedSwap>;
     exactOutputSwap: ResolvedExactOutputSwap | null;
     quoteAmountOut: bigint | null;
     resolvedTokenIn: Address | null;

package/dist/components/SpiceSupply/lib/controlledFunding.d.ts

@@ -0,0 +1,53 @@
+import { type SourceFundingState } from "../../../execution/sourceFunding";
+import { type ExecutorContext } from "./executors";
+import type { Asset, SelectedAsset } from "../../../types/assets";
+import type { DestinationTokenConfig } from "../../../types/supply";
+export declare const SOURCE_FUNDING_EVENT = "spiceflow:source-funding";
+type StoredSelectedAsset = {
+    asset: Omit<Asset, "balance"> & {
+        balance: string;
+    };
+    amount: string;
+};
+export interface SourceFundingProgress {
+    feeOnlyAction: boolean;
+    phase: "funding" | "routing";
+    confirmedAmount: string;
+    matchesSelection: boolean;
+    matchesPurpose: boolean;
+    requiresRecovery: boolean;
+    recoveryKey: string;
+    selectedAsset: SelectedAsset;
+    destinationToken: DestinationTokenConfig;
+    paymentAmount: string;
+    amountDirection: "input" | "input-inclusive" | "output";
+}
+export interface FundingRecord {
+    feeOnlyAction?: boolean;
+    version: 2;
+    scope: string;
+    identity: string;
+    funding: SourceFundingState;
+    submitted: boolean;
+    recoveryKey: string;
+    selectedAsset: StoredSelectedAsset;
+    destinationToken: DestinationTokenConfig;
+    paymentAmount: string;
+    amountDirection: SourceFundingProgress["amountDirection"];
+    route?: {
+        actionId: string;
+        intentId: string;
+        intentIndex: number;
+        spicenetSteps: boolean[];
+    };
+}
+export declare function controlledFundingProgress(record: FundingRecord, ctx: ExecutorContext): SourceFundingProgress;
+export declare function readControlledFunding(scope: string): FundingRecord | null;
+export declare function executeWithSourceFunding(params: {
+    scope: string;
+    ctx: ExecutorContext;
+    run: (ctx: ExecutorContext) => Promise<void>;
+    isCurrent: () => boolean;
+    onRecord?: (record: FundingRecord | null) => void;
+}): Promise<void>;
+export {};

package/dist/components/SpiceSupply/lib/executors.d.ts

@@ -1,5 +1,8 @@
+import { type SourceConversionExecution } from "./sourceConversion";
 import type { Dispatch, MutableRefObject, SetStateAction } from "react";
 import { type Address } from "viem";
+import { type TransactionObserver } from "../../../execution/externalWalletClient";
+import { type SourceFundingState } from "../../../execution/sourceFunding";
 import type { SelectedAsset } from "../../../types/assets";
 import type { BuildPayBatchesFn, BuildSupplyBatchesFn, SpiceSupplyProps } from "../../../types/supply";
 import { type SupplyFeeQuote } from "./feePreview";
@@ -12,6 +15,7 @@ export type PaymentResult = {
     txHash?: string;
     error?: string;
 };
+export { isExternalSource } from "./buildBatches";
 export type ExecutorContext = {
     selectedAsset: SelectedAsset | null;
     parsedAmount: number;
@@ -19,6 +23,7 @@ export type ExecutorContext = {
     isInsufficientBalance: boolean;
     isPayMode: boolean;
     isFeeInclusiveInput?: boolean;
+    feeOnlyAction?: boolean;
     isNon7702: boolean;
     isSourceDestToken: boolean;
     needsSwap: boolean;
@@ -43,7 +48,14 @@ export type ExecutorContext = {
     provider: string | null | undefined;
     resolvedChainId: number;
     executionTokenAddress: Address;
+    executionTokenDecimals?: number;
     feeQuote: SupplyFeeQuote | null;
+    fundingObserver?: TransactionObserver;
+    sourceFunding?: SourceFundingState;
+    sourceFundingRecoveryKey?: string;
+    sourceConversion?: SourceConversionExecution;
+    sourceConversionRequired?: boolean;
+    onSourceFundingChange?: (state: SourceFundingState) => void;
     execution: ExecutionRunner & {
         buildPayChainBatches: BuildPayBatchesFn;
         buildSupplyChainBatches: BuildSupplyBatchesFn;
@@ -63,5 +75,6 @@ export type ExecutorContext = {
         abortControllerRef: MutableRefObject<AbortController | null>;
     };
 } & Pick<SpiceSupplyProps, "destinationToken" | "buildActionCalls" | "feeExecutionMode" | "buildSpicenetBatch" | "onPayExecute" | "onSuccess">;
+export declare function sourceFundingIdentity(ctx: ExecutorContext): string;
 export declare function executeSupply(ctx: ExecutorContext): Promise<void>;
 export declare function executePay(ctx: ExecutorContext): Promise<void>;

package/dist/components/SpiceSupply/lib/externalAction.d.ts

@@ -0,0 +1,61 @@
+import { type Address } from "viem";
+import { type SourceFundingState } from "../../../execution/sourceFunding";
+import { type ExecutorContext } from "./executors";
+import type { BuildActionCallsContext, SpiceSupplyProps } from "../../../types/supply";
+import type { Call } from "../../../types/authorization";
+export type ExternalActionExecution = {
+    wallet: "external";
+    recoveryKey: string;
+};
+export interface ExternalActionProgress {
+    destinationToken: Address;
+    destinationDecimals: number;
+    phase: "funding" | "routing" | "action" | "complete";
+    confirmedCalls: number;
+    totalCalls: number;
+    amount?: string;
+    requiresRecovery: boolean;
+}
+type PendingTransaction = {
+    chainId: number;
+    hash?: `0x${string}`;
+};
+type StoredCall = {
+    to: Address;
+    value: string;
+    data: `0x${string}`;
+};
+export interface ExternalActionRecord {
+    version: 2;
+    scope: string;
+    destinationToken: Address;
+    destinationDecimals: number;
+    sourceKey: string;
+    phase: ExternalActionProgress["phase"];
+    amount?: string;
+    calls?: StoredCall[];
+    confirmedCalls: number;
+    sourceFunding?: SourceFundingState;
+    pendingCall?: PendingTransaction;
+    routeSubmitted: boolean;
+    route?: {
+        actionId: string;
+        intentId: string;
+        intentIndex: number;
+        spicenetSteps: boolean[];
+    };
+    lastHash?: `0x${string}`;
+}
+export declare function externalActionScope(network: string, chainId: number, external: string, embedded: string, recoveryKey: string): string;
+export declare function readExternalAction(scope: string): ExternalActionRecord | null;
+export declare function externalActionProgress(record: ExternalActionRecord): ExternalActionProgress;
+export declare function clearCompletedExternalAction(scope: string): void;
+export declare function buildExternalDeliveryCalls(amount: bigint, context: BuildActionCallsContext, recipient: Address): Call[];
+export declare function executeExternalActionSupply(params: {
+    scope: string;
+    ctx: ExecutorContext;
+    buildActionCalls: SpiceSupplyProps["buildActionCalls"];
+    onRecord: (record: ExternalActionRecord) => void;
+    isCurrent?: () => boolean;
+}): Promise<void>;
+export {};

package/dist/components/SpiceSupply/lib/feeOnlyExecution.d.ts

@@ -0,0 +1,6 @@
+import { type Address } from "viem";
+import type { ChainBatch } from "../../../types/authorization";
+import type { ExecutionOptions } from "../../../hooks/useSpiceExecution";
+import type { ExecutorContext } from "./executors";
+export declare function stripFeeOnlyCalls(batches: ChainBatch[], chainId: number, token: Address): ChainBatch[];
+export declare function feeOnlyExecutionOptions(ctx: ExecutorContext, token: Address, fundingCap: bigint): Pick<ExecutionOptions, "prepareForSigning" | "validateBeforeSubmit">;

package/dist/components/SpiceSupply/lib/feePreview.d.ts

@@ -18,6 +18,7 @@ export type SupplyFeeQuote = {
 export declare function solveGrossFunding(fees: Pick<FeePreview, "grossAmount" | "gasFee" | "spicenetFee" | "bridgeFee">, requiredNetFunding: bigint): bigint;
 export declare function estimatePayFunding(args: {
     requiredNetFunding: bigint;
+    feeOnlyAction?: boolean;
     buildBatches: (gross: bigint) => ChainBatch[] | Promise<ChainBatch[]>;
     fundingToken: Address;
     estimate: EstimateFn;
@@ -36,6 +37,7 @@ export declare function estimatePayFunding(args: {
 export declare function estimateSupplyMaxAmount(ctx: {
     asset: Asset;
     isPayMode: boolean;
+    isFeeInclusiveInput?: boolean;
     isNon7702: boolean;
     needsSwap: boolean;
     isQuoting: boolean;
@@ -50,6 +52,7 @@ export interface FeePreviewContext {
     selectedAsset: SelectedAsset | null;
     isPayMode: boolean;
     isFeeInclusiveInput?: boolean;
+    feeOnlyAction?: boolean;
     parsedAmount: number;
     needsSwap: boolean;
     exactOutputSwap: ResolvedExactOutputSwap | null;

package/dist/components/SpiceSupply/lib/payFundingBatches.d.ts

@@ -0,0 +1,6 @@
+import type { Address } from "viem";
+import type { FeeEstimateSummary } from "@spicenet-io/spiceflow-core";
+import type { ChainBatch } from "../../../types/authorization";
+export declare function wrapPayWithSpicenet(raw: ChainBatch[], fundingRecipient: Address, feeEstimate?: FeeEstimateSummary, opts?: {
+    payoutAlreadyGross?: boolean;
+}): ChainBatch[];

package/dist/components/SpiceSupply/lib/sourceConversion.d.ts

@@ -0,0 +1,12 @@
+import type { ExecutorContext } from "./executors";
+import type { ChainBatch } from "../../../types/authorization";
+import type { SelectedAsset } from "../../../types/assets";
+import type { SourceFundingExecutionPlan } from "../../../utils/crossChainRouter/sourceFundingQuote";
+export interface SourceConversionExecution {
+    virtualSelectedAsset: SelectedAsset;
+    acceptedSourceAmountInMax: bigint;
+    getPlan: (batches: ChainBatch[]) => SourceFundingExecutionPlan | undefined;
+    isCurrent: () => boolean;
+}
+export declare function sourceBatchKey(batch: ChainBatch): string;
+export declare function executeSourceConversion(ctx: ExecutorContext, run: (ctx: ExecutorContext) => Promise<void>, fundExternal: (amount: bigint) => Promise<void>): Promise<void>;

package/dist/components/SpiceWithdraw/lib/helpers.d.ts

@@ -2,5 +2,5 @@ import type { ChainBatch } from "../../../types/authorization";
 export declare function normalizeTokenLabel(value?: string | null): string;
 export declare function formatTokenAmount(rawAmount: bigint, decimals: number): string;
 export declare function scaleAmountBetweenDecimals(amount: bigint, fromDecimals: number, toDecimals: number): bigint;
-export declare function estimateUsd(amount: number, price?: number, stale?: boolean): string;
+export declare function estimateUsd(amount: number, symbol?: string): string;
 export declare function buildWithdrawFeeEstimateKey(batches: ChainBatch[], tokenAddress?: string | null): string | null;

package/dist/components/SpiceWithdraw/parts/WithdrawBalanceCardHeader.d.ts

@@ -4,6 +4,7 @@ interface WithdrawBalanceCardHeaderProps {
     label: string;
     spiceAssetsLoading: boolean;
     totalSelectedBalance: number;
+    onOpenBalancePopover: (anchor: HTMLElement | null) => void;
     dark: boolean;
     dk: ResolvedDarkPalette;
 }

package/dist/components/SpiceWithdraw/parts/WithdrawBalancePopover.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+import type { ResolvedDarkPalette } from "../../../utils/theme";
+interface BalancePopoverProps {
+    show: boolean;
+    position: {
+        top: number;
+        left: number;
+    } | null;
+    popoverRef: React.RefObject<HTMLDivElement>;
+    spiceAssets: any[] | null | undefined;
+    dark: boolean;
+    dk: ResolvedDarkPalette;
+}
+export declare const BalancePopover: React.FC<BalancePopoverProps>;
+export {};

package/dist/execution/externalWalletClient.d.ts

@@ -1,5 +1,13 @@
 import { type Address } from "viem";
 import type { Call } from "../types/authorization";
+export interface TransactionObserver {
+    onSending?: (index: number) => void | Promise<void>;
+    onSubmitted?: (index: number, hash: `0x${string}`) => void;
+    onConfirmed?: (index: number, hash: `0x${string}`) => void;
+    onReverted?: (index: number, hash: `0x${string}`) => void;
+    onRejected?: (index: number) => void;
+}
+export declare function isWalletRejection(error: unknown): boolean;
 export declare function createExternalWalletClient(params: {
     wallet?: {
         getEthereumProvider: () => Promise<any>;
@@ -18,4 +26,5 @@ export declare function sendCallsWithExternalWallet(params: {
     calls: Call[];
     viemChain?: any;
     errorMessage: string;
+    observer?: TransactionObserver;
 }): Promise<`0x${string}` | undefined>;

package/dist/execution/fundEmbeddedWallet.d.ts

@@ -1,4 +1,7 @@
 import { type Address } from "viem";
+import { type TransactionObserver } from "./externalWalletClient";
+import type { Call } from "../types/authorization";
+export declare function tokenTransferCall(recipient: Address, tokenAddr: Address, isNative: boolean, amount: bigint): Call;
 export declare function sendTokenTransferTx(extWc: any, params: {
     recipient: Address;
     tokenAddr: Address;
@@ -14,4 +17,5 @@ export declare function fundEmbeddedWallet(params: {
     isNative: boolean;
     amount: bigint;
     viemChain?: unknown;
+    observer?: TransactionObserver;
 }): Promise<void>;

package/dist/execution/sourceFunding.d.ts

@@ -0,0 +1,28 @@
+import { type Address } from "viem";
+import type { TransactionObserver } from "./externalWalletClient";
+export interface SourceFundingState {
+    version: 1;
+    identity: string;
+    baseline: string;
+    confirmedAmount: string;
+    pending?: {
+        amount: string;
+        hash?: `0x${string}`;
+    };
+}
+export declare function isSourceFundingState(value: unknown): value is SourceFundingState;
+export declare function fundSelectedExternalSource(params: {
+    identity: string;
+    state?: SourceFundingState;
+    onState: (state: SourceFundingState) => void;
+    createWallet: () => Promise<{
+        extWc: any;
+        viemChain?: any;
+    }>;
+    sourceClient: any;
+    recipient: Address;
+    tokenAddr: Address;
+    isNative: boolean;
+    requiredAmount: bigint;
+    observer?: TransactionObserver;
+}): Promise<void>;

package/dist/execution/transactionReceipt.d.ts

@@ -0,0 +1,11 @@
+import type { Call } from "../types/authorization";
+export declare function waitForExpectedTransactionReceipt(params: {
+    client: any;
+    hash: `0x${string}`;
+    call: Call;
+    onRepriced?: (hash: `0x${string}`) => void;
+    onCancelled?: () => void;
+}): Promise<{
+    receipt: any;
+    hash: `0x${string}`;
+}>;

package/dist/hooks/index.d.ts

@@ -6,8 +6,6 @@ export type { UseWalletReturn, WalletState, WalletActions } from "./useWallet";
 export { useSpiceAssets } from "./useSpiceAssets";
 export type { UseSpiceAssetsConfig, UseSpiceAssetsReturn, } from "./useSpiceAssets";
 export { useSpiceExecution } from "./useSpiceExecution";
-export { useDirectWithdraw as useSpiceDirectWithdraw } from "./useDirectWithdraw";
-export type { DirectWithdrawParams, DirectWithdrawState, } from "./useDirectWithdraw";
 export type { ExecutionProgress, ExecutionStep, ExecutionOptions, OnProgress, } from "./useSpiceExecution";
 export { useLockDuration } from "./useLockDuration";
 export type { UseLockDurationReturn } from "./useLockDuration";
@@ -21,3 +19,5 @@ export type { PartnerWhitelistCheckResponse, UseIsUserWhitelistedOptions, } from
 export { useSupplyAssets, isSupportedSupplyAsset } from "./useSupplyAssets";
 export { useSupplyQuote, resolveInputSupplySwapQuote } from "./useSupplyQuote";
 export type { UseSupplyQuoteOpts, SupplyQuoteResult } from "./useSupplyQuote";
+export { useSpiceSupply } from "./useSpiceSupply";
+export type { ExternalActionExecution, ExternalActionProgress, SourceFundingProgress, UseSpiceSupplyParams, UseSpiceSupplyResult, } from "./useSpiceSupply";

package/dist/hooks/useDirectWithdraw.d.ts

@@ -4,15 +4,9 @@ export interface DirectWithdrawParams {
     tokenAddress: Address | string;
     chainId: number;
     balance: bigint;
+    recipient: Address | string;
     onProgress?: (progress: ExecutionProgress) => void;
 }
-export interface DirectWithdrawState {
-    key: string;
-    step: "pending" | "error";
-    message?: string;
-}
 export declare function useDirectWithdraw(): {
-    withdraw: ({ tokenAddress, chainId, balance, onProgress, }: DirectWithdrawParams) => Promise<string>;
-    canWithdraw: boolean;
-    state: DirectWithdrawState | null;
+    withdraw: ({ tokenAddress, chainId, balance, recipient, onProgress, }: DirectWithdrawParams) => Promise<string>;
 };

package/dist/hooks/useSourceFundingConversion.d.ts

@@ -0,0 +1,22 @@
+import { type Address } from "viem";
+import { type SourceFundingExecutionPlan } from "../utils/crossChainRouter/sourceFundingQuote";
+import type { SelectedAsset } from "../types/assets";
+import type { DestinationTokenConfig } from "../types/supply";
+export declare function useSourceFundingConversion(params: {
+    enabled: boolean;
+    selectedAsset: SelectedAsset | null;
+    destinationToken: DestinationTokenConfig;
+    executorAddress?: Address;
+    direction: "input" | "input-inclusive" | "output";
+    maxSlippage?: number;
+    outputAmount?: bigint;
+}): {
+    required: boolean;
+    plan: import("../utils/crossChainRouter/sourceFundingQuote").SourceFundingPlan | null;
+    key: string;
+    virtualSelectedAsset: SelectedAsset | null;
+    prepare: (requiredBridgeAmount?: bigint) => Promise<SourceFundingExecutionPlan>;
+    getPrepared: (amount?: bigint) => SourceFundingExecutionPlan | null;
+    error: string | null;
+    isCurrent: () => boolean;
+};

package/dist/hooks/useSpiceAssets.d.ts

@@ -5,7 +5,6 @@ export interface UseSpiceAssetsConfig {
     supportedChains?: number[];
     enabled?: boolean;
     refetchInterval?: number;
-    priceEnabled?: boolean;
 }
 export interface UseSpiceAssetsReturn {
     assets: Asset[];
@@ -15,4 +14,4 @@ export interface UseSpiceAssetsReturn {
     refetch: () => Promise<void>;
     getAssetsByChain: (chainId: number) => Asset[];
 }
-export declare const useSpiceAssets: ({ address, supportedChains, enabled, refetchInterval, priceEnabled, }: UseSpiceAssetsConfig) => UseSpiceAssetsReturn;
+export declare const useSpiceAssets: ({ address, supportedChains, enabled, refetchInterval, }: UseSpiceAssetsConfig) => UseSpiceAssetsReturn;

package/dist/hooks/useSpiceExecution.d.ts

@@ -31,6 +31,9 @@ export interface ExecutionOptions {
     }) => ChainBatch[] | null | Promise<ChainBatch[] | null>;
     skipPreSubmitFeeEstimate?: boolean;
     submittedFeeEstimate?: FeeEstimateSummary;
+    validateBeforeSubmit?: (chainBatches: ChainBatch[]) => void | Promise<void>;
+    requireDestinationReceipt?: boolean;
+    prepareForSigning?: (chainBatches: ChainBatch[]) => Promise<ChainBatch[]>;
     skipUserFundingPreflight?: boolean;
     signal?: AbortSignal;
 }

package/dist/hooks/useSpiceSupply.d.ts

@@ -0,0 +1,80 @@
+import { type Address } from "viem";
+import { type PaymentResult, type SupplyStep } from "../components/SpiceSupply/lib/executors";
+import { type SourceFundingProgress } from "../components/SpiceSupply/lib/controlledFunding";
+import { type ExternalActionExecution, type ExternalActionProgress } from "../components/SpiceSupply/lib/externalAction";
+export type { ExternalActionExecution, ExternalActionProgress, } from "../components/SpiceSupply/lib/externalAction";
+export type { SourceFundingProgress } from "../components/SpiceSupply/lib/controlledFunding";
+import { useSupplyAssets } from "./useSupplyAssets";
+import { useSupplyQuote } from "./useSupplyQuote";
+import type { LiquidityVenue } from "../utils/crossChainRouter/liquidityVenues";
+import type { SpiceSupplyProps } from "../types/supply";
+import type { Asset, SelectedAsset } from "../types/assets";
+import type { FeePreview } from "../types/ui";
+export interface UseSpiceSupplyParams extends Pick<SpiceSupplyProps, "destinationToken" | "sourceChains" | "supportedSourceAssets" | "includeExternalWalletAssets" | "includeCrossChainEmbeddedAssets" | "sourceFundingRecoveryKey" | "feeOnlyAction" | "buildActionCalls" | "feeExecutionMode" | "buildSpicenetBatch" | "onPayExecute" | "resolveExactOutputSwap" | "amountDirection" | "onSuccess" | "onError"> {
+    enabled: boolean;
+    actionExecution?: ExternalActionExecution;
+    selectedAsset: SelectedAsset | null;
+    paymentAmount?: string;
+    recipient?: Address;
+    maxSlippage?: number;
+    resolveInputSwap?: LiquidityVenue["resolve"];
+    prependSourceEscrow?: boolean;
+    isZeroAmountPay?: boolean;
+}
+export interface UseSpiceSupplyResult {
+    assets: ReturnType<typeof useSupplyAssets> & {
+        selectable: Asset[];
+    };
+    quote: ReturnType<typeof useSupplyQuote> & {
+        hasSourceConversion: boolean;
+        executionInput: {
+            address: Address;
+            chainId: number;
+            decimals: number;
+            amount: bigint;
+        } | null;
+    };
+    fees: {
+        preview: FeePreview | null;
+        source: {
+            symbol: string;
+            decimals: number;
+            gasFee: bigint;
+            spicenetFee: bigint;
+        } | null;
+        isLoading: boolean;
+        ready: boolean;
+        error: string | null;
+    };
+    amount: {
+        parsed: number;
+        isInsufficientBalance: boolean;
+        sourceBalance: number;
+        feesExceedAmount: boolean;
+        sourceRequiredAmount: bigint | null;
+    };
+    status: {
+        step: SupplyStep;
+        statusMsg: string;
+        txHash: string | null;
+        isExecuting: boolean;
+        error: string | null;
+        showStatusPanel: boolean;
+        paymentResult: PaymentResult | null;
+        externalAction: ExternalActionProgress | null;
+        sourceFunding: SourceFundingProgress | null;
+    };
+    flags: {
+        directExecutionFeeNote: boolean;
+    };
+    canExecute: boolean;
+    submitSupply: () => Promise<void>;
+    submitPay: () => Promise<void>;
+    fundEmbeddedSource: (amount: bigint) => Promise<void>;
+    retrySupply: () => void;
+    dismissPaymentStatus: () => void;
+    resolveMaxAmount: (asset: Asset) => Promise<string | null>;
+    resetAfterSuccess: () => void;
+    resetPaymentState: () => void;
+}
+export declare function useSpiceSupply(params: UseSpiceSupplyParams): UseSpiceSupplyResult;