@rainlanguage/ui-components 0.0.1-alpha.10

package/dist/stores/transactionStore.d.ts

@@ -0,0 +1,98 @@
+import type { Hex } from 'viem';
+import type { Config } from '@wagmi/core';
+import type { ApprovalCalldata, DepositAndAddOrderCalldataResult, DepositCalldataResult, RemoveOrderCalldata, SgVault, WithdrawCalldataResult } from '@rainlanguage/orderbook/js_api';
+export declare const ADDRESS_ZERO = "0x0000000000000000000000000000000000000000";
+export declare const ONE: bigint;
+export declare enum TransactionStatus {
+    IDLE = "Idle",
+    CHECKING_ALLOWANCE = "Checking your allowance...",
+    PENDING_WALLET = "Waiting for wallet confirmation...",
+    PENDING_APPROVAL = "Approving token spend...",
+    PENDING_DEPLOYMENT = "Deploying your order...",
+    PENDING_WITHDRAWAL = "Withdrawing tokens...",
+    PENDING_DEPOSIT = "Depositing tokens...",
+    PENDING_REMOVE_ORDER = "Removing order...",
+    PENDING_SUBGRAPH = "Awaiting subgraph...",
+    SUCCESS = "Success! Transaction confirmed",
+    ERROR = "Something went wrong"
+}
+export declare enum TransactionErrorMessage {
+    BAD_CALLLDATA = "Bad calldata.",
+    DEPLOY_FAILED = "Lock transaction failed.",
+    TIMEOUT = "Transaction timed out.",
+    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.",
+    DEPOSIT_FAILED = "Failed to deposit tokens.",
+    WITHDRAWAL_FAILED = "Failed to withdraw tokens.",
+    REMOVE_ORDER_FAILED = "Failed to remove order."
+}
+export type ExtendedApprovalCalldata = ApprovalCalldata & {
+    symbol?: string;
+};
+export type DeploymentTransactionArgs = {
+    config: Config;
+    approvals: ExtendedApprovalCalldata[];
+    deploymentCalldata: DepositAndAddOrderCalldataResult;
+    orderbookAddress: Hex;
+    chainId: number;
+    subgraphUrl: string;
+    network: string;
+};
+export type DepositOrWithdrawTransactionArgs = {
+    config: Config;
+    approvalCalldata?: ApprovalCalldata;
+    transactionCalldata: DepositCalldataResult | WithdrawCalldataResult;
+    action: 'deposit' | 'withdraw';
+    chainId: number;
+    vault: SgVault;
+    subgraphUrl: string;
+};
+export type RemoveOrderTransactionArgs = {
+    config: Config;
+    orderbookAddress: Hex;
+    removeOrderCalldata: RemoveOrderCalldata;
+    chainId: number;
+    subgraphUrl: string;
+};
+export type TransactionState = {
+    status: TransactionStatus;
+    error: string;
+    hash: string;
+    data: null;
+    functionName: string;
+    message: string;
+    newOrderHash: string;
+    network: string;
+    explorerLink: string;
+};
+export type TransactionStore = {
+    subscribe: (run: (value: TransactionState) => void) => () => void;
+    reset: () => void;
+    handleDeploymentTransaction: (args: DeploymentTransactionArgs) => Promise<void>;
+    handleDepositOrWithdrawTransaction: (args: DepositOrWithdrawTransactionArgs) => Promise<void>;
+    handleRemoveOrderTransaction: (args: RemoveOrderTransactionArgs) => 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;
+};
+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>;
+    handleDepositOrWithdrawTransaction: ({ config, approvalCalldata, transactionCalldata, action, chainId, vault, subgraphUrl }: DepositOrWithdrawTransactionArgs) => Promise<void>;
+    handleRemoveOrderTransaction: ({ config, orderbookAddress, removeOrderCalldata, chainId, subgraphUrl }: RemoveOrderTransactionArgs) => 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: (message: TransactionErrorMessage, hash?: string) => void;
+    awaitTransactionIndexing: (subgraphUrl: string, txHash: string, successMessage: string) => Promise<void>;
+    awaitNewOrderIndexing: (subgraphUrl: string, txHash: string, network?: string) => Promise<void>;
+    awaitRemoveOrderIndexing: (subgraphUrl: string, txHash: string) => Promise<void>;
+};
+export default _default;

package/dist/stores/transactionStore.js

@@ -0,0 +1,303 @@
+import { writable } from 'svelte/store';
+import { sendTransaction, switchChain, waitForTransactionReceipt } from '@wagmi/core';
+import { getTransaction, getTransactionAddOrders, getTransactionRemoveOrders } from '@rainlanguage/orderbook/js_api';
+import { getExplorerLink } from '../services/getExplorerLink';
+export const ADDRESS_ZERO = '0x0000000000000000000000000000000000000000';
+export const ONE = BigInt('1000000000000000000');
+export var TransactionStatus;
+(function (TransactionStatus) {
+    TransactionStatus["IDLE"] = "Idle";
+    TransactionStatus["CHECKING_ALLOWANCE"] = "Checking your allowance...";
+    TransactionStatus["PENDING_WALLET"] = "Waiting for wallet confirmation...";
+    TransactionStatus["PENDING_APPROVAL"] = "Approving token spend...";
+    TransactionStatus["PENDING_DEPLOYMENT"] = "Deploying your order...";
+    TransactionStatus["PENDING_WITHDRAWAL"] = "Withdrawing tokens...";
+    TransactionStatus["PENDING_DEPOSIT"] = "Depositing tokens...";
+    TransactionStatus["PENDING_REMOVE_ORDER"] = "Removing order...";
+    TransactionStatus["PENDING_SUBGRAPH"] = "Awaiting subgraph...";
+    TransactionStatus["SUCCESS"] = "Success! Transaction confirmed";
+    TransactionStatus["ERROR"] = "Something went wrong";
+})(TransactionStatus || (TransactionStatus = {}));
+export var TransactionErrorMessage;
+(function (TransactionErrorMessage) {
+    TransactionErrorMessage["BAD_CALLLDATA"] = "Bad calldata.";
+    TransactionErrorMessage["DEPLOY_FAILED"] = "Lock transaction failed.";
+    TransactionErrorMessage["TIMEOUT"] = "Transaction timed out.";
+    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["DEPOSIT_FAILED"] = "Failed to deposit tokens.";
+    TransactionErrorMessage["WITHDRAWAL_FAILED"] = "Failed to withdraw tokens.";
+    TransactionErrorMessage["REMOVE_ORDER_FAILED"] = "Failed to remove order.";
+})(TransactionErrorMessage || (TransactionErrorMessage = {}));
+const initialState = {
+    status: TransactionStatus.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: TransactionStatus.PENDING_SUBGRAPH,
+            message: 'Checking for transaction indexing...'
+        }));
+        let attempts = 0;
+        let newTx;
+        const interval = setInterval(async () => {
+            attempts++;
+            newTx = await getTransaction(subgraphUrl, txHash);
+            if (newTx) {
+                clearInterval(interval);
+                transactionSuccess(txHash, successMessage);
+            }
+            else if (attempts >= 10) {
+                update((state) => ({
+                    ...state,
+                    message: 'The subgraph took too long to respond. Please check again later.'
+                }));
+                clearInterval(interval);
+                return transactionError(TransactionErrorMessage.TIMEOUT);
+            }
+        }, 1000);
+    };
+    const awaitNewOrderIndexing = async (subgraphUrl, txHash, network) => {
+        update((state) => ({
+            ...state,
+            status: TransactionStatus.PENDING_SUBGRAPH,
+            message: 'Waiting for new order to be indexed...'
+        }));
+        let attempts = 0;
+        const interval = setInterval(async () => {
+            attempts++;
+            const addOrders = await getTransactionAddOrders(subgraphUrl, txHash);
+            if (attempts >= 10) {
+                update((state) => ({
+                    ...state,
+                    message: 'The subgraph took too long to respond. Please check again later.'
+                }));
+                clearInterval(interval);
+                return transactionError(TransactionErrorMessage.TIMEOUT);
+            }
+            else if (addOrders?.length > 0) {
+                clearInterval(interval);
+                return transactionSuccess(txHash, '', addOrders[0].order.orderHash, network);
+            }
+        }, 1000);
+    };
+    const awaitRemoveOrderIndexing = async (subgraphUrl, txHash) => {
+        update((state) => ({
+            ...state,
+            status: TransactionStatus.PENDING_SUBGRAPH,
+            message: 'Waiting for order removal to be indexed...'
+        }));
+        let attempts = 0;
+        const interval = setInterval(async () => {
+            attempts++;
+            const removeOrders = await getTransactionRemoveOrders(subgraphUrl, txHash);
+            if (attempts >= 10) {
+                update((state) => ({
+                    ...state,
+                    message: 'The subgraph took too long to respond. Please check again later.'
+                }));
+                clearInterval(interval);
+                return transactionError(TransactionErrorMessage.TIMEOUT);
+            }
+            else if (removeOrders?.length > 0) {
+                clearInterval(interval);
+                return transactionSuccess(txHash);
+            }
+        }, 1000);
+    };
+    const checkingWalletAllowance = (message) => update((state) => ({
+        ...state,
+        status: TransactionStatus.CHECKING_ALLOWANCE,
+        message: message || ''
+    }));
+    const awaitWalletConfirmation = (message) => update((state) => ({
+        ...state,
+        status: TransactionStatus.PENDING_WALLET,
+        message: message || ''
+    }));
+    const awaitApprovalTx = (hash, symbol) => update((state) => ({
+        ...state,
+        hash: hash,
+        status: TransactionStatus.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: TransactionStatus.SUCCESS,
+            hash: hash,
+            message: message || '',
+            newOrderHash: newOrderHash || '',
+            network: network || ''
+        }));
+    };
+    const transactionError = (message, hash) => update((state) => ({
+        ...state,
+        status: TransactionStatus.ERROR,
+        error: message,
+        hash: hash || ''
+    }));
+    const handleDeploymentTransaction = async ({ config, approvals, deploymentCalldata, orderbookAddress, chainId, subgraphUrl, network }) => {
+        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, TransactionStatus.PENDING_DEPLOYMENT, transactionExplorerLink);
+            await waitForTransactionReceipt(config, { hash });
+            return awaitNewOrderIndexing(subgraphUrl, hash, network);
+        }
+        catch {
+            return transactionError(TransactionErrorMessage.DEPLOYMENT_FAILED);
+        }
+    };
+    const handleDepositOrWithdrawTransaction = async ({ config, approvalCalldata, transactionCalldata, action, chainId, vault, subgraphUrl }) => {
+        try {
+            await switchChain(config, { chainId });
+        }
+        catch {
+            return transactionError(TransactionErrorMessage.SWITCH_CHAIN_FAILED);
+        }
+        if (approvalCalldata) {
+            let approvalHash;
+            try {
+                awaitWalletConfirmation(`Please approve ${vault.token.symbol} spend in your wallet...`);
+                approvalHash = await sendTransaction(config, {
+                    to: vault.token.address,
+                    data: approvalCalldata
+                });
+            }
+            catch {
+                return transactionError(TransactionErrorMessage.USER_REJECTED_APPROVAL);
+            }
+            try {
+                awaitApprovalTx(approvalHash, vault.token.symbol);
+                await waitForTransactionReceipt(config, { hash: approvalHash });
+            }
+            catch {
+                return transactionError(TransactionErrorMessage.APPROVAL_FAILED);
+            }
+        }
+        let hash;
+        try {
+            awaitWalletConfirmation(`Please confirm ${action === 'deposit' ? 'deposit' : 'withdrawal'} in your wallet...`);
+            hash = await sendTransaction(config, {
+                to: vault.orderbook.id,
+                data: transactionCalldata
+            });
+        }
+        catch {
+            return transactionError(TransactionErrorMessage.USER_REJECTED_TRANSACTION);
+        }
+        try {
+            awaitTx(hash, action === 'deposit'
+                ? TransactionStatus.PENDING_DEPOSIT
+                : TransactionStatus.PENDING_WITHDRAWAL);
+            await waitForTransactionReceipt(config, { hash });
+            return awaitTransactionIndexing(subgraphUrl, hash, `The ${action === 'deposit' ? 'deposit' : 'withdrawal'} was successful.`);
+        }
+        catch {
+            return transactionError(action === 'deposit'
+                ? TransactionErrorMessage.DEPOSIT_FAILED
+                : TransactionErrorMessage.WITHDRAWAL_FAILED);
+        }
+    };
+    const handleRemoveOrderTransaction = async ({ config, orderbookAddress, removeOrderCalldata, chainId, subgraphUrl }) => {
+        try {
+            await switchChain(config, { chainId });
+        }
+        catch {
+            return transactionError(TransactionErrorMessage.SWITCH_CHAIN_FAILED);
+        }
+        let hash;
+        try {
+            awaitWalletConfirmation('Please confirm order removal in your wallet...');
+            hash = await sendTransaction(config, {
+                to: orderbookAddress,
+                data: removeOrderCalldata
+            });
+        }
+        catch {
+            return transactionError(TransactionErrorMessage.USER_REJECTED_TRANSACTION);
+        }
+        try {
+            awaitTx(hash, TransactionStatus.PENDING_REMOVE_ORDER);
+            await waitForTransactionReceipt(config, { hash });
+            return awaitRemoveOrderIndexing(subgraphUrl, hash);
+        }
+        catch {
+            return transactionError(TransactionErrorMessage.REMOVE_ORDER_FAILED);
+        }
+    };
+    return {
+        subscribe,
+        reset,
+        handleDeploymentTransaction,
+        handleDepositOrWithdrawTransaction,
+        handleRemoveOrderTransaction,
+        checkingWalletAllowance,
+        awaitWalletConfirmation,
+        awaitApprovalTx,
+        transactionSuccess,
+        transactionError,
+        awaitTransactionIndexing,
+        awaitNewOrderIndexing,
+        awaitRemoveOrderIndexing
+    };
+};
+export default transactionStore();

package/dist/test/matchers.d.ts

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

package/dist/test/matchers.js

@@ -0,0 +1,4 @@
+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/appStores.d.ts

@@ -0,0 +1,19 @@
+import type { Readable, Writable } from 'svelte/store';
+import type { ConfigSource, OrderbookConfigSource } from '@rainlanguage/orderbook/js_api';
+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>;
+    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>;
+}

package/dist/types/appStores.js

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

package/dist/types/modal.d.ts

@@ -0,0 +1,20 @@
+import type { SgOrder } from '@rainlanguage/orderbook/js_api';
+import type { DepositOrWithdrawArgs, OrderRemoveArgs, DeploymentArgs } from './transaction';
+export type DepositOrWithdrawModalProps = {
+    open: boolean;
+    args: DepositOrWithdrawArgs;
+};
+export type OrderRemoveModalProps = {
+    open: boolean;
+    args: OrderRemoveArgs;
+};
+export type DeployModalProps = {
+    open: boolean;
+    args: DeploymentArgs;
+};
+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;

package/dist/types/modal.js

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

package/dist/types/strategy.d.ts

@@ -0,0 +1,10 @@
+import type { NameAndDescriptionCfg } from '@rainlanguage/orderbook/js_api';
+export type ValidStrategyDetail = {
+    details: NameAndDescriptionCfg;
+    name: string;
+    dotrain: string;
+};
+export type InvalidStrategyDetail = {
+    name: string;
+    error: string;
+};

package/dist/types/strategy.js

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

package/dist/types/transaction.d.ts

@@ -0,0 +1,27 @@
+import type { ExtendedApprovalCalldata } from '../stores/transactionStore';
+import type { DepositAndAddOrderCalldataResult } from '@rainlanguage/orderbook/js_api';
+import type { Hex } from 'viem';
+import type { SgOrder, SgVault } from '@rainlanguage/orderbook/js_api';
+export type DeploymentArgs = {
+    approvals: ExtendedApprovalCalldata[];
+    deploymentCalldata: DepositAndAddOrderCalldataResult;
+    orderbookAddress: Hex;
+    chainId: number;
+    subgraphUrl: string;
+    network: string;
+};
+export type DepositOrWithdrawArgs = {
+    vault: SgVault;
+    onDepositOrWithdraw: () => void;
+    action: 'deposit' | 'withdraw';
+    chainId: number;
+    rpcUrl: string;
+    subgraphUrl: string;
+};
+export type OrderRemoveArgs = {
+    order: SgOrder;
+    onRemove: () => void;
+    chainId: number;
+    orderbookAddress: Hex;
+    subgraphUrl: string;
+};

package/dist/types/transaction.js

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

package/dist/utils/breadcrumbs.d.ts

@@ -0,0 +1,5 @@
+export interface BreadCrumb {
+    label: string;
+    href: string;
+}
+export declare function generateBreadcrumbs(path: string): BreadCrumb[];

package/dist/utils/breadcrumbs.js

@@ -0,0 +1,9 @@
+export function generateBreadcrumbs(path) {
+    const crumbs = path.split('/');
+    return crumbs
+        .map((c, i) => ({
+        label: c,
+        href: crumbs.slice(0, i + 1).join('/')
+    }))
+        .slice(1, -1);
+}

package/dist/utils/codeMirrorThemes.d.ts

@@ -0,0 +1,2 @@
+export declare const lightCodeMirrorTheme: import("@codemirror/state").Extension;
+export declare const darkCodeMirrorTheme: import("@codemirror/state").Extension;

package/dist/utils/codeMirrorThemes.js

@@ -0,0 +1,86 @@
+import { createTheme } from 'thememirror';
+import { tags } from '@lezer/highlight';
+// configured to resemble vscode default light theme
+export const lightCodeMirrorTheme = createTheme({
+    variant: 'light',
+    settings: {
+        background: '#ffffff',
+        foreground: '#001080',
+        caret: '#000000',
+        selection: '#add6ff',
+        lineHighlight: '#77777740',
+        gutterBackground: '#eeeeee',
+        gutterForeground: '#237893'
+    },
+    styles: [
+        { tag: tags.comment, color: '#008001' },
+        { tag: tags.variableName, color: '#0070c1' },
+        { tag: [tags.string, tags.special(tags.brace)], color: '#b55b00' },
+        { tag: tags.number, color: '#00b97b' },
+        { tag: tags.bool, color: '#0000ff' },
+        { tag: tags.null, color: '#0000ff' },
+        { tag: tags.unit, color: '#0000ff' },
+        { tag: tags.keyword, color: '#af01db' },
+        { tag: tags.operator, color: '#000000' },
+        { tag: tags.className, color: '#257f99' },
+        { tag: tags.meta, color: '#0950a9' },
+        { tag: tags.definition(tags.typeName), color: '#257f99' },
+        { tag: tags.angleBracket, color: '#213CF1' },
+        { tag: tags.brace, color: '#213CF1' },
+        { tag: tags.bracket, color: '#213CF1' },
+        { tag: tags.squareBracket, color: '#213CF1' },
+        { tag: tags.paren, color: '#213CF1' },
+        { tag: tags.punctuation, color: '#464646' },
+        { tag: tags.separator, color: '#464646' },
+        { tag: tags.typeName, color: '#257f99' },
+        { tag: tags.tagName, color: '#800000' },
+        { tag: tags.attributeName, color: '#eb3d36' },
+        { tag: tags.attributeValue, color: '#444444' },
+        { tag: tags.content, color: '#b55b00' },
+        { tag: [tags.propertyName, tags.definition(tags.propertyName)], color: '#0469ff' },
+        { tag: tags.labelName, color: '#4fc4ff' },
+        { tag: tags.deleted, color: '#cc0000' }
+    ]
+});
+// configured to resemble vscode default dark theme
+export const darkCodeMirrorTheme = createTheme({
+    variant: 'dark',
+    settings: {
+        background: '#1e1e1e',
+        foreground: '#d4d4d4',
+        caret: '#d4d4d4',
+        selection: '#ffffff',
+        lineHighlight: '#99999940',
+        gutterBackground: '#282828',
+        gutterForeground: '#858585'
+    },
+    styles: [
+        { tag: [tags.comment, tags.lineComment], color: '#6c9e57' },
+        { tag: tags.variableName, color: '#9cdcfe' },
+        { tag: [tags.string, tags.special(tags.brace)], color: '#ce9178' },
+        { tag: tags.number, color: '#B6CFA9' },
+        { tag: tags.bool, color: '#4fc4ff' },
+        { tag: tags.null, color: '#4fc4ff' },
+        { tag: tags.unit, color: '#608FC2' },
+        { tag: tags.keyword, color: '#d18dcc' },
+        { tag: tags.operator, color: '#d4d4d4' },
+        { tag: tags.className, color: '#4dcab1' },
+        { tag: tags.meta, color: '#608FC2' },
+        { tag: tags.definition(tags.typeName), color: '#4fcfb5' },
+        { tag: tags.angleBracket, color: '#F9D849' },
+        { tag: tags.brace, color: '#F9D849' },
+        { tag: tags.bracket, color: '#F9D849' },
+        { tag: tags.squareBracket, color: '#F9D849' },
+        { tag: tags.paren, color: '#F9D849' },
+        { tag: tags.punctuation, color: '#d4d4d4' },
+        { tag: tags.separator, color: '#d4d4d4' },
+        { tag: tags.typeName, color: '#4ecdb4' },
+        { tag: tags.tagName, color: '#59a3df' },
+        { tag: tags.attributeName, color: '#ffffff' },
+        { tag: tags.attributeValue, color: '#ffffff' },
+        { tag: tags.content, color: '#ce9178' },
+        { tag: [tags.propertyName, tags.definition(tags.propertyName)], color: '#608FC2' },
+        { tag: tags.labelName, color: '#4fc4ff' },
+        { tag: tags.deleted, color: '#c86464' }
+    ]
+});

package/dist/utils/hex.d.ts

@@ -0,0 +1,2 @@
+export declare const HEX_INPUT_REGEX: RegExp;
+export declare const bigintStringToHex: (val: string) => `0x${string}`;

package/dist/utils/hex.js

@@ -0,0 +1,3 @@
+import { toHex } from 'viem';
+export const HEX_INPUT_REGEX = /^(0x)?([0-9a-f]+)?$/;
+export const bigintStringToHex = (val) => toHex(BigInt(val));