@spicenet-io/spiceflow-ui 4.9.6-embedded-balances.0 → 4.10.0-dev.20260909.1

package/README.md

@@ -108,55 +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.
-
-### Host-supplied token logos
-
-`AccountDisplay.tokenLogos` maps a token symbol to a logo URL, the same key
-shape `tokenPrices` uses. A discovered embedded-wallet balance falls back to
-it when the RPC provider returns no logo, which is what happens for a token
-that is not in the chain's configured token list. Provider metadata still
-wins when it has a logo.
-
-```tsx
-<AccountDisplay tokenLogos={{ REPPO: reppoLogoUrl }} />
-```
-
-### 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.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-CDEv1O2j.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;

package/dist/auth-privy.js

@@ -1,2 +1,2 @@
 "use client";
-import{P as g}from"./privy-5n1m7sMG.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-BV1FYtxg.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/AccountHeader.d.ts

@@ -5,6 +5,7 @@ interface AccountHeaderProps {
     status: "active" | "inactive";
     statusLabel?: string;
     totalUsdValue: number;
+    hasUnpricedAssets?: boolean;
     breakdownSubtitle: string;
     showUsdSummary?: boolean;
     address?: string;

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,12 +2,13 @@ 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";
     statusLabel?: string;
     totalUsdValue: number;
+    hasUnpricedAssets?: boolean;
     breakdownSubtitle: string;
     showUsdSummary?: boolean;
     address?: string;
@@ -17,7 +18,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/tokenPrices.d.ts

@@ -0,0 +1,7 @@
+import type { Asset } from "../../types/assets";
+type PriceableAsset = Pick<Asset, "symbol" | "name" | "displaySymbol" | "displayName" | "receiptTokenName"> & {
+    chainId: number;
+    address: string;
+};
+export declare function getTokenPrice(asset: PriceableAsset, tokenPrices: Record<string, number>): number;
+export {};

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

@@ -4,14 +4,14 @@ import type React from "react";
 export interface CustomSectionItem {
     tokenSymbol: string;
     tokenLogoURI?: string;
-    label: string;
+    label: React.ReactNode;
     displayValue: string;
     valueColor?: "green" | "red" | "default";
 }
 export interface CustomSection {
     title: string;
     items: CustomSectionItem[];
-    totalValue: number;
+    totalValue?: number;
 }
 export interface SpiceAsset {
     tokenAddress: string;
@@ -24,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 {
@@ -44,14 +42,13 @@ export interface AccountDisplayProps {
     customSections?: CustomSection[];
     extraAssets?: SpiceAsset[];
     tokenPrices?: Record<string, number>;
-    tokenLogos?: Record<string, string>;
     breakdownLabels?: BreakdownLabel[];
     notice?: AccountNotice | null;
     styles?: CustomStyles;
     dark?: boolean;
     onDepositSuccess?: () => void;
     onDepositClick?: () => void;
-    onWithdrawClick?: (receiptTokenId?: string) => void;
+    onWithdrawClick?: () => void;
     onCompleteDeposit?: (deposit: VerifiedPendingDeposit) => void;
     showModeToggle?: boolean;
     defaultMode?: "7702" | "non7702";

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

@@ -3,7 +3,6 @@ import { type FeeEstimateSummary, type ResolvedSwap } from "@spicenet-io/spicefl
 import type { ChainAuthorization, ChainBatch } from "../../../types/authorization";
 import type { Asset } from "../../../types/assets";
 export declare function isDirectLockSource(asset: Asset, lockChainId: number): boolean;
-export declare function isInPlaceLockSource(asset: Asset, lockChainId: number): boolean;
 export declare function composeLockSwapBatches(batches: ChainBatch[], params: {
     chainId: number;
     recipient: Address;

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 } 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) => Promise<ChainBatch[]>;
+}): Promise<SupplyFeeQuote>;

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,12 @@ export interface BatchBuilderContext {
     externalWalletAddress: string | null | undefined;
     address: string | null | undefined;
     recipient?: Address;
+    swapOutputRecipient?: Address;
     isNon7702: boolean;
     isPayMode: boolean;
+    isFeeInclusiveInput?: boolean;
+    swapInputAmount?: bigint | null;
+    feeOnlyAction?: boolean;
     resolvedChainId: number;
     buildActionCalls: SpiceSupplyProps["buildActionCalls"];
     feeExecutionMode: SpiceSupplyProps["feeExecutionMode"];
@@ -27,7 +33,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,55 @@
+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 reconcileControlledFunding(scope: string): Promise<boolean>;
+export declare function executeWithSourceFunding(params: {
+    scope: string;
+    recovery?: "resume" | "balance";
+    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,24 +1,33 @@
+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";
 import type { ResolvedExactOutputSwap } from "../../../utils/swapQuotes";
 import type { ExecutionProgress } from "../../../hooks/useSpiceExecution";
 import type { ExecutionRunner } from "../../../execution/runner";
-export type SupplyStep = "idle" | "signing-delegation" | "signing-intent" | "submitting" | "executing" | "success" | "error";
+export type SupplyStep = "idle" | "building" | "signing-delegation" | "signing-intent" | "submitting" | "executing" | "success" | "error";
 export type PaymentResult = {
     status: "processing" | "success" | "failed";
     txHash?: string;
     error?: string;
 };
+export { isExternalSource } from "./buildBatches";
 export type ExecutorContext = {
+    signal?: AbortSignal;
     selectedAsset: SelectedAsset | null;
     parsedAmount: number;
     currentPaymentAmount: string;
     isInsufficientBalance: boolean;
     isPayMode: boolean;
     isFeeInclusiveInput?: boolean;
+    swapInputAmount?: bigint | null;
+    feeOnlyAction?: boolean;
+    actionProceeds?: SpiceSupplyProps["actionProceeds"];
+    validateFeeQuote?: () => void;
     isNon7702: boolean;
     isSourceDestToken: boolean;
     needsSwap: boolean;
@@ -43,7 +52,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 +79,7 @@ export type ExecutorContext = {
         abortControllerRef: MutableRefObject<AbortController | null>;
     };
 } & Pick<SpiceSupplyProps, "destinationToken" | "buildActionCalls" | "feeExecutionMode" | "buildSpicenetBatch" | "onPayExecute" | "onSuccess">;
+export declare function sourceFundingSelection(ctx: ExecutorContext): SelectedAsset | null;
+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,63 @@
+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 reconcileExternalFunding(scope: string): Promise<boolean>;
+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;
+    recovery?: "resume" | "balance";
+    ctx: ExecutorContext;
+    buildActionCalls: SpiceSupplyProps["buildActionCalls"];
+    onRecord: (record: ExternalActionRecord | null) => void;
+    isCurrent?: () => boolean;
+}): Promise<void>;
+export {};

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

@@ -0,0 +1,16 @@
+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;
+}
+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 { 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" | "resolveActionOutputCredits">;

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

@@ -1,3 +1,5 @@
+import { type FundingConversion } from "./feeConversion";
+import type { LiquidityVenuesConfig } from "../../../utils/crossChainRouter/venueConfig";
 import { type Address } from "viem";
 import { type FeeEstimateSummary } from "@spicenet-io/spiceflow-core";
 import type { FeePreview } from "../../../types/ui";
@@ -14,10 +16,15 @@ export type SupplyFeeQuote = {
     preview: FeePreview;
     feeEstimate: FeeEstimateSummary | null;
     grossFundingAmount?: bigint;
+    proceedsUsed?: bigint;
+    proceedsAvailable?: bigint;
+    fundingConversion?: FundingConversion;
+    fundingBatches?: ChainBatch[];
 };
 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 +43,7 @@ export declare function estimatePayFunding(args: {
 export declare function estimateSupplyMaxAmount(ctx: {
     asset: Asset;
     isPayMode: boolean;
+    isFeeInclusiveInput?: boolean;
     isNon7702: boolean;
     needsSwap: boolean;
     isQuoting: boolean;
@@ -46,10 +54,15 @@ export declare function estimateSupplyMaxAmount(ctx: {
     feeExecutionMode: SpiceSupplyProps["feeExecutionMode"];
 }): Promise<string | null>;
 export interface FeePreviewContext {
+    liquidityVenues?: LiquidityVenuesConfig;
+    maxSlippage?: number;
+    resolveExactOutputSwap?: SpiceSupplyProps["resolveExactOutputSwap"];
     signal?: AbortSignal;
     selectedAsset: SelectedAsset | null;
     isPayMode: boolean;
     isFeeInclusiveInput?: boolean;
+    feeOnlyAction?: boolean;
+    actionProceeds?: SpiceSupplyProps["actionProceeds"];
     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/intentSigning.d.ts

@@ -2,11 +2,12 @@ import { type Address, type Hex } from "viem";
 import type { ChainAuthorization, ChainBatch } from "../types/authorization";
 import type { WalletActions } from "../hooks/useWallet";
 export declare function build7702IntentDigest(chainBatches: ChainBatch[], exp: bigint): `0x${string}`;
-export declare function sign7702IntentDigest(actions: Pick<WalletActions, "signMessage">, chainBatches: ChainBatch[], exp: bigint, signal?: AbortSignal): Promise<Hex>;
+export declare function sign7702IntentDigest(actions: Pick<WalletActions, "signMessage">, chainBatches: ChainBatch[], exp: bigint, signal?: AbortSignal, onSignatureRequested?: () => void): Promise<Hex>;
 export declare function getChainAuthorizations(params: {
     chainBatches: ChainBatch[];
     signingAddress: Address;
-    actions: Pick<WalletActions, "signAuthorization">;
+    actions: Pick<WalletActions, "signAuthorization" | "prepareSigning">;
     cache?: Map<string, ChainAuthorization>;
     signal?: AbortSignal;
+    onSignatureRequested?: () => void;
 }): Promise<ChainAuthorization[]>;

package/dist/execution/pollIntentStep.d.ts

@@ -1,3 +1,8 @@
+type StepResult = {
+    status: string;
+    transactionHash?: string;
+    error?: string;
+};
 type PollIntentStepOptions = {
     actionId: string;
     intentIndex: number;
@@ -8,11 +13,7 @@ type PollIntentStepOptions = {
     pollsBeforeRetry?: number;
     maxConsecutiveStatusErrors?: number;
     onStatusMessage?: (message: string, txHash?: string) => void;
-    onStepUpdate?: (result: {
-        status: string;
-        transactionHash?: string;
-        error?: string;
-    }) => void;
+    onStepUpdate?: (result: StepResult) => void;
     signal?: AbortSignal;
     chainId?: number;
 };
@@ -27,11 +28,7 @@ export declare function runAllIntentSteps(options: {
     maxExecuteAttemptsForStep?: (stepIndex: number) => number;
     maxPolls?: number;
     onStatusMessage?: (message: string, txHash?: string) => void;
-    onStepUpdate?: (stepIndex: number, result: {
-        status: string;
-        transactionHash?: string;
-        error?: string;
-    }) => void;
+    onStepUpdate?: (stepIndex: number, result: StepResult) => void;
     signal?: AbortSignal;
 }): Promise<string | undefined>;
 export {};