@rainlanguage/ui-components 0.0.1-alpha.120 → 0.0.1-alpha.121

package/dist/components/deployment/DeploymentSteps.svelte

@@ -2,6 +2,7 @@
 import TokenIOInput from "./TokenIOInput.svelte";
 import ComposedRainlangModal from "./ComposedRainlangModal.svelte";
 import {
+  DotrainOrderGui
 } from "@rainlanguage/orderbook";
 import WalletConnect from "../wallet/WalletConnect.svelte";
 import {} from "svelte/store";
@@ -13,8 +14,6 @@ import DepositInput from "./DepositInput.svelte";
 import SelectToken from "./SelectToken.svelte";
 import DeploymentSectionHeader from "./DeploymentSectionHeader.svelte";
 import { useGui } from "../../hooks/useGui";
-import { handleDeployment } from "./handleDeployment";
-import {} from "../../types/transaction";
 import { fade } from "svelte/transition";
 import ShareChoicesButton from "./ShareChoicesButton.svelte";
 import { useRegistry } from "../../providers/registry/useRegistry";
@@ -177,8 +176,7 @@ async function handleDeployButtonClick() {
       return;
     }
     DeploymentStepsError.clear();
-    const deploymentArgs = await handleDeployment(gui, $account, subgraphUrl);
-    return onDeploy(deploymentArgs);
+    return onDeploy(gui, subgraphUrl);
   } catch (e) {
     DeploymentStepsError.catch(e, DeploymentStepsErrorCode.ADD_ORDER_FAILED);
   } finally {

package/dist/components/deployment/DeploymentSteps.svelte.d.ts

@@ -1,8 +1,7 @@
 import { SvelteComponent } from "svelte";
-import { type ConfigSource, type NameAndDescriptionCfg } from '@rainlanguage/orderbook';
+import { type ConfigSource, type NameAndDescriptionCfg, DotrainOrderGui } from '@rainlanguage/orderbook';
 import { type Writable } from 'svelte/store';
 import type { AppKit } from '@reown/appkit';
-import { type DeploymentArgs } from '../../types/transaction';
 import type { Account } from '../../types/account';
 declare const __propDef: {
     props: {
@@ -12,7 +11,7 @@ declare const __propDef: {
             description: string;
         };
         /** Strategy details containing name and description configuration */ strategyDetail: NameAndDescriptionCfg;
-        /** Handlers for deployment modals */ onDeploy: (deploymentArgs: DeploymentArgs) => void;
+        /** Handlers for deployment modals */ onDeploy: (gui: DotrainOrderGui, subgraphUrl?: string) => void;
         wagmiConnected: Writable<boolean>;
         appKitModal: Writable<AppKit>;
         settings: Writable<ConfigSource>;

package/dist/index.d.ts

@@ -68,9 +68,8 @@ export { default as TransactionList } from './components/transactions/Transactio
 export { default as FixedBottomTransaction } from './components/transactions/FixedBottomTransaction.svelte';
 export type { AppStoresInterface } from './types/appStores.ts';
 export type { OrderbookConfigSource, OrderbookCfgRef } from '@rainlanguage/orderbook';
-export { TransactionStatusMessage, TransactionStoreErrorMessage, type ExtendedApprovalCalldata, type TransactionArgs, type DeploymentArgs, type VaultActionArgs } from './types/transaction';
-export type { TransactionErrorMessage } from './stores/transactionStore';
-export type { VaultActionModalProps, QuoteDebugModalHandler, DebugTradeModalHandler, DeployModalProps, DisclaimerModalProps, TransactionConfirmationProps } from './types/modal';
+export { TransactionStatusMessage, TransactionStoreErrorMessage, type TransactionArgs, type DeploymentArgs, type VaultActionArgs } from './types/transaction';
+export type { VaultActionModalProps, QuoteDebugModalHandler, DebugTradeModalHandler, DisclaimerModalProps, TransactionConfirmationProps, HandleTransactionConfirmationModal } from './types/modal';
 export type { ValidStrategyDetail, InvalidStrategyDetail } from './types/strategy';
 export type { ToastProps } from './types/toast';
 export { createResolvableQuery, createResolvableInfiniteQuery } from './__mocks__/queries';
@@ -85,7 +84,6 @@ export { DEFAULT_PAGE_SIZE, DEFAULT_REFRESH_INTERVAL } from './queries/constants
 export { QKEY_VAULTS, QKEY_VAULT, QKEY_VAULT_CHANGES, QKEY_ORDERS, QKEY_ORDER, QKEY_ORDER_TRADES_LIST, QKEY_ORDER_QUOTE, QKEY_VAULTS_VOL_LIST, QKEY_ORDER_APY } from './queries/keys';
 export { darkChartTheme, lightChartTheme } from './utils/lightweightChartsThemes';
 export { lightCodeMirrorTheme, darkCodeMirrorTheme } from './utils/codeMirrorThemes';
-export { default as transactionStore } from './stores/transactionStore';
 export { cachedWritableStore, cachedWritableIntOptional, cachedWritableStringOptional, cachedWritableString } from './storesGeneric/cachedWritableStore';
 export { default as logoLight } from './assets/logo-light.svg';
 export { default as logoDark } from './assets/logo-dark.svg';
@@ -105,4 +103,3 @@ export { TransactionManager } from './providers/transactions/TransactionManager'
 export { mockPageStore } from './__mocks__/stores';
 export { mockConfigSource } from './__mocks__/settings';
 export { mockSettingsStore } from './__mocks__/settings';
-export { mockTransactionStore } from './__mocks__/mockTransactionStore';

package/dist/index.js

@@ -83,7 +83,6 @@ export { QKEY_VAULTS, QKEY_VAULT, QKEY_VAULT_CHANGES, QKEY_ORDERS, QKEY_ORDER, Q
 export { darkChartTheme, lightChartTheme } from './utils/lightweightChartsThemes';
 export { lightCodeMirrorTheme, darkCodeMirrorTheme } from './utils/codeMirrorThemes';
 // Stores
-export { default as transactionStore } from './stores/transactionStore';
 export { cachedWritableStore, cachedWritableIntOptional, cachedWritableStringOptional, cachedWritableString } from './storesGeneric/cachedWritableStore';
 // Assets
 export { default as logoLight } from './assets/logo-light.svg';
@@ -108,4 +107,3 @@ export { TransactionManager } from './providers/transactions/TransactionManager'
 export { mockPageStore } from './__mocks__/stores';
 export { mockConfigSource } from './__mocks__/settings';
 export { mockSettingsStore } from './__mocks__/settings';
-export { mockTransactionStore } from './__mocks__/mockTransactionStore';

package/dist/models/Transaction.d.ts

@@ -38,6 +38,7 @@ export declare class TransactionStore implements Transaction {
     private name;
     private config;
     private txHash;
+    private networkKey;
     private links;
     private onSuccess;
     private onError;

package/dist/models/Transaction.js

@@ -13,6 +13,7 @@ export class TransactionStore {
     name;
     config;
     txHash;
+    networkKey;
     links;
     onSuccess;
     onError;
@@ -29,6 +30,7 @@ export class TransactionStore {
         this.config = args.config;
         this.txHash = args.txHash;
         this.name = args.name;
+        this.networkKey = args.networkKey;
         this.links = args.toastLinks;
         this.state = writable({
             name: this.name,
@@ -110,6 +112,17 @@ export class TransactionStore {
             this.updateState({
                 status: TransactionStatusMessage.SUCCESS
             });
+            const newOrderHash = result.value.orderHash;
+            // If we have a new order hash, add the "View order" link
+            if (newOrderHash) {
+                const newLink = {
+                    link: `/orders/${this.networkKey}-${newOrderHash}`,
+                    label: 'View order'
+                };
+                this.updateState({
+                    links: [newLink, ...this.links]
+                });
+            }
             return this.onSuccess();
         }
         this.updateState({

package/dist/providers/transactions/TransactionManager.d.ts

@@ -132,6 +132,27 @@ export declare class TransactionManager {
         entity: SgVault;
         subgraphUrl: string;
     }): Promise<Transaction>;
+    /**
+     * Creates and initializes a new transaction for deploying a strategy.
+     * @param args - Configuration for the deployment transaction.
+     * @param args.txHash - Hash of the transaction to track.
+     * @param args.chainId - Chain ID where the transaction is being executed.
+     * @param args.networkKey - Network identifier string.
+     * @param args.queryKey - The ID of the vault into which funds are deposited (used for query invalidation and UI links).
+     * @param args.subgraphUrl - URL of the subgraph to query for transaction status.
+     * @returns A new Transaction instance configured for deposit.
+     * @example
+     * const tx = await manager.createAddOrderTransaction({
+     *   txHash: '0xdeploytxhash',
+     *   chainId: 1,
+     *   networkKey: 'mainnet',
+     *   queryKey: '0x789...', // Vault ID
+     *   subgraphUrl: 'https://api.thegraph.com/subgraphs/name/...',
+     * });
+     */
+    createAddOrderTransaction(args: InternalTransactionArgs & {
+        subgraphUrl: string;
+    }): Promise<Transaction>;
     /**
      * Creates, initializes, and executes a new transaction instance.
      * @param args - Configuration for the transaction.

package/dist/providers/transactions/TransactionManager.js

@@ -2,7 +2,7 @@ import { writable } from 'svelte/store';
 import { TransactionStore } from '../../models/Transaction';
 import { getExplorerLink } from '../../services/getExplorerLink';
 import { TransactionName } from '../../types/transaction';
-import { getTransaction, getTransactionRemoveOrders } from '@rainlanguage/orderbook';
+import { getTransaction, getTransactionRemoveOrders, getTransactionAddOrders } from '@rainlanguage/orderbook';
 import { formatUnits } from 'viem';
 /**
  * Manages blockchain transactions with toast notifications and query invalidation.
@@ -246,6 +246,54 @@ export class TransactionManager {
             }
         });
     }
+    /**
+     * Creates and initializes a new transaction for deploying a strategy.
+     * @param args - Configuration for the deployment transaction.
+     * @param args.txHash - Hash of the transaction to track.
+     * @param args.chainId - Chain ID where the transaction is being executed.
+     * @param args.networkKey - Network identifier string.
+     * @param args.queryKey - The ID of the vault into which funds are deposited (used for query invalidation and UI links).
+     * @param args.subgraphUrl - URL of the subgraph to query for transaction status.
+     * @returns A new Transaction instance configured for deposit.
+     * @example
+     * const tx = await manager.createAddOrderTransaction({
+     *   txHash: '0xdeploytxhash',
+     *   chainId: 1,
+     *   networkKey: 'mainnet',
+     *   queryKey: '0x789...', // Vault ID
+     *   subgraphUrl: 'https://api.thegraph.com/subgraphs/name/...',
+     * });
+     */
+    async createAddOrderTransaction(args) {
+        const { queryKey, txHash, chainId, subgraphUrl } = args;
+        const name = 'Deploying order';
+        const errorMessage = 'Deployment failed.';
+        const successMessage = 'Order deployed successfully.';
+        const explorerLink = await getExplorerLink(txHash, chainId, 'tx');
+        const toastLinks = [
+            {
+                link: explorerLink,
+                label: 'View on explorer'
+            }
+        ];
+        return this.createTransaction({
+            ...args,
+            name,
+            errorMessage,
+            successMessage,
+            queryKey,
+            toastLinks,
+            awaitSubgraphConfig: {
+                subgraphUrl,
+                txHash,
+                successMessage,
+                fetchEntityFn: getTransactionAddOrders,
+                isSuccess: (data) => {
+                    return Array.isArray(data) ? data.length > 0 : false;
+                }
+            }
+        });
+    }
     /**
      * Creates, initializes, and executes a new transaction instance.
      * @param args - Configuration for the transaction.
@@ -264,7 +312,9 @@ export class TransactionManager {
             config: this.wagmiConfig
         };
         const onSuccess = () => {
-            this.queryClient.invalidateQueries({ queryKey: [args.queryKey] });
+            if (args.queryKey) {
+                this.queryClient.invalidateQueries({ queryKey: [args.queryKey] });
+            }
         };
         const onError = () => {
             this.addToast({

package/dist/services/awaitTransactionIndexing.js

@@ -25,17 +25,17 @@ export const awaitSubgraphIndexing = async (options) => {
         try {
             const data = await fetchEntityFn(subgraphUrl, txHash);
             if (data.value && isSuccess(data.value)) {
-                let orderHash;
+                let newOrderHash;
                 // Extract orderHash from order data if it exists in the expected format
                 // This only applies to addOrder transactions
                 if (Array.isArray(data.value) && data.value.length > 0 && data.value[0]?.order?.orderHash) {
-                    orderHash = data.value[0].order.orderHash;
+                    newOrderHash = data.value[0].order.orderHash;
                 }
                 return {
                     value: {
                         txHash,
                         successMessage,
-                        orderHash,
+                        orderHash: newOrderHash,
                         network,
                         data: data.value
                     }

package/dist/types/modal.d.ts

@@ -1,15 +1,11 @@
 import type { SgOrder, SgVault } from '@rainlanguage/orderbook';
-import type { DeploymentArgs, VaultActionArgs } from './transaction';
+import type { VaultActionArgs } from './transaction';
 import type { Hex } from 'viem';
 export type VaultActionModalProps = {
     open: boolean;
     args: VaultActionArgs;
     onSubmit: (amount: bigint) => void;
 };
-export type DeployModalProps = {
-    open: boolean;
-    args: DeploymentArgs;
-};
 export type DisclaimerModalProps = {
     open: boolean;
     onAccept: () => void;
@@ -22,9 +18,15 @@ export type TransactionConfirmationProps = {
         chainId: number;
         toAddress: Hex;
         onConfirm: (hash: Hex) => void;
-        entity: SgOrder | SgVault;
+        entity?: SgOrder | SgVault;
         calldata: string;
     };
 };
 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 HandleTransactionConfirmationModal = (props: TransactionConfirmationProps, options?: {
+    timeout?: number;
+}) => Promise<{
+    success: boolean;
+    hash?: string;
+}>;

package/dist/types/transaction.d.ts

@@ -1,17 +1,10 @@
 import type { Hex } from 'viem';
-import type { SgVault, ApprovalCalldata, VaultCalldataResult, DepositAndAddOrderCalldataResult } from '@rainlanguage/orderbook';
+import type { SgVault, VaultCalldataResult, DeploymentTransactionArgs } from '@rainlanguage/orderbook';
 import type { Config } from '@wagmi/core';
 import type { ToastLink } from './toast';
 import type { AwaitSubgraphConfig } from '../services/awaitTransactionIndexing';
-export type ExtendedApprovalCalldata = ApprovalCalldata & {
-    symbol?: string;
-};
-export type DeploymentArgs = {
-    approvals: ExtendedApprovalCalldata[];
-    deploymentCalldata: DepositAndAddOrderCalldataResult;
-    orderbookAddress: Hex;
-    chainId: number;
-    subgraphUrl?: string;
+export type DeploymentArgs = DeploymentTransactionArgs & {
+    subgraphUrl: string;
     network: string;
 };
 export type VaultActionArgs = {
@@ -71,6 +64,3 @@ export type TransactionArgs = InternalTransactionArgs & {
     toastLinks: ToastLink[];
     awaitSubgraphConfig?: AwaitSubgraphConfig;
 };
-export type DeploymentTransactionArgs = Omit<DeploymentArgs, 'account'> & {
-    config: Config;
-};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rainlanguage/ui-components",
-	"version": "0.0.1-alpha.120",
+	"version": "0.0.1-alpha.121",
 	"description": "A component library for building Svelte applications to be used with Raindex.",
 	"license": "LicenseRef-DCL-1.0",
 	"author": "Rain Open Source Software Ltd",
@@ -53,7 +53,7 @@
 		"@fontsource/dm-sans": "5.1.0",
 		"@imask/svelte": "7.6.1",
 		"@observablehq/plot": "0.6.16",
-		"@rainlanguage/orderbook": "0.0.1-alpha.120",
+		"@rainlanguage/orderbook": "0.0.1-alpha.121",
 		"@reown/appkit": "1.6.4",
 		"@reown/appkit-adapter-wagmi": "1.6.4",
 		"@sentry/sveltekit": "7.120.0",

package/dist/__mocks__/mockTransactionStore.d.ts

@@ -1,4 +0,0 @@
-import { type TransactionState, type TransactionStore } from '../stores/transactionStore';
-export declare const mockTransactionStore: Partial<TransactionStore> & {
-    mockSetSubscribeValue: (value: Partial<TransactionState>) => void;
-};

package/dist/__mocks__/mockTransactionStore.js

@@ -1,52 +0,0 @@
-import { writable } from 'svelte/store';
-import { initialState, TransactionErrorMessage } from '../stores/transactionStore';
-import { TransactionStatusMessage } from '../types/transaction';
-const mockTransactionWritable = writable(initialState);
-export const mockTransactionStore = {
-    subscribe: mockTransactionWritable.subscribe,
-    reset: () => mockTransactionWritable.set(initialState),
-    handleDeploymentTransaction: async () => {
-        mockTransactionWritable.update((state) => ({
-            ...state,
-            status: TransactionStatusMessage.SUCCESS,
-            message: 'Strategy deployed successfully!',
-            hash: '0x123'
-        }));
-        return Promise.resolve();
-    },
-    checkingWalletAllowance: (message = '') => mockTransactionWritable.update((state) => ({
-        ...state,
-        status: TransactionStatusMessage.CHECKING_ALLOWANCE,
-        message
-    })),
-    awaitWalletConfirmation: (message = '') => mockTransactionWritable.update((state) => ({
-        ...state,
-        status: TransactionStatusMessage.PENDING_WALLET,
-        message
-    })),
-    awaitApprovalTx: (hash) => mockTransactionWritable.update((state) => ({
-        ...state,
-        hash,
-        status: TransactionStatusMessage.PENDING_APPROVAL,
-        message: 'Approving token spend...'
-    })),
-    transactionSuccess: (hash, message = '', newOrderHash = '', network = '') => mockTransactionWritable.update((state) => ({
-        ...state,
-        status: TransactionStatusMessage.SUCCESS,
-        hash,
-        message,
-        newOrderHash,
-        network
-    })),
-    transactionError: (error, hash = '') => mockTransactionWritable.update((state) => ({
-        ...state,
-        status: TransactionStatusMessage.ERROR,
-        error,
-        hash
-    })),
-    // Extra function for testing purposes
-    mockSetSubscribeValue: (value) => mockTransactionWritable.update((state) => ({
-        ...state,
-        ...value
-    }))
-};

package/dist/components/deployment/handleDeployment.d.ts

@@ -1,11 +0,0 @@
-import type { DotrainOrderGui } from '@rainlanguage/orderbook';
-import type { DeploymentArgs } from '../../types/transaction';
-export declare enum AddOrderErrors {
-    ADD_ORDER_FAILED = "Failed to add order",
-    MISSING_GUI = "Order GUI is required",
-    MISSING_CONFIG = "Wagmi config is required",
-    NO_ACCOUNT_CONNECTED = "No wallet address found",
-    ERROR_GETTING_ARGS = "Error getting deployment transaction args",
-    ERROR_GETTING_NETWORK_KEY = "Error getting network key"
-}
-export declare function handleDeployment(gui: DotrainOrderGui, account: string | null, subgraphUrl?: string): Promise<DeploymentArgs>;

package/dist/components/deployment/handleDeployment.js

@@ -1,33 +0,0 @@
-export var AddOrderErrors;
-(function (AddOrderErrors) {
-    AddOrderErrors["ADD_ORDER_FAILED"] = "Failed to add order";
-    AddOrderErrors["MISSING_GUI"] = "Order GUI is required";
-    AddOrderErrors["MISSING_CONFIG"] = "Wagmi config is required";
-    AddOrderErrors["NO_ACCOUNT_CONNECTED"] = "No wallet address found";
-    AddOrderErrors["ERROR_GETTING_ARGS"] = "Error getting deployment transaction args";
-    AddOrderErrors["ERROR_GETTING_NETWORK_KEY"] = "Error getting network key";
-})(AddOrderErrors || (AddOrderErrors = {}));
-export async function handleDeployment(gui, account, subgraphUrl) {
-    const networkKeyResult = gui.getNetworkKey();
-    if (networkKeyResult.error) {
-        throw new Error(AddOrderErrors.ERROR_GETTING_NETWORK_KEY);
-    }
-    const network = networkKeyResult.value;
-    if (!account) {
-        throw new Error(AddOrderErrors.NO_ACCOUNT_CONNECTED);
-    }
-    const result = await gui.getDeploymentTransactionArgs(account);
-    if (result.error) {
-        throw new Error(result.error.msg);
-    }
-    const { approvals, deploymentCalldata, orderbookAddress, chainId } = result.value;
-    return {
-        approvals,
-        deploymentCalldata,
-        // Cast to Hex, since js_api returns a string
-        orderbookAddress: orderbookAddress,
-        chainId,
-        network,
-        subgraphUrl
-    };
-}

package/dist/stores/transactionStore.d.ts

@@ -1,49 +0,0 @@
-import { TransactionStatusMessage } from '../types/transaction';
-import type { DeploymentTransactionArgs } from '../types/transaction';
-export declare const ADDRESS_ZERO = "0x0000000000000000000000000000000000000000";
-export declare const ONE: bigint;
-export type TransactionState = {
-    status: TransactionStatusMessage;
-    error: string;
-    hash: string;
-    data: null;
-    functionName: string;
-    message: string;
-    newOrderHash: string;
-    network: string;
-    explorerLink: string;
-};
-export declare enum TransactionErrorMessage {
-    BAD_CALLLDATA = "Bad calldata.",
-    DEPLOY_FAILED = "Lock transaction failed.",
-    TIMEOUT = "The subgraph took too long to respond.",
-    APPROVAL_FAILED = "Approval transaction failed.",
-    USER_REJECTED_APPROVAL = "User rejected approval transaction.",
-    USER_REJECTED_TRANSACTION = "User rejected the transaction.",
-    DEPLOYMENT_FAILED = "Deployment transaction failed.",
-    SWITCH_CHAIN_FAILED = "Failed to switch chain."
-}
-export type TransactionStore = {
-    subscribe: (run: (value: TransactionState) => void) => () => void;
-    reset: () => void;
-    handleDeploymentTransaction: (args: DeploymentTransactionArgs) => Promise<void>;
-    checkingWalletAllowance: (message?: string) => void;
-    awaitWalletConfirmation: (message?: string) => void;
-    awaitApprovalTx: (hash: string) => void;
-    transactionSuccess: (hash: string, message?: string) => void;
-    transactionError: (message: TransactionErrorMessage, hash?: string) => void;
-};
-export declare const initialState: TransactionState;
-declare const _default: {
-    subscribe: (this: void, run: import("svelte/store").Subscriber<TransactionState>, invalidate?: import("svelte/store").Invalidator<TransactionState> | undefined) => import("svelte/store").Unsubscriber;
-    reset: () => void;
-    handleDeploymentTransaction: ({ config, approvals, deploymentCalldata, orderbookAddress, chainId, subgraphUrl, network }: DeploymentTransactionArgs) => Promise<void>;
-    checkingWalletAllowance: (message?: string) => void;
-    awaitWalletConfirmation: (message?: string) => void;
-    awaitApprovalTx: (hash: string, symbol: string | undefined) => void;
-    transactionSuccess: (hash: string, message?: string, newOrderHash?: string, network?: string) => void;
-    transactionError: (error: TransactionErrorMessage, hash?: string) => void;
-    awaitTransactionIndexing: (subgraphUrl: string, txHash: string, successMessage: string) => Promise<void>;
-    awaitNewOrderIndexing: (subgraphUrl: string, txHash: string, network?: string) => Promise<void>;
-};
-export default _default;

package/dist/stores/transactionStore.js

@@ -1,180 +0,0 @@
-import { writable } from 'svelte/store';
-import { sendTransaction, switchChain, waitForTransactionReceipt } from '@wagmi/core';
-import { getExplorerLink } from '../services/getExplorerLink';
-import { TransactionStatusMessage } from '../types/transaction';
-import { awaitSubgraphIndexing } from '../services/awaitTransactionIndexing';
-import { getTransaction, getTransactionAddOrders } from '@rainlanguage/orderbook';
-export const ADDRESS_ZERO = '0x0000000000000000000000000000000000000000';
-export const ONE = BigInt('1000000000000000000');
-export var TransactionErrorMessage;
-(function (TransactionErrorMessage) {
-    TransactionErrorMessage["BAD_CALLLDATA"] = "Bad calldata.";
-    TransactionErrorMessage["DEPLOY_FAILED"] = "Lock transaction failed.";
-    TransactionErrorMessage["TIMEOUT"] = "The subgraph took too long to respond.";
-    TransactionErrorMessage["APPROVAL_FAILED"] = "Approval transaction failed.";
-    TransactionErrorMessage["USER_REJECTED_APPROVAL"] = "User rejected approval transaction.";
-    TransactionErrorMessage["USER_REJECTED_TRANSACTION"] = "User rejected the transaction.";
-    TransactionErrorMessage["DEPLOYMENT_FAILED"] = "Deployment transaction failed.";
-    TransactionErrorMessage["SWITCH_CHAIN_FAILED"] = "Failed to switch chain.";
-})(TransactionErrorMessage || (TransactionErrorMessage = {}));
-export const initialState = {
-    status: TransactionStatusMessage.IDLE,
-    error: '',
-    hash: '',
-    data: null,
-    functionName: '',
-    message: '',
-    newOrderHash: '',
-    network: '',
-    explorerLink: ''
-};
-const transactionStore = () => {
-    const { subscribe, set, update } = writable(initialState);
-    const reset = () => set(initialState);
-    const awaitTransactionIndexing = async (subgraphUrl, txHash, successMessage) => {
-        update((state) => ({
-            ...state,
-            status: TransactionStatusMessage.PENDING_SUBGRAPH,
-            message: 'Waiting for transaction to be indexed...'
-        }));
-        const result = await awaitSubgraphIndexing({
-            subgraphUrl,
-            txHash,
-            successMessage,
-            fetchEntityFn: getTransaction,
-            isSuccess: (data) => !!data
-        });
-        if (result.error) {
-            return transactionError(TransactionErrorMessage.TIMEOUT);
-        }
-        if (result.value) {
-            return transactionSuccess(result.value.txHash, successMessage);
-        }
-    };
-    const awaitNewOrderIndexing = async (subgraphUrl, txHash, network) => {
-        update((state) => ({
-            ...state,
-            status: TransactionStatusMessage.PENDING_SUBGRAPH,
-            message: 'Waiting for new order to be indexed...'
-        }));
-        const result = await awaitSubgraphIndexing({
-            subgraphUrl,
-            txHash,
-            successMessage: 'New order indexed successfully',
-            network,
-            fetchEntityFn: getTransactionAddOrders,
-            isSuccess: (data) => data?.length > 0
-        });
-        if (result.error) {
-            return transactionError(TransactionErrorMessage.TIMEOUT);
-        }
-        if (result.value) {
-            return transactionSuccess(result.value.txHash, result.value.successMessage, result.value.orderHash, result.value.network);
-        }
-    };
-    const checkingWalletAllowance = (message) => update((state) => ({
-        ...state,
-        status: TransactionStatusMessage.CHECKING_ALLOWANCE,
-        message: message || ''
-    }));
-    const awaitWalletConfirmation = (message) => update((state) => ({
-        ...state,
-        status: TransactionStatusMessage.PENDING_WALLET,
-        message: message || ''
-    }));
-    const awaitApprovalTx = (hash, symbol) => update((state) => ({
-        ...state,
-        hash: hash,
-        status: TransactionStatusMessage.PENDING_APPROVAL,
-        message: `Approving ${symbol || 'token'} spend...`
-    }));
-    const awaitTx = (hash, status, explorerLink, message) => update((state) => ({
-        ...state,
-        hash: hash,
-        status: status,
-        message: message || 'Waiting for transaction...',
-        explorerLink: explorerLink || ''
-    }));
-    const transactionSuccess = (hash, message, newOrderHash, network) => {
-        update((state) => ({
-            ...state,
-            status: TransactionStatusMessage.SUCCESS,
-            hash: hash,
-            message: message || '',
-            newOrderHash: newOrderHash || '',
-            network: network || ''
-        }));
-    };
-    const transactionError = (error, hash) => update((state) => ({
-        ...state,
-        status: TransactionStatusMessage.ERROR,
-        error,
-        message: error,
-        hash: hash ?? ''
-    }));
-    const handleDeploymentTransaction = async ({ config, approvals, deploymentCalldata, orderbookAddress, chainId, subgraphUrl, network }) => {
-        reset();
-        try {
-            await switchChain(config, { chainId });
-        }
-        catch {
-            return transactionError(TransactionErrorMessage.SWITCH_CHAIN_FAILED);
-        }
-        for (const approval of approvals) {
-            let approvalHash;
-            try {
-                awaitWalletConfirmation(`Please approve ${approval.symbol || approval.token} spend in your wallet...`);
-                approvalHash = await sendTransaction(config, {
-                    to: approval.token,
-                    data: approval.calldata
-                });
-            }
-            catch {
-                return transactionError(TransactionErrorMessage.USER_REJECTED_APPROVAL);
-            }
-            try {
-                awaitApprovalTx(approvalHash, approval.symbol);
-                await waitForTransactionReceipt(config, { hash: approvalHash });
-            }
-            catch {
-                return transactionError(TransactionErrorMessage.APPROVAL_FAILED);
-            }
-        }
-        let hash;
-        try {
-            awaitWalletConfirmation('Please confirm deployment in your wallet...');
-            hash = await sendTransaction(config, {
-                to: orderbookAddress,
-                data: deploymentCalldata
-            });
-        }
-        catch {
-            return transactionError(TransactionErrorMessage.USER_REJECTED_TRANSACTION);
-        }
-        try {
-            const transactionExplorerLink = await getExplorerLink(hash, chainId, 'tx');
-            awaitTx(hash, TransactionStatusMessage.PENDING_DEPLOYMENT, transactionExplorerLink);
-            await waitForTransactionReceipt(config, { hash });
-            if (subgraphUrl) {
-                return awaitNewOrderIndexing(subgraphUrl, hash, network);
-            }
-            return transactionSuccess(hash, 'Deployment successful. Check the Orders page for your new order.', '', network);
-        }
-        catch {
-            return transactionError(TransactionErrorMessage.DEPLOYMENT_FAILED);
-        }
-    };
-    return {
-        subscribe,
-        reset,
-        handleDeploymentTransaction,
-        checkingWalletAllowance,
-        awaitWalletConfirmation,
-        awaitApprovalTx,
-        transactionSuccess,
-        transactionError,
-        awaitTransactionIndexing,
-        awaitNewOrderIndexing
-    };
-};
-export default transactionStore();