@spicenet-io/spiceflow-ui 3.3.5 → 3.3.6

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

@@ -0,0 +1,31 @@
+import { type Address } from "viem";
+import { type FeeEstimateSummary } from "@spicenet-io/spiceflow-core";
+import type { ChainBatch } from "../../../types/authorization";
+export declare function sumRollupBalanceForChainToken(balances: unknown, chainId: number, tokenAddress: string): bigint;
+export declare function fetchSpiceBalanceForChainToken(apiBaseUrl: string, user: Address, chainId: number, tokenAddress: string): Promise<bigint>;
+export declare function waitForSpiceBalanceIncrease({ apiBaseUrl, user, chainId, tokenAddress, prevBalance, timeoutMs, pollIntervalMs, }: {
+    apiBaseUrl: string;
+    user: Address;
+    chainId: number;
+    tokenAddress: string;
+    prevBalance: bigint;
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+}): Promise<void>;
+export declare function build7702EstimateRequest(user: Address, batches: ChainBatch[]): {
+    user: `0x${string}`;
+    intents: {
+        mode: "7702";
+        signatureType: "ecdsa";
+        signature: `0x${string}`;
+        nbf: number;
+        exp: number;
+        chainBatches: {
+            hash: any;
+            chainId: any;
+            tokenTransfers: import("../../..").TokenTransferConfig[];
+            calls: any;
+        }[];
+    }[];
+};
+export declare function withSpicenetFundingBatch(batches: ChainBatch[], userAddress: Address, feeEstimate?: FeeEstimateSummary): ChainBatch[];

package/dist/components/SpiceLock/parts/LockConfirmationPanel.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import type { LockConfirmationData, LockConfirmationPanelProps } from "../../../types/lock";
+export type { LockConfirmationData, LockConfirmationPanelProps };
+export declare const LockConfirmationPanel: React.FC<LockConfirmationPanelProps>;

package/dist/components/SpiceLock/parts/LockDurationSlider.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import type { LockDurationSliderProps } from "../../../types/lock";
+export type { LockDurationSliderProps };
+export declare const LockDurationSlider: React.FC<LockDurationSliderProps>;

package/dist/components/SpiceLock/parts/LockExpiryRow.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import type { LockExpiryRowProps } from "../../../types/lock";
+export type { LockExpiryRowProps };
+export declare const LockExpiryRow: React.FC<LockExpiryRowProps>;

package/dist/components/SpiceLock/parts/VotingPowerRow.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import type { VotingPowerRowProps } from "../../../types/lock";
+export type { VotingPowerRowProps };
+export declare const VotingPowerRow: React.FC<VotingPowerRowProps>;

package/dist/components/SpicePay/SpicePay.d.ts

@@ -1,4 +1,14 @@
 import React from "react";
-import type { SpicePayProps } from "../../types/pay";
-export type { SpicePayProps };
+import type { Address } from "viem";
+import type { SpiceSupplyProps } from "../../types/supply";
+export type SpicePayProps = Omit<SpiceSupplyProps, "amountDirection" | "destinationToken" | "actionLabel" | "swapDescription" | "directDescription" | "supportedSourceAssets" | "onSuccess" | "onError"> & {
+    paymentTokenAddress: Address;
+    paymentTokenSymbol: string;
+    paymentTokenDecimals: number;
+    paymentTokenLogoURI?: string;
+    paymentChainId: number;
+    ctaLabel?: string;
+    onPaymentSuccess?: (txHash?: string) => void;
+    onPaymentError?: (error: Error) => void;
+};
 export declare const SpicePay: React.FC<SpicePayProps>;

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

@@ -0,0 +1,33 @@
+import { type Address } from "viem";
+import type { ResolvedSwap } from "@spicenet-io/spiceflow-core";
+import type { ChainBatch } from "../../../types/authorization";
+import type { SelectedAsset } from "../../../types/assets";
+import type { SpiceSupplyProps, SupplyBatchBuildOptions } from "../../../types/supply";
+import type { ResolvedExactOutputSwap } from "../../../utils/swapQuotes";
+import type { GaslessExecutionOptions } from "../../../hooks/useSpiceExecution";
+import type { FeeEstimateSummary } from "@spicenet-io/spiceflow-core";
+type EstimateGaslessFn = (chainBatches: ChainBatch[], tokenAddress: string, tokenTransferAmount: bigint, options?: GaslessExecutionOptions) => Promise<FeeEstimateSummary>;
+export declare function scaleTokenAmount(amount: bigint, fromDecimals: number, toDecimals: number): bigint;
+export interface BatchBuilderContext {
+    currentPaymentAmount: string;
+    destinationToken: SpiceSupplyProps["destinationToken"];
+    embeddedWalletAddress: string | null | undefined;
+    providerEmbeddedAddress: string | null | undefined;
+    address: string | null | undefined;
+    isNon7702: boolean;
+    isPayMode: boolean;
+    resolvedChainId: number;
+    buildActionCalls: SpiceSupplyProps["buildActionCalls"];
+    feeExecutionMode: SpiceSupplyProps["feeExecutionMode"];
+    buildSpicenetBatch: SpiceSupplyProps["buildSpicenetBatch"];
+    selectedAsset: SelectedAsset | null;
+    needsSwap: boolean;
+    resolvedSwap: ResolvedSwap | null;
+    exactOutputSwap: ResolvedExactOutputSwap | null;
+    quoteAmountOut: bigint | null;
+    resolvedTokenIn: Address | null;
+}
+export declare function buildPayChainBatches(ctx: BatchBuilderContext, options?: SupplyBatchBuildOptions): Promise<ChainBatch[]>;
+export declare function buildSupplyChainBatches(ctx: BatchBuilderContext, options?: SupplyBatchBuildOptions): Promise<ChainBatch[]>;
+export declare function estimateRequiredGrossFunding(requiredNetFunding: bigint, buildBatches: (grossFundingAmount: bigint) => ChainBatch[] | Promise<ChainBatch[]>, fundingToken: Address, estimateGasless: EstimateGaslessFn, gaslessOptions?: Pick<GaslessExecutionOptions, "useCustomTransfers" | "userOverride">): Promise<bigint>;
+export {};

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

@@ -0,0 +1,67 @@
+import type { Dispatch, MutableRefObject, SetStateAction } from "react";
+import { type Address } from "viem";
+import type { ChainBatch } from "../../../types/authorization";
+import type { SelectedAsset } from "../../../types/assets";
+import type { SpiceSupplyProps, SupplyBatchBuildOptions } from "../../../types/supply";
+import type { ResolvedExactOutputSwap } from "../../../utils/swapQuotes";
+import type { GaslessExecutionOptions, GaslessProgress } from "../../../hooks/useSpiceExecution";
+import type { GaslessRunner } from "../../../execution/gasless";
+export type SupplyStep = "idle" | "signing-delegation" | "signing-intent" | "submitting" | "executing" | "success" | "error";
+export type PaymentResult = {
+    status: "processing" | "success" | "failed";
+    txHash?: string;
+    error?: string;
+};
+type BuildPayBatchesFn = (options?: SupplyBatchBuildOptions) => Promise<ChainBatch[]>;
+type BuildSupplyBatchesFn = (options?: SupplyBatchBuildOptions) => Promise<ChainBatch[]>;
+type EstimateRequiredGrossFundingFn = (requiredNetFunding: bigint, buildBatches: (grossFundingAmount: bigint) => ChainBatch[] | Promise<ChainBatch[]>, fundingToken: Address, gaslessOptions?: Pick<GaslessExecutionOptions, "useCustomTransfers" | "userOverride">) => Promise<bigint>;
+export type ExecutorContext = {
+    selectedAsset: SelectedAsset | null;
+    parsedAmount: number;
+    currentPaymentAmount: string;
+    isInsufficientBalance: boolean;
+    isPayMode: boolean;
+    isNon7702: boolean;
+    isSourceDestToken: boolean;
+    needsSwap: boolean;
+    exactOutputSwap: ResolvedExactOutputSwap | null;
+    selectedIsEquivalent: boolean;
+    resolvedTokenIn: Address | null;
+    embeddedWalletAddress: string | null | undefined;
+    providerEmbeddedAddress: string | null | undefined;
+    externalWallet: {
+        getEthereumProvider: () => Promise<any>;
+    } | null | undefined;
+    externalWalletAddress: string | null | undefined;
+    address: string | null | undefined;
+    isConnected: boolean;
+    ready: boolean;
+    authenticated: boolean;
+    provider: string | null | undefined;
+    resolvedChainId: number;
+    executionTokenAddress: Address;
+    gasless: GaslessRunner & {
+        buildPayChainBatches: BuildPayBatchesFn;
+        buildSupplyChainBatches: BuildSupplyBatchesFn;
+        estimateRequiredGrossFunding: EstimateRequiredGrossFundingFn;
+        onProgress: (progress: GaslessProgress) => void;
+    };
+    ui: {
+        setError: Dispatch<SetStateAction<string | null>>;
+        setStep: Dispatch<SetStateAction<SupplyStep>>;
+        setStatusMsg: Dispatch<SetStateAction<string>>;
+        setTxHash: Dispatch<SetStateAction<string | null>>;
+        setIsExecuting: Dispatch<SetStateAction<boolean>>;
+        setShowStatusPanel: Dispatch<SetStateAction<boolean>>;
+        setPaymentResult: Dispatch<SetStateAction<PaymentResult | null>>;
+    };
+    refs: {
+        spiceDepositSubmittedRef: MutableRefObject<boolean>;
+        abortControllerRef: MutableRefObject<AbortController | null>;
+    };
+} & Pick<SpiceSupplyProps, "destinationToken" | "buildActionCalls" | "feeExecutionMode" | "buildSpicenetBatch" | "onPayExecute" | "onError">;
+export declare function executeSupply(ctx: ExecutorContext): Promise<void>;
+export declare function executeDirectExternalAction(ctx: ExecutorContext): Promise<`0x${string}` | undefined>;
+export declare function executeNon7702Pay(ctx: ExecutorContext): Promise<string>;
+export declare function executePay(ctx: ExecutorContext): Promise<void>;
+export {};

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

@@ -0,0 +1,43 @@
+import { type Address } from "viem";
+import { type FeeEstimateSummary } from "@spicenet-io/spiceflow-core";
+import type { FeePreview } from "../../../types/ui";
+import type { ChainBatch } from "../../../types/authorization";
+import type { SelectedAsset } from "../../../types/assets";
+import type { SpiceSupplyProps, SupplyBatchBuildOptions } from "../../../types/supply";
+import type { ResolvedExactOutputSwap } from "../../../utils/swapQuotes";
+import type { ResolvedSwap } from "@spicenet-io/spiceflow-core";
+import type { GaslessExecutionOptions } from "../../../hooks/useSpiceExecution";
+type EstimateGaslessFn = (chainBatches: ChainBatch[], tokenAddress: string, tokenTransferAmount: bigint, options?: GaslessExecutionOptions) => Promise<FeeEstimateSummary>;
+type BuildPayBatchesFn = (options?: SupplyBatchBuildOptions) => Promise<ChainBatch[]>;
+type BuildSupplyBatchesFn = (options?: SupplyBatchBuildOptions) => Promise<ChainBatch[]>;
+type EstimateRequiredGrossFundingFn = (requiredNetFunding: bigint, buildBatches: (grossFundingAmount: bigint) => ChainBatch[] | Promise<ChainBatch[]>, fundingToken: Address, gaslessOptions?: Pick<GaslessExecutionOptions, "useCustomTransfers" | "userOverride">) => Promise<bigint>;
+export interface FeePreviewContext {
+    selectedAsset: SelectedAsset | null;
+    isPayMode: boolean;
+    parsedAmount: number;
+    needsSwap: boolean;
+    exactOutputSwap: ResolvedExactOutputSwap | null;
+    isNon7702: boolean;
+    isSourceDestToken: boolean;
+    currentPaymentAmount: string;
+    destinationToken: SpiceSupplyProps["destinationToken"];
+    feeExecutionMode: SpiceSupplyProps["feeExecutionMode"];
+    resolvedTokenIn: Address | null;
+    embeddedWalletAddress: string | null | undefined;
+    providerEmbeddedAddress: string | null | undefined;
+    resolvedChainId: number;
+    isConnected: boolean;
+    address: string | null | undefined;
+    ready: boolean;
+    authenticated: boolean;
+    isDirect: boolean;
+    resolvedSwap: ResolvedSwap | null;
+    isQuoting: boolean;
+    executionTokenAddress: Address;
+    buildPayChainBatches: BuildPayBatchesFn;
+    buildSupplyChainBatches: BuildSupplyBatchesFn;
+    estimateGasless: EstimateGaslessFn;
+    estimateRequiredGrossFunding: EstimateRequiredGrossFundingFn;
+}
+export declare function estimateFeePreview(ctx: FeePreviewContext): Promise<FeePreview | null>;
+export {};

package/dist/components/SpiceSupply/{DestinationEstimate.d.ts → parts/DestinationEstimate.d.ts}

@@ -1,6 +1,6 @@
 import React from "react";
-import type { ResolvedExactOutputSwap } from "../../utils/swapQuotes";
-import type { ResolvedDarkPalette } from "../../utils/resolveTheme";
+import type { ResolvedExactOutputSwap } from "../../../utils/swapQuotes";
+import type { ResolvedDarkPalette } from "../../../utils/theme";
 interface DestinationEstimateProps {
     variant: "supply" | "pay";
     destinationSymbol: string;

package/dist/components/SpiceSupply/{SupplyEstimate.d.ts → parts/SupplyEstimate.d.ts}

@@ -1,4 +1,4 @@
 import React from "react";
-import type { SupplyEstimateProps } from "../../types/supply";
+import type { SupplyEstimateProps } from "../../../types/supply";
 export type { SupplyEstimateProps };
 export declare const SupplyEstimate: React.FC<SupplyEstimateProps>;

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

@@ -0,0 +1,34 @@
+import type { Dispatch, MutableRefObject, SetStateAction } from "react";
+import type { GaslessRunner } from "../../../execution/gasless";
+import type { DestinationToken, SpiceWithdrawProps } from "../../../types/withdraw";
+import type { ChainBatch } from "../../../types/authorization";
+import type { GaslessProgress } from "../../../hooks/useSpiceExecution";
+export type WithdrawalExecutionContext = {
+    actionId: string;
+    intentId: string;
+    intentIndex: number;
+    totalSteps: number;
+};
+export type WithdrawExecutorContext = {
+    batches: ChainBatch[];
+    walletAddress: string | null | undefined;
+    recipient: string | null | undefined;
+    token: DestinationToken | null;
+    chainId: number | null;
+    amount: string;
+    receiveAmountRaw: bigint;
+    gasFee: bigint | null;
+    isNon7702: boolean;
+    buildWithdrawBatches: (spicenetFundingAmount?: bigint) => ChainBatch[];
+    gasless: GaslessRunner;
+    ui: {
+        setIsExecuting: Dispatch<SetStateAction<boolean>>;
+        setExecutionError: Dispatch<SetStateAction<string | null>>;
+        setExecutionProgress: Dispatch<SetStateAction<GaslessProgress | null>>;
+        setLockedGasFee: Dispatch<SetStateAction<bigint | null>>;
+    };
+    executionContextRef: MutableRefObject<WithdrawalExecutionContext | null>;
+    isMountedRef: MutableRefObject<boolean>;
+} & Pick<SpiceWithdrawProps, "onWithdrawExecute" | "onWithdrawSuccess" | "onWithdrawError" | "buildSpicenetBatch">;
+export declare function executeWithdraw(ctx: WithdrawExecutorContext): Promise<void>;
+export declare function retryWithdraw(ctx: WithdrawExecutorContext): Promise<void>;

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

@@ -0,0 +1,6 @@
+import type { FeeEstimateSummary } from "@spicenet-io/spiceflow-core";
+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, symbol?: string): string;
+export declare function getFeeAdjustedWithdrawFunding(feeEstimate: FeeEstimateSummary, fallbackChainId: number): bigint | null;

package/dist/components/SpiceWithdraw/{SelectPopover.d.ts → parts/SelectPopover.d.ts}

@@ -1,5 +1,5 @@
 import React from "react";
-import type { SelectPopoverItem } from "../../types/withdraw";
+import type { SelectPopoverItem } from "../../../types/withdraw";
 export type { SelectPopoverItem };
 interface SelectPopoverProps {
     isOpen: boolean;

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/components/SpiceWithdraw/parts/WithdrawDetailsPanel.d.ts

@@ -0,0 +1,39 @@
+import React from "react";
+import type { ResolvedDarkPalette } from "../../../utils/theme";
+import type { Theme, CustomStyles } from "../../../types/theme";
+interface WithdrawDetailsPanelProps {
+    show: boolean;
+    onToggle: () => void;
+    showCustomAddress: boolean;
+    setShowCustomAddress: React.Dispatch<React.SetStateAction<boolean>>;
+    customRecipient: string;
+    setCustomRecipient: (value: string) => void;
+    externalAddress: string | null | undefined;
+    recipientAddress: string | null | undefined;
+    destChainName: string;
+    destChainLogo: string | null;
+    compatibleDestinationChains: number[];
+    txDetailsChainSwitchRef: React.RefObject<HTMLButtonElement>;
+    onOpenNetworkPopover: (anchor: HTMLButtonElement | null) => void;
+    sourceChainLabel: string;
+    sourceDetailsLogo: string | null | undefined;
+    sourceTokenLabel: string;
+    amount: string;
+    totalSourceDebitDisplay: string;
+    receiveAmountDisplay: string;
+    destTokenSymbol: string;
+    shouldQuoteWithdrawGas: boolean;
+    estimatingFee: boolean;
+    feeError: string | null;
+    displayedGasFee: bigint | null;
+    selectedDestToken: {
+        decimals: number;
+        symbol: string;
+    } | null;
+    theme: Theme;
+    styles: CustomStyles | undefined;
+    dark: boolean;
+    dk: ResolvedDarkPalette;
+}
+export declare const WithdrawDetailsPanel: React.FC<WithdrawDetailsPanelProps>;
+export {};

package/dist/components/StatusDisplay/index.d.ts

@@ -1,4 +1,5 @@
 export { StatusDisplay } from "./StatusDisplay";
-export { StatusIcon } from "./StatusIcon";
-export { StepItem } from "./StepItem";
+export { StatusPanel } from "./parts/StatusPanel";
+export { StatusIcon } from "./parts/StatusIcon";
+export { StepItem } from "./parts/StepItem";
 export type { StatusIconProps, StepItemProps } from "../../types/status";

package/dist/components/StatusDisplay/{StatusIcon.d.ts → parts/StatusIcon.d.ts}

@@ -1,3 +1,3 @@
 import React from "react";
-import type { StatusIconProps } from "../../types/status";
+import type { StatusIconProps } from "../../../types/status";
 export declare const StatusIcon: React.FC<StatusIconProps>;

package/dist/components/StatusDisplay/{StatusPanel.d.ts → parts/StatusPanel.d.ts}

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

package/dist/components/StatusDisplay/{StepItem.d.ts → parts/StepItem.d.ts}

@@ -1,3 +1,3 @@
 import React from "react";
-import type { StepItemProps } from "../../types/status";
+import type { StepItemProps } from "../../../types/status";
 export declare const StepItem: React.FC<StepItemProps>;

package/dist/execution/gasless.d.ts

@@ -0,0 +1,7 @@
+import type { FeeEstimateSummary } from "@spicenet-io/spiceflow-core";
+import type { ChainBatch } from "../types/authorization";
+import type { GaslessExecutionOptions, GaslessProgress } from "../hooks/useSpiceExecution";
+export type GaslessRunner = {
+    estimateGasless: (chainBatches: ChainBatch[], tokenAddress: string, tokenTransferAmount: bigint, options?: GaslessExecutionOptions) => Promise<FeeEstimateSummary>;
+    executeGasless: (chainBatches: ChainBatch[], tokenAddress: string, tokenTransferAmount: bigint, onProgress?: (progress: GaslessProgress) => void, signal?: AbortSignal, options?: GaslessExecutionOptions) => Promise<string>;
+};

package/dist/execution/pollIntentStep.d.ts

@@ -0,0 +1,28 @@
+export declare const FIRST_STEP_POLL_MS = 350;
+export declare const STEP_POLL_MS = 1000;
+export type PollIntentStepOptions = {
+    actionId: string;
+    intentIndex: number;
+    intentId: string;
+    stepIndex: number;
+    maxPolls?: number;
+    maxExecuteAttempts?: number;
+    pollsBeforeRetry?: number;
+    maxConsecutiveStatusErrors?: number;
+    onStatusMessage?: (message: string, txHash?: string) => void;
+    signal?: AbortSignal;
+    chainId?: number;
+};
+export declare function pollIntentStepUntilSuccess(options: PollIntentStepOptions): Promise<string | undefined>;
+export declare function runAllIntentSteps(options: {
+    actionId: string;
+    intentIndex: number;
+    intentId: string;
+    totalSteps: number;
+    delayBeforeSpicenetStepMs?: number;
+    isSpicenetStep?: (stepIndex: number) => boolean;
+    maxExecuteAttemptsForStep?: (stepIndex: number) => number;
+    maxPolls?: number;
+    onStatusMessage?: (message: string, txHash?: string) => void;
+    signal?: AbortSignal;
+}): Promise<string | undefined>;

package/dist/hooks/index.d.ts

@@ -1,4 +1,4 @@
-export { useWalletBalances, fetchBalances } from "./useAssets";
+export { useWalletBalances, fetchBalances } from "./useWalletBalances";
 export { useAssetInput } from "./useAssetInput";
 export type { UseAssetInputReturn } from "./useAssetInput";
 export { useWallet } from "./useWallet";
@@ -6,9 +6,9 @@ export type { UseWalletReturn, WalletState, WalletActions } from "./useWallet";
 export { useEmbeddedWalletAddress } from "./useEmbeddedWalletAddress";
 export { useSpiceAssets } from "./useSpiceAssets";
 export type { UseSpiceAssetsConfig, UseSpiceAssetsReturn, } from "./useSpiceAssets";
-export { useSpiceExecution } from "./useGaslessExecution";
-export { useSpiceExecution as useGaslessExecution } from "./useGaslessExecution";
-export type { GaslessProgress, GaslessStep, GaslessExecutionOptions, OnProgress, } from "./useGaslessExecution";
+export { useSpiceExecution } from "./useSpiceExecution";
+export { useSpiceExecution as useGaslessExecution } from "./useSpiceExecution";
+export type { GaslessProgress, GaslessStep, GaslessExecutionOptions, OnProgress, } from "./useSpiceExecution";
 export { useLockDuration } from "./useLockDuration";
 export type { UseLockDurationReturn } from "./useLockDuration";
 export type { VerifiedPendingDeposit } from "./usePendingDeposit";

package/dist/hooks/{useLockDuration/index.d.ts → useLockDuration.d.ts}

@@ -1,4 +1,4 @@
-import { LockDurationOption } from "../../types/lock";
+import { LockDurationOption } from "../types/lock";
 export interface UseLockDurationReturn {
     selectedDurationIdx: number;
     setSelectedDurationIdx: (idx: number) => void;

package/dist/hooks/{useSpiceAssets/index.d.ts → useSpiceAssets.d.ts}

@@ -1,5 +1,5 @@
 import { Address } from "viem";
-import { Asset } from "../../types/assets";
+import { Asset } from "../types/assets";
 export interface UseSpiceAssetsConfig {
     address?: Address | string;
     supportedChains?: number[];

package/dist/hooks/useSpiceBrand.d.ts

@@ -1,4 +1,4 @@
-import type { ResolvedDarkPalette } from "../utils/resolveTheme";
+import type { ResolvedDarkPalette } from "../utils/theme";
 import type { Theme, SpiceTheme, CustomStyles } from "../types/theme";
 export interface UseSpiceBrandResult {
     brand: SpiceTheme | undefined;
@@ -8,5 +8,13 @@ export interface UseSpiceBrandResult {
     primaryColor: string;
     dk: ResolvedDarkPalette;
     palette: ResolvedDarkPalette;
+    fontFamily: string;
+    monoFont: string;
+    inputDark: boolean;
+    cardBg: string;
+    cardBorder: string;
+    textPrimary: string;
+    textSecondary: string;
+    subtitleText: string;
 }
 export declare function useSpiceBrand(componentStyles?: CustomStyles, componentDark?: boolean): UseSpiceBrandResult;

package/dist/hooks/{useGaslessExecution/index.d.ts → useSpiceExecution.d.ts}

@@ -1,6 +1,6 @@
 import { Address } from "viem";
-import { ChainBatch, Call } from "../../types/authorization";
-import type { FeeEstimateSummary } from "../../types/unified";
+import { ChainBatch, Call } from "../types/authorization";
+import type { FeeEstimateSummary } from "@spicenet-io/spiceflow-core";
 export type { Call, ChainBatch };
 export type GaslessStep = "idle" | "building" | "signing-delegation" | "signing-intent" | "submitting" | "executing" | "confirming-rollup" | "success" | "error";
 export interface GaslessProgress {
@@ -22,6 +22,7 @@ export interface GaslessExecutionOptions {
     useCustomTransfers?: boolean;
     userOverride?: Address;
     signAuthorizationsForEstimate?: boolean;
+    feeExecutionMode?: "backend-transfer" | "user-transfer";
 }
 export declare function useSpiceExecution(): {
     executeGasless: (chainBatches: ChainBatch[], tokenAddress: string, tokenTransferAmount: bigint, onProgress?: OnProgress, signal?: AbortSignal, options?: GaslessExecutionOptions) => Promise<string>;

package/dist/hooks/{useStatus/index.d.ts → useStatus.d.ts}

@@ -1,4 +1,4 @@
-import { IntentStatus, SwapStep } from "../../types/status";
+import { IntentStatus, SwapStep } from "../types/status";
 export interface UseStatusConfig {
     checkStepStatus: (intentId: string, stepId: number) => Promise<{
         success: boolean;

package/dist/hooks/{useAssets/index.d.ts → useWalletBalances.d.ts}

@@ -1,5 +1,5 @@
 import { Address } from "viem";
-import { Asset, MultiChainBalances } from "../../types/assets";
+import { Asset, MultiChainBalances } from "../types/assets";
 export declare const fetchBalances: (walletAddress: Address, supportedChains?: number[]) => Promise<MultiChainBalances>;
 export interface UseAssetsConfig {
     address?: Address;