@spicenet-io/spiceflow-ui 4.9.5 → 4.9.6-consistency.0

package/dist/auth-privy.cjs.js

@@ -1,2 +1,2 @@
 "use client";
-"use strict";const r=require("./privy-8_x0Dkgt.js");require("react/jsx-runtime"),require("react"),require("@spicenet-io/spiceflow-core"),require("viem"),require("viem/actions"),require("@privy-io/react-auth"),require("wagmi"),require("@tanstack/react-query"),exports.PrivyLogin=r.PrivyLogin;
+"use strict";const r=require("./privy-B3kX5909.js");require("react/jsx-runtime"),require("react"),require("@spicenet-io/spiceflow-core"),require("@tanstack/react-query"),require("viem"),require("@privy-io/react-auth"),require("wagmi"),require("viem/actions"),exports.PrivyLogin=r.PrivyLogin;

package/dist/auth-privy.js

@@ -1,2 +1,2 @@
 "use client";
-import{P as g}from"./privy--KTaTEam.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-BIQ0yO8R.js";import"react/jsx-runtime";import"react";import"@spicenet-io/spiceflow-core";import"@tanstack/react-query";import"viem";import"@privy-io/react-auth";import"wagmi";import"viem/actions";export{g as PrivyLogin};

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

@@ -1,6 +1,6 @@
 import React from "react";
-import { CustomSection } from "../types";
 import type { ResolvedDarkPalette } from "../../../utils/theme";
+import { CustomSection } from "../types";
 interface AccountCustomSectionProps {
     section: CustomSection;
     dk: ResolvedDarkPalette;

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

@@ -1,7 +1,7 @@
 import React from "react";
-import { SpiceAsset } from "../types";
 import type { ResolvedDarkPalette } from "../../../utils/theme";
-import type { DirectWithdrawState } from "../../../hooks/useDirectWithdraw";
+import type { DirectWithdrawState } from "../types";
+import { SpiceAsset } from "../types";
 interface AccountIdleBalancesProps {
     spiceAssets: SpiceAsset[];
     loading: boolean;

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

@@ -1,8 +1,8 @@
 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 "../types";
+import { AccountNotice, CustomSection, SpiceAsset } from "../types";
 interface AccountPanelProps {
     appName: string;
     status: "active" | "inactive";

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

@@ -1,19 +1,23 @@
-import type { CustomStyles } from "../../types/theme";
-import { VerifiedPendingDeposit } from "../../hooks/usePendingDeposit";
 import type React from "react";
+import { VerifiedPendingDeposit } from "../../hooks/usePendingDeposit";
+import type { CustomStyles } from "../../types/theme";
 export interface CustomSectionItem {
     tokenSymbol: string;
     tokenLogoURI?: string;
-    label: string;
+    label: React.ReactNode;
     displayValue: string;
     valueColor?: "green" | "red" | "default";
+    onClick?: () => void;
 }
 export interface CustomSection {
     title: string;
     items: CustomSectionItem[];
-    totalValue: number;
+    totalValue?: number;
 }
 export interface SpiceAsset {
+    owner?: string;
+    location?: "external" | "embedded" | "rollup";
+    positionId?: string;
     tokenAddress: string;
     tokenSymbol: string;
     tokenDisplaySymbol?: string;
@@ -56,4 +60,11 @@ export interface AccountDisplayProps {
     showModeToggle?: boolean;
     defaultMode?: "7702" | "non7702";
     showUsdSummary?: boolean;
+    alwaysShowEmbeddedIdle?: boolean;
+    showDisconnect?: boolean;
+}
+export interface DirectWithdrawState {
+    key: string;
+    step: "pending" | "error";
+    message?: string;
 }

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

@@ -0,0 +1,14 @@
+import { type Address } from "viem";
+import type { ChainBatch } from "../../../types/authorization";
+import type { SpiceSupplyProps, SupplyBatchBuildOptions } from "../../../types/supply";
+import type { SupplyFeeQuote } from "./feePreview";
+export declare function appendProceedsFees(batches: ChainBatch[], owner: Address, token: Address, gas: bigint, platform: bigint): ChainBatch[];
+export declare function simulateProceedsBatch(batches: ChainBatch[], owner: Address, token: Address, signal?: AbortSignal, platformFeeMaximum?: bigint): Promise<bigint>;
+export declare function estimateProceedsFunding(args: {
+    proceeds: NonNullable<SpiceSupplyProps["actionProceeds"]>;
+    owner: Address;
+    token: Address;
+    signal?: AbortSignal;
+    baseline: () => Promise<SupplyFeeQuote | null>;
+    buildBatches: (amount: bigint, options?: SupplyBatchBuildOptions) => Promise<ChainBatch[]>;
+}): Promise<SupplyFeeQuote>;

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

@@ -1,17 +1,19 @@
+import type { FeeEstimateSummary, ResolvedSwap } from "@spicenet-io/spiceflow-core";
 import { type Address } from "viem";
-import type { ResolvedSwap } from "@spicenet-io/spiceflow-core";
-import type { ChainBatch } from "../../../types/authorization";
+import type { ExecutionOptions } from "../../../hooks/useSpiceExecution";
 import type { SelectedAsset } from "../../../types/assets";
-import type { SpiceSupplyProps, SupplyBatchBuildOptions } from "../../../types/supply";
+import type { ChainBatch } from "../../../types/authorization";
+import type { PivotRoute, SpiceSupplyProps, SupplyBatchBuildOptions } from "../../../types/supply";
 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 getPivotEscrowAmount(sourceSwap: Pick<ResolvedSwap, "amountOutMinimum">, gasSkim: bigint): bigint;
 export declare function stripSpicenetFundingBatches(batches: ChainBatch[]): ChainBatch[];
 export declare function scaleTokenAmount(amount: bigint, fromDecimals: number, toDecimals: number): bigint;
 export interface BatchBuilderContext {
     currentPaymentAmount: string;
+    isFeeInclusiveInput?: boolean;
+    feeOnlyAction?: boolean;
+    swapInputAmount?: bigint | null;
     destinationToken: SpiceSupplyProps["destinationToken"];
     embeddedWalletAddress: string | null | undefined;
     providerEmbeddedAddress: string | null | undefined;
@@ -31,9 +33,20 @@ export interface BatchBuilderContext {
     exactOutputSwap: ResolvedExactOutputSwap | null;
     quoteAmountOut: bigint | null;
     resolvedTokenIn: Address | null;
+    sourceSwap?: ResolvedSwap | null;
+    sourceExactOutputSwap?: ResolvedExactOutputSwap | null;
+    resolveSourceExactOutputSwap?: (amountOut: bigint) => Promise<ResolvedExactOutputSwap>;
+    pivot?: PivotRoute | null;
     requestTimestampMs?: number;
 }
-export declare function buildPayChainBatches(ctx: BatchBuilderContext, options?: SupplyBatchBuildOptions): Promise<ChainBatch[]>;
-export declare function buildSupplyChainBatches(ctx: BatchBuilderContext, options?: SupplyBatchBuildOptions): Promise<ChainBatch[]>;
+export declare function isPivotPay(ctx: Pick<BatchBuilderContext, "isPayMode" | "selectedAsset" | "resolvedChainId" | "pivot">): ctx is typeof ctx & {
+    pivot: PivotRoute;
+};
+export declare function isPivotSupply(ctx: Pick<BatchBuilderContext, "isPayMode" | "selectedAsset" | "resolvedChainId" | "sourceSwap" | "pivot">): ctx is typeof ctx & {
+    sourceSwap: ResolvedSwap;
+    pivot: PivotRoute;
+};
+export declare const buildPayChainBatches: (ctx: BatchBuilderContext, options?: SupplyBatchBuildOptions) => Promise<ChainBatch[]>;
+export declare const buildSupplyChainBatches: (ctx: BatchBuilderContext, options?: SupplyBatchBuildOptions) => Promise<ChainBatch[]>;
 export declare function estimateRequiredGrossFunding(requiredNetFunding: bigint, buildBatches: (grossFundingAmount: bigint) => ChainBatch[] | Promise<ChainBatch[]>, fundingToken: Address, estimate: EstimateFn, executionOptions?: Pick<ExecutionOptions, "useCustomTransfers" | "userOverride">): Promise<bigint>;
 export {};

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

@@ -1,11 +1,12 @@
+import type { ResolvedSwap } from "@spicenet-io/spiceflow-core";
 import type { Dispatch, MutableRefObject, SetStateAction } from "react";
 import { type Address } from "viem";
+import type { ExecutionRunner } from "../../../execution/runner";
+import type { ExecutionProgress } from "../../../hooks/useSpiceExecution";
 import type { SelectedAsset } from "../../../types/assets";
-import type { BuildPayBatchesFn, BuildSupplyBatchesFn, SpiceSupplyProps } from "../../../types/supply";
-import { type SupplyFeeQuote } from "./feePreview";
+import type { BuildPayBatchesFn, BuildSupplyBatchesFn, PivotRoute, SpiceSupplyProps } from "../../../types/supply";
 import type { ResolvedExactOutputSwap } from "../../../utils/swapQuotes";
-import type { ExecutionProgress } from "../../../hooks/useSpiceExecution";
-import type { ExecutionRunner } from "../../../execution/runner";
+import { type SupplyFeeQuote } from "./feePreview";
 export type SupplyStep = "idle" | "signing-delegation" | "signing-intent" | "submitting" | "executing" | "success" | "error";
 export type PaymentResult = {
     status: "processing" | "success" | "failed";
@@ -19,12 +20,20 @@ export type ExecutorContext = {
     isInsufficientBalance: boolean;
     isPayMode: boolean;
     isFeeInclusiveInput?: boolean;
+    feeOnlyAction?: boolean;
+    actionProceeds?: SpiceSupplyProps["actionProceeds"];
+    validateFeeQuote?: () => void;
+    executionTokenDecimals?: number;
+    signal?: AbortSignal;
     isNon7702: boolean;
     isSourceDestToken: boolean;
     needsSwap: boolean;
     exactOutputSwap: ResolvedExactOutputSwap | null;
     selectedIsEquivalent: boolean;
     resolvedTokenIn: Address | null;
+    sourceSwap: ResolvedSwap | null;
+    sourceExactOutputSwap: ResolvedExactOutputSwap | null;
+    pivot: PivotRoute | null;
     embeddedWalletAddress: string | null | undefined;
     providerEmbeddedAddress: string | null | undefined;
     recipient?: Address;

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

@@ -0,0 +1,17 @@
+import { type Address } from "viem";
+import type { FeePreviewContext, SupplyFeeQuote } from "./feePreview";
+export declare function resolveFeeFundingToken(asset: NonNullable<FeePreviewContext["selectedAsset"]>["asset"], chainId: number, feeToken: Address): Address | null;
+export interface FundingConversion {
+    tokenIn: Address;
+    tokenOut: Address;
+    amountInMax: bigint;
+    amountOut: bigint;
+    sourceAmountMax: bigint;
+    fromProceeds?: boolean;
+}
+export declare class InsufficientFeeFundingBalanceError extends Error {
+    readonly requiredAmount: bigint;
+    readonly balance: bigint;
+    constructor(requiredAmount: bigint, balance: bigint);
+}
+export declare function quoteConvertedFees(ctx: FeePreviewContext): Promise<SupplyFeeQuote>;

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

@@ -0,0 +1,6 @@
+import { type Address } from "viem";
+import type { ExecutionOptions } from "../../../hooks/useSpiceExecution";
+import type { ChainBatch } from "../../../types/authorization";
+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" | "resolveActionOutputCredits">;

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

@@ -1,23 +1,45 @@
-import { type Address } from "viem";
+import type { ResolvedSwap } from "@spicenet-io/spiceflow-core";
 import { type FeeEstimateSummary } from "@spicenet-io/spiceflow-core";
-import type { FeePreview } from "../../../types/ui";
-import type { ChainBatch } from "../../../types/authorization";
+import { type Address } from "viem";
+import type { ExecutionOptions } from "../../../hooks/useSpiceExecution";
 import type { Asset, SelectedAsset } from "../../../types/assets";
-import type { SpiceSupplyProps, SupplyBatchBuildOptions } from "../../../types/supply";
+import type { ChainBatch } from "../../../types/authorization";
+import type { PivotRoute, SpiceSupplyProps, SupplyBatchBuildOptions } from "../../../types/supply";
+import type { FeePreview } from "../../../types/ui";
 import type { ResolvedExactOutputSwap } from "../../../utils/swapQuotes";
-import type { ResolvedSwap } from "@spicenet-io/spiceflow-core";
-import type { ExecutionOptions } from "../../../hooks/useSpiceExecution";
+import { type FundingConversion } from "./feeConversion";
 type EstimateFn = (chainBatches: ChainBatch[], tokenAddress: string, tokenTransferAmount: bigint, options?: ExecutionOptions) => Promise<FeeEstimateSummary>;
 type BuildPayBatchesFn = (options?: SupplyBatchBuildOptions) => Promise<ChainBatch[]>;
 type BuildSupplyBatchesFn = (options?: SupplyBatchBuildOptions) => Promise<ChainBatch[]>;
 export type SupplyFeeQuote = {
+    actionDefinition?: Parameters<NonNullable<SupplyBatchBuildOptions["onActionCalls"]>>[0];
+    fundingConversion?: FundingConversion;
+    fundingBatches?: ChainBatch[];
+    proceedsAvailable?: bigint;
+    proceedsUsed?: bigint;
+    batches?: ChainBatch[];
+    actionContext?: Partial<import("../../../types/supply").BuildActionCallsContext>;
+    fundingAmount?: bigint;
+    destinationSwap?: ResolvedSwap;
+    swapInputAmount?: bigint;
+    destinationAmount?: bigint;
+    sourceSpendCap?: bigint;
+    expiresAt?: number;
     preview: FeePreview;
     feeEstimate: FeeEstimateSummary | null;
     grossFundingAmount?: bigint;
+    sourceGasSkim?: bigint;
 };
+export declare function sizePivotSourceGasSkim(params: {
+    user: Address;
+    pivot: PivotRoute;
+    buildSupplyChainBatches: BuildSupplyBatchesFn;
+    signal?: AbortSignal;
+}): Promise<bigint>;
 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;
@@ -33,12 +55,18 @@ export declare function estimatePayFunding(args: {
     feeEstimate: FeeEstimateSummary;
     grossFundingAmount: bigint;
 }>;
+export declare function estimateMaximumSupplyInput(params: {
+    balance: bigint;
+    decimals: number;
+    planForAmount: (rawAmount: bigint) => Promise<SupplyFeeQuote | null>;
+}): Promise<string>;
 export declare function estimateSupplyMaxAmount(ctx: {
     asset: Asset;
     isPayMode: boolean;
     isNon7702: boolean;
     needsSwap: boolean;
     isQuoting: boolean;
+    pivot?: PivotRoute | null;
     embeddedWalletAddress: string | null | undefined;
     buildSupplyChainBatches: BuildSupplyBatchesFn;
     estimate: EstimateFn;
@@ -46,6 +74,11 @@ export declare function estimateSupplyMaxAmount(ctx: {
     feeExecutionMode: SpiceSupplyProps["feeExecutionMode"];
 }): Promise<string | null>;
 export interface FeePreviewContext {
+    liquidityVenues?: import("../../../utils/crossChainRouter/venueConfig").LiquidityVenuesConfig;
+    maxSlippage?: number;
+    resolveExactOutputSwap?: SpiceSupplyProps["resolveExactOutputSwap"];
+    feeOnlyAction?: boolean;
+    actionProceeds?: SpiceSupplyProps["actionProceeds"];
     signal?: AbortSignal;
     selectedAsset: SelectedAsset | null;
     isPayMode: boolean;
@@ -69,6 +102,9 @@ export interface FeePreviewContext {
     authenticated: boolean;
     isDirect: boolean;
     resolvedSwap: ResolvedSwap | null;
+    sourceSwap?: ResolvedSwap | null;
+    sourceExactOutputSwap?: ResolvedExactOutputSwap | null;
+    pivot?: PivotRoute | null;
     isQuoting: boolean;
     executionTokenAddress: Address;
     buildPayChainBatches: BuildPayBatchesFn;
@@ -76,4 +112,5 @@ export interface FeePreviewContext {
     estimate: EstimateFn;
 }
 export declare function estimateFeePreview(ctx: FeePreviewContext): Promise<SupplyFeeQuote | null>;
+export declare function supplyContextForFees(fees: FeePreview, amount: bigint, inclusive: boolean, mode: SpiceSupplyProps["feeExecutionMode"]): Required<Pick<import("../../../types/supply").BuildActionCallsContext, "grossAmount" | "netAmount" | "combinedFeeAmount" | "feeExecutionMode" | "feeBreakdown">>;
 export {};

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

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

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

@@ -0,0 +1,165 @@
+import { type Address } from "viem";
+import type { Asset } from "../../../types/assets";
+import type { SpiceWithdrawProps } from "../../../types/withdraw";
+import { assetPositionId } from "../../../utils/assetPolicy";
+export declare function useSpiceEmbeddedWithdraw(params: {
+    enabled: boolean;
+    asset: Asset | null;
+    amount: bigint;
+    recipient?: Address;
+    owner?: Address;
+    sourceChains?: number[];
+    onSuccess?: SpiceWithdrawProps["onWithdrawSuccess"];
+    onError?: SpiceWithdrawProps["onWithdrawError"];
+}): {
+    supply: {
+        selectedAsset: import("../../..").SelectedAsset | null;
+        capability: {
+            eligible: boolean;
+            reason: string | null;
+            policyExcluded?: boolean;
+        } | null;
+        assets: {
+            selectable: Asset[];
+            displayAssets: Asset[];
+            filteredSpiceAssets: Asset[];
+            embeddedWalletAddress: `0x${string}` | undefined;
+            externalAddress: `0x${string}` | undefined;
+            isNon7702: boolean;
+            refreshSpiceAssets: () => Promise<void>;
+            refreshWalletAssets: () => Promise<void>;
+            loading: boolean;
+            refreshing: boolean | undefined;
+            error: string | null;
+        };
+        quote: {
+            resolvedSwap: import("@spicenet-io/spiceflow-core").ResolvedSwap | null;
+            inputAmount?: bigint | null;
+            estimatedOutput: string | null;
+            hasSourceConversion: boolean;
+            executionInput: {
+                address: `0x${string}`;
+                chainId: number;
+                decimals: number;
+                amount: bigint;
+            } | null;
+            inputDecimals?: number | null;
+            quoteKey: string | null;
+            quoteExpiresAt: number | null;
+            refreshQuote: () => void;
+            isQuoting: boolean;
+            quoteError: string | null;
+            estimatedInput: string | null;
+            exactOutputSwap: import("../../..").ResolvedExactOutputSwap | null;
+            quoteAmountOut: bigint | null;
+            resolvedTokenIn: Address | null;
+            isDirect: boolean;
+            needsSwap: boolean;
+            selectedIsEquivalent: boolean;
+            sourceSwap: import("@spicenet-io/spiceflow-core").ResolvedSwap | null;
+            sourceExactOutputSwap: import("../../..").ResolvedExactOutputSwap | null;
+            pivot: import("../../../types/supply").PivotRoute | null;
+        };
+        fees: {
+            fundingConversion: import("../../SpiceSupply/lib/feeConversion").FundingConversion | undefined;
+            proceedsUsed: bigint | undefined;
+            fundingShortfall: bigint | undefined;
+            source: {
+                address: `0x${string}`;
+                chainId: number;
+                symbol: string;
+                decimals: number;
+                gasFee: bigint;
+                spicenetFee: bigint;
+            } | null;
+            destinationAmount: bigint | undefined;
+            sourceSpendCap: bigint | undefined;
+            preview: import("../../../types").FeePreview | null;
+            isLoading: boolean;
+            ready: boolean;
+            error: string | null;
+        };
+        amount: {
+            sourceRequiredAmount: bigint | null;
+            parsed: number;
+            isInsufficientBalance: boolean;
+            sourceBalance: number;
+            feesExceedAmount: boolean;
+        };
+        status: {
+            sourceFunding: {
+                matchesPurpose: boolean;
+                matchesSelection: boolean;
+                phase: "complete" | "routing" | "funding";
+                amount: string;
+            } | null;
+            finalizing: boolean;
+            finalizationError: string | null;
+            externalAction: {
+                destinationToken: Address;
+                destinationDecimals: number;
+                amount?: string;
+                phase: "funding" | "routing" | "action" | "complete";
+                confirmedCalls: number;
+                totalCalls: number;
+                requiresRecovery: boolean;
+            } | null;
+            step: import("../../..").SupplyStep;
+            statusMsg: string;
+            txHash: string | null;
+            isExecuting: boolean;
+            error: string | null;
+            showStatusPanel: boolean;
+            paymentResult: import("../../..").PaymentResult | null;
+        };
+        flags: {
+            directExecutionFeeNote: boolean;
+        };
+        retryFinalization: () => void;
+        fundEmbeddedSource: (amount: bigint) => Promise<void>;
+        canExecute: boolean;
+        submitSupply: () => Promise<void>;
+        submitPay: () => Promise<void>;
+        retrySupply: () => void;
+        dismissPaymentStatus: () => void;
+        resolveMaxAmount: (asset: Asset) => Promise<string | null>;
+        resetAfterSuccess: () => void;
+        resetPaymentState: () => void;
+    };
+    candidates: {
+        balance: bigint;
+        balanceFormatted: number;
+        _fundingWallet?: "external" | "embedded";
+        owner?: Address;
+        location?: "external" | "embedded" | "rollup";
+        positionId?: string;
+        _source?: "wallet" | "spice";
+        address: Address;
+        symbol: string;
+        name: string;
+        decimals: number;
+        chainId: number;
+        balanceError?: string;
+        balanceStatus?: "stale";
+        _wrapFromNative?: boolean;
+        balanceUsd: number;
+        priceStatus?: "fresh" | "stale" | "unavailable";
+        isNative: boolean;
+        logoURI?: string;
+        displaySymbol?: string;
+        displayName?: string;
+        displayChainName?: string;
+        receiptTokenId?: string;
+        receiptTokenName?: string;
+        receiptTokenDecimals?: number;
+        chainTokens?: Record<string, {
+            name?: string;
+            decimals?: number;
+        }>;
+        isUniversal?: boolean;
+    }[];
+    source: Asset | null;
+    setSource: import("react").Dispatch<import("react").SetStateAction<Asset | null>>;
+    feeToken: import("@spicenet-io/spiceflow-core").Token | undefined;
+    sourceKey: typeof assetPositionId;
+};

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

@@ -1,6 +1,6 @@
 import React from "react";
-import type { ResolvedDarkPalette } from "../../../utils/theme";
 import type { DestinationToken } from "../../../types/withdraw";
+import type { ResolvedDarkPalette } from "../../../utils/theme";
 interface WithdrawDestinationCardProps {
     header: React.ReactNode;
     amount: string;
@@ -11,7 +11,9 @@ interface WithdrawDestinationCardProps {
     destChainName: string;
     destChainLogo: string | null;
     compatibleDestinationChains: number[];
-    networkSwitchRef: React.RefObject<HTMLButtonElement>;
+    networkSwitchRef: {
+        readonly current: HTMLButtonElement | null;
+    };
     onOpenNetworkPopover: (anchor: HTMLButtonElement | null) => void;
     showNetworkPopover: boolean;
     setShowNetworkPopover: React.Dispatch<React.SetStateAction<boolean>>;

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

@@ -1,6 +1,6 @@
 import React from "react";
+import type { CustomStyles, Theme } from "../../../types/theme";
 import type { ResolvedDarkPalette } from "../../../utils/theme";
-import type { Theme, CustomStyles } from "../../../types/theme";
 interface WithdrawDetailsPanelProps {
     show: boolean;
     onToggle: () => void;
@@ -13,7 +13,9 @@ interface WithdrawDetailsPanelProps {
     destChainName: string;
     destChainLogo: string | null;
     compatibleDestinationChains: number[];
-    txDetailsChainSwitchRef: React.RefObject<HTMLButtonElement>;
+    txDetailsChainSwitchRef: {
+        readonly current: HTMLButtonElement | null;
+    };
     onOpenNetworkPopover: (anchor: HTMLButtonElement | null) => void;
     sourceChainLabel: string;
     sourceDetailsLogo: string | null | undefined;

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

@@ -1,6 +1,6 @@
 import React from "react";
-import type { ResolvedDarkPalette } from "../../../utils/theme";
 import type { Asset } from "../../../types/assets";
+import type { ResolvedDarkPalette } from "../../../utils/theme";
 interface WithdrawSourceCardProps {
     header: React.ReactNode;
     amount: string;
@@ -25,7 +25,9 @@ interface WithdrawSourceCardProps {
         top: number;
         left: number;
     } | null>>;
-    tokenTriggerRef: React.RefObject<HTMLDivElement>;
+    tokenTriggerRef: {
+        readonly current: HTMLDivElement | null;
+    };
     primaryColor: string;
     dark: boolean;
     dk: ResolvedDarkPalette;

package/dist/components/StatusDisplay/parts/StatusPanel.d.ts

@@ -1,4 +1,4 @@
 import React from "react";
-import type { StatusResultItem, StatusPanelProps } from "../../../types/status";
-export type { StatusResultItem, StatusPanelProps };
+import type { StatusPanelProps, StatusResultItem } from "../../../types/status";
+export type { StatusPanelProps, StatusResultItem };
 export declare const StatusPanel: React.FC<StatusPanelProps>;

package/dist/execution/escrowCredit.d.ts

@@ -0,0 +1,18 @@
+import { type Address } from "viem";
+import type { ChainBatch } from "../types/authorization";
+import { type RollupBalanceEntry } from "../utils/rollupBalances";
+export interface EscrowDeposit {
+    chainId: number;
+    token: Address;
+    amount: bigint;
+}
+export declare function collectEscrowDeposits(chainBatches: ChainBatch[]): EscrowDeposit[];
+export declare function waitForEscrowCredit(params: {
+    deposits: EscrowDeposit[];
+    baseline: RollupBalanceEntry[];
+    fetchEntries: () => Promise<RollupBalanceEntry[]>;
+    timeoutMs?: number;
+    intervalMs?: number;
+    signal?: AbortSignal;
+    wait?: (ms: number) => Promise<void>;
+}): Promise<boolean>;

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

package/dist/execution/fundedExecution.d.ts

@@ -0,0 +1,24 @@
+import { type Address } from "viem";
+import type { Asset, SelectedAsset } from "../types/assets";
+import { type PendingDepositRecord } from "../utils/pendingDeposit";
+import type { ExecutionRunner } from "./runner";
+export declare function reconcileFundedAction(record: PendingDepositRecord): Promise<string>;
+export declare function executeFundedPlan(params: {
+    asset?: Asset;
+    embedded: Address;
+    external?: Address;
+    externalWallet?: {
+        getEthereumProvider: () => Promise<any>;
+    } | null;
+    fundExternal: boolean;
+    sourceSpendCap: bigint;
+    identity: string;
+    purpose?: string;
+    selection?: SelectedAsset | null;
+    minimumDestinationAmount?: bigint;
+    actionDefinition?: string;
+    fundOnly?: boolean;
+    assertCurrent: () => void | Promise<void>;
+    run: (options: Parameters<ExecutionRunner["execute"]>[5]) => Promise<string>;
+    onFunding?: () => void;
+}): Promise<string>;