@rainlanguage/ui-components 0.0.1-alpha.24 → 0.0.1-alpha.240

package/dist/services/time.js

@@ -1,3 +1,10 @@
+import dayjs from "dayjs";
+import bigIntSupport from "dayjs/plugin/bigIntSupport";
+import localizedFormat from "dayjs/plugin/localizedFormat";
+import utc from "dayjs/plugin/utc";
+dayjs.extend(bigIntSupport);
+dayjs.extend(localizedFormat);
+dayjs.extend(utc);
 export const TIME_DELTA_24_HOURS = 60 * 60 * 24;
 export const TIME_DELTA_48_HOURS = TIME_DELTA_24_HOURS * 2;
 export const TIME_DELTA_7_DAYS = TIME_DELTA_24_HOURS * 7;
@@ -6,12 +13,87 @@ export const TIME_DELTA_1_YEAR = TIME_DELTA_24_HOURS * 365;
 export function dateTimestamp(date) {
     return Math.floor(date.getTime() / 1000);
 }
+export function formatTimestampSecondsAsLocal(timestampSeconds) {
+    return dayjs(timestampSeconds * BigInt("1000"))
+        .utc()
+        .format("L LT");
+}
+export function timestampSecondsToUTCTimestamp(timestampSeconds) {
+    return dayjs(timestampSeconds * BigInt("1000")).unix();
+}
+/**
+ * Method to put a timeout on a promise, throws the exception if promise is not settled within the time
+ * @param promise - The original promise
+ * @param time - The time in ms
+ * @param exception - The exception to reject with if time runs out before original promise settlement
+ * @returns A new promise that gets settled with initial promise settlement or rejected with exception value
+ * if the time runs out before the main promise settlement
+ */
+export async function promiseTimeout(promise, time, exception) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let timeout;
+    return Promise.race([
+        promise,
+        new Promise((_resolve, reject) => (timeout = setTimeout(reject, time, exception))),
+    ]).finally(() => clearTimeout(timeout));
+}
 if (import.meta.vitest) {
-    const { it, expect } = import.meta.vitest;
-    it('should get date timestamp in seconds', () => {
-        const date = new Date(2022, 1, 16, 17, 32, 11, 168);
-        const result = dateTimestamp(date);
-        const expected = Math.floor(date.getTime() / 1000);
-        expect(result).toEqual(expected);
+    const { describe, it, expect, vi } = import.meta.vitest;
+    describe("Date and timestamp utilities", () => {
+        describe("formatTimestampSecondsAsLocal", () => {
+            it("converts timestamp to local format", () => {
+                const result = formatTimestampSecondsAsLocal(BigInt("1672531200")); // Jan 1, 2023 12:00 AM
+                expect(result).toBe("01/01/2023 12:00 AM");
+            });
+        });
+        describe("timestampSecondsToUTCTimestamp", () => {
+            it("converts bigint timestamp to UTCTimestamp", () => {
+                const result = timestampSecondsToUTCTimestamp(BigInt("1672531200"));
+                expect(result).toBe(1672531200);
+            });
+        });
+    });
+    describe("promiseTimeout", () => {
+        it("resolves when promise resolves before timeout", async () => {
+            const testValue = "test";
+            const promise = Promise.resolve(testValue);
+            const result = await promiseTimeout(promise, 100, new Error("Timeout"));
+            expect(result).toBe(testValue);
+        });
+        it("rejects when promise times out", async () => {
+            const promise = new Promise((resolve) => setTimeout(resolve, 200));
+            const exception = new Error("Timeout");
+            await expect(promiseTimeout(promise, 100, exception)).rejects.toThrow(exception);
+        });
+        it("rejects when original promise rejects", async () => {
+            const error = new Error("Original rejection");
+            const promise = Promise.reject(error);
+            await expect(promiseTimeout(promise, 100, new Error("Timeout"))).rejects.toThrow(error);
+        });
+        it("clears timeout after promise resolution", async () => {
+            vi.spyOn(global, "clearTimeout");
+            const promise = Promise.resolve("test");
+            await promiseTimeout(promise, 100, new Error("Timeout"));
+            expect(clearTimeout).toHaveBeenCalled();
+        });
+        it("clears timeout after promise rejection", async () => {
+            vi.spyOn(global, "clearTimeout");
+            const promise = Promise.reject(new Error("Original rejection"));
+            try {
+                await promiseTimeout(promise, 100, new Error("Timeout"));
+            }
+            catch {
+                // Ignore the error
+            }
+            expect(clearTimeout).toHaveBeenCalled();
+        });
+    });
+    describe("dateTimestamp", () => {
+        it("should get date timestamp in seconds", () => {
+            const date = new Date(2022, 1, 16, 17, 32, 11, 168);
+            const result = dateTimestamp(date);
+            const expected = Math.floor(date.getTime() / 1000);
+            expect(result).toEqual(expected);
+        });
     });
 }

package/dist/services/validateAmount.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The maximum number of fractional (post-decimal-point) digits that the
+ * underlying `Float` decimal parser accepts without precision loss. A value
+ * with more than this many decimal places is rejected client-side with a
+ * friendly message.
+ */
+export declare const MAX_DECIMALS = 67;
+export interface AmountDecimalsValidation {
+    isValid: boolean;
+    errorMessage: string | null;
+}
+/**
+ * Counts the number of fractional digits in a plain decimal string.
+ *
+ * Returns `null` when the input is not a plain decimal number (empty, or
+ * containing anything other than an optional leading sign and digits around a
+ * single decimal point), so callers defer to the underlying parser for those
+ * cases.
+ *
+ * @param value The raw string entered by the user.
+ */
+export declare function countDecimalPlaces(value: string): number | null;
+/**
+ * Validates that a raw amount string does not exceed the maximum supported
+ * number of decimal places.
+ *
+ * @param value The raw string entered by the user.
+ * @returns Validation result with a friendly error message when invalid.
+ */
+export declare function validateAmount(value: string): AmountDecimalsValidation;

package/dist/services/validateAmount.js

@@ -0,0 +1,53 @@
+/**
+ * The maximum number of fractional (post-decimal-point) digits that the
+ * underlying `Float` decimal parser accepts without precision loss. A value
+ * with more than this many decimal places is rejected client-side with a
+ * friendly message.
+ */
+export const MAX_DECIMALS = 67;
+/**
+ * Counts the number of fractional digits in a plain decimal string.
+ *
+ * Returns `null` when the input is not a plain decimal number (empty, or
+ * containing anything other than an optional leading sign and digits around a
+ * single decimal point), so callers defer to the underlying parser for those
+ * cases.
+ *
+ * @param value The raw string entered by the user.
+ */
+export function countDecimalPlaces(value) {
+    const trimmed = value.trim();
+    if (trimmed === "")
+        return null;
+    // Optional sign, integer part, optional fractional part. Plain decimal only
+    // (no scientific notation, no thousands separators) to match the inputs the
+    // `Float` decimal parser accepts.
+    const match = /^[+-]?(\d*)(?:\.(\d*))?$/.exec(trimmed);
+    if (!match)
+        return null;
+    const [, integerPart, fractionalPart] = match;
+    // Reject strings with no digits at all (e.g. ".", "+", "-").
+    if ((integerPart ?? "") === "" && (fractionalPart ?? "") === "")
+        return null;
+    return (fractionalPart ?? "").length;
+}
+/**
+ * Validates that a raw amount string does not exceed the maximum supported
+ * number of decimal places.
+ *
+ * @param value The raw string entered by the user.
+ * @returns Validation result with a friendly error message when invalid.
+ */
+export function validateAmount(value) {
+    const decimals = countDecimalPlaces(value);
+    if (decimals !== null && decimals > MAX_DECIMALS) {
+        return {
+            isValid: false,
+            errorMessage: `Too many decimal places. A maximum of ${MAX_DECIMALS} decimal places is allowed.`,
+        };
+    }
+    return {
+        isValid: true,
+        errorMessage: null,
+    };
+}

package/dist/storesGeneric/cachedWritableStore.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Creates a writable Svelte store that persists its value to localStorage.
+ *
+ * @template T - The type of the value stored in the store
+ * @param {string} key - The localStorage key used to store the value
+ * @param {T} defaultValue - The default value to use when no value is found in localStorage
+ * @param {function(T): string} serialize - Function to convert the store value to a string for storage
+ * @param {function(string): T} deserialize - Function to convert the stored string back to the original type
+ * @returns {import('svelte/store').Writable<T>} A writable store that automatically syncs with localStorage
+ *
+ * @example
+ * // Create a store for a boolean value
+ * const darkMode = cachedWritableStore(
+ *   'darkMode',
+ *   false,
+ *   value => JSON.stringify(value),
+ *   str => JSON.parse(str)
+ * );
+ *
+ * // Create a store for a complex object
+ * const userPreferences = cachedWritableStore(
+ *   'userPrefs',
+ *   { theme: 'light', fontSize: 14 },
+ *   value => JSON.stringify(value),
+ *   str => JSON.parse(str)
+ * );
+ */
+export declare function cachedWritableStore<T>(key: string, defaultValue: T, serialize: (value: T) => string, deserialize: (serialized: string) => T): import("svelte/store").Writable<T>;
+export declare const cachedWritableString: (key: string, defaultValue?: string) => import("svelte/store").Writable<string>;
+export declare const cachedWritableInt: (key: string, defaultValue?: number) => import("svelte/store").Writable<number>;
+/**
+ * Creates a writable store that can hold an optional value of type T and persists to localStorage.
+ *
+ * @template T - The type of the value stored
+ * @param {string} key - The localStorage key to use for persistence
+ * @param {T | undefined} defaultValue - The default value if nothing is found in localStorage
+ * @param {function} serialize - Function to convert the value to a string for storage
+ * @param {function} deserialize - Function to convert the stored string back to a value
+ * @returns A writable store that persists to localStorage and can hold undefined values
+ */
+export declare const cachedWritableOptionalStore: <T>(key: string, defaultValue: T | undefined, serialize: (value: T) => string, deserialize: (serialized: string) => T) => import("svelte/store").Writable<T | undefined>;
+/**
+ * Creates a writable store that can hold an optional number value and persists to localStorage.
+ *
+ * @param {string} key - The localStorage key to use for persistence
+ * @param {number | undefined} defaultValue - The default value if nothing is found in localStorage
+ * @returns A writable store that persists to localStorage and can hold an optional number
+ */
+export declare const cachedWritableIntOptional: (key: string, defaultValue?: number | undefined) => import("svelte/store").Writable<number | undefined>;
+/**
+ * Creates a writable store that can hold an optional string value and persists to localStorage.
+ *
+ * @param {string} key - The localStorage key to use for persistence
+ * @param {string | undefined} defaultValue - The default value if nothing is found in localStorage
+ * @returns A writable store that persists to localStorage and can hold an optional string
+ */
+export declare const cachedWritableStringOptional: (key: string, defaultValue?: string | undefined) => import("svelte/store").Writable<string | undefined>;

package/dist/storesGeneric/cachedWritableStore.js

@@ -0,0 +1,93 @@
+import { writable } from "svelte/store";
+/**
+ * Creates a writable Svelte store that persists its value to localStorage.
+ *
+ * @template T - The type of the value stored in the store
+ * @param {string} key - The localStorage key used to store the value
+ * @param {T} defaultValue - The default value to use when no value is found in localStorage
+ * @param {function(T): string} serialize - Function to convert the store value to a string for storage
+ * @param {function(string): T} deserialize - Function to convert the stored string back to the original type
+ * @returns {import('svelte/store').Writable<T>} A writable store that automatically syncs with localStorage
+ *
+ * @example
+ * // Create a store for a boolean value
+ * const darkMode = cachedWritableStore(
+ *   'darkMode',
+ *   false,
+ *   value => JSON.stringify(value),
+ *   str => JSON.parse(str)
+ * );
+ *
+ * // Create a store for a complex object
+ * const userPreferences = cachedWritableStore(
+ *   'userPrefs',
+ *   { theme: 'light', fontSize: 14 },
+ *   value => JSON.stringify(value),
+ *   str => JSON.parse(str)
+ * );
+ */
+export function cachedWritableStore(key, defaultValue, serialize, deserialize) {
+    const getCache = () => {
+        try {
+            const cached = localStorage.getItem(key);
+            return cached !== null ? deserialize(cached) : defaultValue;
+        }
+        catch {
+            return defaultValue;
+        }
+    };
+    const setCache = (value) => {
+        try {
+            if (value !== undefined) {
+                localStorage.setItem(key, serialize(value));
+            }
+            else {
+                localStorage.removeItem(key);
+            }
+        }
+        catch {
+            // Silently ignore localStorage errors to allow the application to function
+            // without persistence in environments where localStorage is unavailable
+        }
+    };
+    const data = writable(getCache());
+    data.subscribe((value) => {
+        setCache(value);
+    });
+    return data;
+}
+export const cachedWritableString = (key, defaultValue = "") => cachedWritableStore(key, defaultValue, (v) => v, (v) => v);
+export const cachedWritableInt = (key, defaultValue = 0) => cachedWritableStore(key, defaultValue, (v) => v.toString(), (v) => {
+    const parsed = Number.parseInt(v);
+    return isNaN(parsed) ? defaultValue : parsed;
+});
+/**
+ * Creates a writable store that can hold an optional value of type T and persists to localStorage.
+ *
+ * @template T - The type of the value stored
+ * @param {string} key - The localStorage key to use for persistence
+ * @param {T | undefined} defaultValue - The default value if nothing is found in localStorage
+ * @param {function} serialize - Function to convert the value to a string for storage
+ * @param {function} deserialize - Function to convert the stored string back to a value
+ * @returns A writable store that persists to localStorage and can hold undefined values
+ */
+export const cachedWritableOptionalStore = (key, defaultValue = undefined, serialize, deserialize) => cachedWritableStore(key, defaultValue, (v) => (v !== undefined ? serialize(v) : ""), (v) => (v !== "" ? deserialize(v) : undefined));
+/**
+ * Creates a writable store that can hold an optional number value and persists to localStorage.
+ *
+ * @param {string} key - The localStorage key to use for persistence
+ * @param {number | undefined} defaultValue - The default value if nothing is found in localStorage
+ * @returns A writable store that persists to localStorage and can hold an optional number
+ */
+export const cachedWritableIntOptional = (key, defaultValue = undefined) => cachedWritableOptionalStore(key, defaultValue, (v) => v.toString(), (v) => {
+    const parsed = Number.parseInt(v);
+    return isNaN(parsed) ? (defaultValue ?? 0) : parsed;
+});
+/**
+ * Creates a writable store that can hold an optional string value and persists to localStorage.
+ *
+ * @param {string} key - The localStorage key to use for persistence
+ * @param {string | undefined} defaultValue - The default value if nothing is found in localStorage
+ * @returns A writable store that persists to localStorage and can hold an optional string
+ */
+export const cachedWritableStringOptional = (key, defaultValue = undefined) => cachedWritableOptionalStore(key, defaultValue, (v) => v, (v) => v);

package/dist/storesGeneric/scrub.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Global "scrub" toggle used for safe screenshotting of the GUI.
+ *
+ * When `true`, every {@link Sensitive} region (which wraps all rendered
+ * addresses and transaction hashes via the `Hash` component) is masked with an
+ * opaque grey box so that sharing a screenshot does not leak addresses/hashes.
+ *
+ * This is purely presentational: it never changes any on-chain data or the
+ * underlying values held in memory, only how they are displayed.
+ *
+ * The value is persisted to localStorage under the `scrub` key so the masked
+ * state survives reloads while a user is preparing screenshots.
+ */
+export declare const scrub: import("svelte/store").Writable<boolean>;

package/dist/storesGeneric/scrub.js

@@ -0,0 +1,22 @@
+import { cachedWritableStore } from "./cachedWritableStore";
+/**
+ * Global "scrub" toggle used for safe screenshotting of the GUI.
+ *
+ * When `true`, every {@link Sensitive} region (which wraps all rendered
+ * addresses and transaction hashes via the `Hash` component) is masked with an
+ * opaque grey box so that sharing a screenshot does not leak addresses/hashes.
+ *
+ * This is purely presentational: it never changes any on-chain data or the
+ * underlying values held in memory, only how they are displayed.
+ *
+ * The value is persisted to localStorage under the `scrub` key so the masked
+ * state survives reloads while a user is preparing screenshots.
+ */
+export const scrub = cachedWritableStore("scrub", false, (value) => JSON.stringify(value), (serialized) => {
+    try {
+        return JSON.parse(serialized) === true;
+    }
+    catch {
+        return false;
+    }
+});

package/dist/test/matchers.d.ts

@@ -1,6 +1,6 @@
-import * as matchers from '@testing-library/jest-dom/matchers';
+import * as matchers from "@testing-library/jest-dom/matchers";
 export declare const expect: import("vitest").ExpectStatic;
-declare module 'vitest' {
+declare module "vitest" {
     interface JestAssertion<T = any> extends matchers.TestingLibraryMatchers<ReturnType<typeof expect.stringContaining>, T> {
     }
 }

package/dist/test/matchers.js

@@ -1,4 +1,4 @@
-import { expect as vitestExpect } from 'vitest';
-import * as matchers from '@testing-library/jest-dom/matchers';
+import { expect as vitestExpect } from "vitest";
+import * as matchers from "@testing-library/jest-dom/matchers";
 vitestExpect.extend(matchers);
 export const expect = vitestExpect;

package/dist/types/account.d.ts

@@ -0,0 +1,3 @@
+import type { Readable } from "svelte/store";
+import type { Hex } from "viem";
+export type Account = Readable<Hex | null>;

package/dist/types/appStores.d.ts

@@ -1,19 +1,12 @@
-import type { Readable, Writable } from 'svelte/store';
-import type { ConfigSource, OrderbookConfigSource } from '@rainlanguage/orderbook/js_api';
+import type { Writable } from "svelte/store";
+import type { Address, Hex } from "@rainlanguage/raindex";
 export interface AppStoresInterface {
-    settings: Writable<ConfigSource | undefined>;
-    activeSubgraphs: Writable<Record<string, string>>;
-    accounts: Readable<Record<string, string>>;
-    activeAccountsItems: Writable<Record<string, string>>;
-    activeOrderStatus: Writable<boolean | undefined>;
-    orderHash: Writable<string>;
+    selectedChainIds: Writable<number[]>;
+    showInactiveOrders: Writable<boolean>;
+    orderHash: Writable<Hex>;
     hideZeroBalanceVaults: Writable<boolean>;
-    activeNetworkRef: Writable<string | undefined>;
-    activeOrderbookRef: Writable<string | undefined>;
-    activeOrderbook: Readable<OrderbookConfigSource | undefined>;
-    subgraphUrl: Readable<string | undefined>;
-    activeAccounts: Readable<{
-        [k: string]: string;
-    }>;
-    showMyItemsOnly: Writable<boolean>;
+    hideInactiveOrdersVaults: Writable<boolean>;
+    activeTokens: Writable<Address[]>;
+    activeRaindexAddresses: Writable<Address[]>;
+    ownerFilter: Writable<Address>;
 }

package/dist/types/modal.d.ts

@@ -1,20 +1,32 @@
-import type { SgOrder } from '@rainlanguage/orderbook/js_api';
-import type { DepositOrWithdrawArgs, OrderRemoveArgs, DeploymentArgs } from './transaction';
-export type DepositOrWithdrawModalProps = {
+import type { Float, RaindexOrder, RaindexVault } from "@rainlanguage/raindex";
+import type { VaultActionArgs } from "./transaction";
+import type { Hex } from "viem";
+export type VaultActionModalProps = {
     open: boolean;
-    args: DepositOrWithdrawArgs;
-};
-export type OrderRemoveModalProps = {
-    open: boolean;
-    args: OrderRemoveArgs;
-};
-export type DeployModalProps = {
-    open: boolean;
-    args: DeploymentArgs;
+    args: VaultActionArgs;
+    onSubmit: (amount: Float) => void;
 };
 export type DisclaimerModalProps = {
     open: boolean;
     onAccept: () => void;
 };
-export type QuoteDebugModalHandler = (order: SgOrder, rpcUrl: string, orderbook: string, inputIOIndex: number, outputIOIndex: number, pair: string, blockNumber?: number) => void;
-export type DebugTradeModalHandler = (hash: string, rpcUrl: string) => void;
+export type TransactionConfirmationProps = {
+    open: boolean;
+    modalTitle: string;
+    closeOnConfirm?: boolean;
+    args: {
+        chainId: number;
+        toAddress: Hex;
+        onConfirm: (hash: Hex) => void;
+        entity?: RaindexOrder | RaindexVault;
+        calldata: string;
+    };
+};
+export type QuoteDebugModalHandler = (order: RaindexOrder, inputIOIndex: number, outputIOIndex: number, pair: string, blockNumber?: bigint) => void;
+export type DebugTradeModalHandler = (hash: string, rpcUrls: string[]) => void;
+export type HandleTransactionConfirmationModal = (props: TransactionConfirmationProps, options?: {
+    timeout?: number;
+}) => Promise<{
+    success: boolean;
+    hash?: string;
+}>;

package/dist/types/order.d.ts

@@ -0,0 +1,10 @@
+import type { NameAndDescriptionCfg } from "@rainlanguage/raindex";
+export type ValidOrderDetail = {
+    details: NameAndDescriptionCfg;
+    name: string;
+    dotrain: string;
+};
+export type InvalidOrderDetail = {
+    name: string;
+    error: string;
+};

package/dist/types/order.js

@@ -0,0 +1 @@
+export {};

package/dist/types/toast.d.ts

@@ -0,0 +1,11 @@
+export interface ToastProps {
+    message: string;
+    detail?: string;
+    type: "success" | "error" | "warning" | "info";
+    color: "green" | "red" | "yellow" | "blue";
+    links?: ToastLink[];
+}
+export type ToastLink = {
+    link: string;
+    label: string;
+};

package/dist/types/toast.js

@@ -0,0 +1 @@
+export {};

package/dist/types/tokenBalance.d.ts

@@ -0,0 +1,6 @@
+import type { AccountBalance } from "@rainlanguage/raindex";
+export interface TokenBalance {
+    value: AccountBalance;
+    loading: boolean;
+    error: string;
+}

package/dist/types/tokenBalance.js

@@ -0,0 +1 @@
+export {};

package/dist/types/transaction.d.ts

@@ -1,26 +1,71 @@
-import type { ExtendedApprovalCalldata } from '../stores/transactionStore';
-import type { Hex } from 'viem';
-import type { DepositAndAddOrderCalldataResult, SgOrder, SgVault } from '@rainlanguage/orderbook/js_api';
-export type DeploymentArgs = {
-    approvals: ExtendedApprovalCalldata[];
-    deploymentCalldata: DepositAndAddOrderCalldataResult;
-    orderbookAddress: Hex;
-    chainId: number;
-    subgraphUrl: string;
-    network: string;
+import type { Hex } from "viem";
+import type { RaindexVault } from "@rainlanguage/raindex";
+import type { ToastLink } from "./toast";
+import type { TransactionStoreState } from "../models/Transaction";
+/**
+ * Context provided to the indexing function, allowing it to update
+ * transaction state and trigger callbacks without TransactionStore
+ * knowing the specifics of what's being indexed.
+ */
+export type IndexingContext = {
+    /** Update the transaction state (status, errorDetails, links) */
+    updateState: (partialState: Partial<TransactionStoreState>) => void;
+    /** Callback to invoke on successful indexing */
+    onSuccess: () => void;
+    /** Callback to invoke on indexing failure */
+    onError: () => void;
+    /** Current toast links (useful for prepending new links) */
+    links: ToastLink[];
 };
-export type DepositOrWithdrawArgs = {
-    vault: SgVault;
-    onDepositOrWithdraw: () => void;
-    action: 'deposit' | 'withdraw';
-    chainId: number;
-    rpcUrl: string;
-    subgraphUrl: string;
+/**
+ * Generic indexing function type. TransactionStore calls this function
+ * after the transaction receipt is confirmed, without knowing what
+ * type of indexing is being performed (SDK-based, subgraph, etc.).
+ */
+export type AwaitIndexingFn = (ctx: IndexingContext) => Promise<void>;
+export type VaultActionArgs = {
+    vault: RaindexVault;
+    onDeposit?: () => void;
+    account: Hex;
 };
-export type OrderRemoveArgs = {
-    order: SgOrder;
-    onRemove: () => void;
+export declare enum TransactionName {
+    REMOVAL = "Order Removal",
+    WITHDRAWAL = "Vault Withdrawal",
+    WITHDRAWAL_MULTIPLE = "Vaults Withdrawal",
+    APPROVAL = "Token Approval",
+    DEPOSIT = "Vault Deposit",
+    TAKE_ORDER = "Take Order"
+}
+export declare enum TransactionStatusMessage {
+    IDLE = "Idle",
+    STARTING = "Starting transaction...",
+    CHECKING_ALLOWANCE = "Checking your allowance...",
+    PENDING_WALLET = "Waiting for wallet confirmation...",
+    PENDING_APPROVAL = "Approving token spend...",
+    PENDING_RECEIPT = "Waiting for transaction receipt...",
+    PENDING_DEPLOYMENT = "Deploying your order...",
+    PENDING_WITHDRAWAL = "Withdrawing tokens...",
+    PENDING_DEPOSIT = "Depositing tokens...",
+    PENDING_SUBGRAPH = "Awaiting transaction indexing...",
+    SUCCESS = "Transaction confirmed",
+    ERROR = "Something went wrong"
+}
+export declare enum TransactionStoreErrorMessage {
+    SWITCH_CHAIN_FAILED = "Failed to switch chain.",
+    SUBGRAPH_TIMEOUT_ERROR = "The subgraph took too long to respond. Your transaction may still be processing.",
+    SUBGRAPH_FAILED = "Failed to index transaction.",
+    RECEIPT_FAILED = "Failed to get transaction receipt."
+}
+export type InternalTransactionArgs = {
     chainId: number;
-    orderbookAddress: Hex;
-    subgraphUrl: string;
+    txHash: Hex;
+    queryKey: string;
+};
+export type TransactionArgs = InternalTransactionArgs & {
+    name: string;
+    errorMessage: string;
+    successMessage: string;
+    queryKey: string;
+    toastLinks: ToastLink[];
+    awaitIndexingFn?: AwaitIndexingFn;
 };

package/dist/types/transaction.js

@@ -1 +1,31 @@
-export {};
+export var TransactionName;
+(function (TransactionName) {
+    TransactionName["REMOVAL"] = "Order Removal";
+    TransactionName["WITHDRAWAL"] = "Vault Withdrawal";
+    TransactionName["WITHDRAWAL_MULTIPLE"] = "Vaults Withdrawal";
+    TransactionName["APPROVAL"] = "Token Approval";
+    TransactionName["DEPOSIT"] = "Vault Deposit";
+    TransactionName["TAKE_ORDER"] = "Take Order";
+})(TransactionName || (TransactionName = {}));
+export var TransactionStatusMessage;
+(function (TransactionStatusMessage) {
+    TransactionStatusMessage["IDLE"] = "Idle";
+    TransactionStatusMessage["STARTING"] = "Starting transaction...";
+    TransactionStatusMessage["CHECKING_ALLOWANCE"] = "Checking your allowance...";
+    TransactionStatusMessage["PENDING_WALLET"] = "Waiting for wallet confirmation...";
+    TransactionStatusMessage["PENDING_APPROVAL"] = "Approving token spend...";
+    TransactionStatusMessage["PENDING_RECEIPT"] = "Waiting for transaction receipt...";
+    TransactionStatusMessage["PENDING_DEPLOYMENT"] = "Deploying your order...";
+    TransactionStatusMessage["PENDING_WITHDRAWAL"] = "Withdrawing tokens...";
+    TransactionStatusMessage["PENDING_DEPOSIT"] = "Depositing tokens...";
+    TransactionStatusMessage["PENDING_SUBGRAPH"] = "Awaiting transaction indexing...";
+    TransactionStatusMessage["SUCCESS"] = "Transaction confirmed";
+    TransactionStatusMessage["ERROR"] = "Something went wrong";
+})(TransactionStatusMessage || (TransactionStatusMessage = {}));
+export var TransactionStoreErrorMessage;
+(function (TransactionStoreErrorMessage) {
+    TransactionStoreErrorMessage["SWITCH_CHAIN_FAILED"] = "Failed to switch chain.";
+    TransactionStoreErrorMessage["SUBGRAPH_TIMEOUT_ERROR"] = "The subgraph took too long to respond. Your transaction may still be processing.";
+    TransactionStoreErrorMessage["SUBGRAPH_FAILED"] = "Failed to index transaction.";
+    TransactionStoreErrorMessage["RECEIPT_FAILED"] = "Failed to get transaction receipt.";
+})(TransactionStoreErrorMessage || (TransactionStoreErrorMessage = {}));