@rainlanguage/ui-components 0.0.1-alpha.21 → 0.0.1-alpha.211

package/dist/stores/transactionStore.js

@@ -1,303 +0,0 @@
-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/utils/time.d.ts

@@ -1,12 +0,0 @@
-import type { UTCTimestamp } from 'lightweight-charts';
-export declare function formatTimestampSecondsAsLocal(timestampSeconds: bigint): string;
-export declare function timestampSecondsToUTCTimestamp(timestampSeconds: bigint): UTCTimestamp;
-/**
- * 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 declare function promiseTimeout<T>(promise: Promise<T>, time: number, exception: unknown): Promise<T>;

package/dist/utils/time.js

@@ -1,27 +0,0 @@
-import dayjs from 'dayjs';
-import bigIntSupport from 'dayjs/plugin/bigIntSupport';
-import localizedFormat from 'dayjs/plugin/localizedFormat';
-dayjs.extend(bigIntSupport);
-dayjs.extend(localizedFormat);
-export function formatTimestampSecondsAsLocal(timestampSeconds) {
-    return dayjs(timestampSeconds * BigInt('1000')).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));
-}

package/dist/utils/vault.d.ts

@@ -1,2 +0,0 @@
-import type { SgVault } from '@rainlanguage/orderbook/js_api';
-export declare const vaultBalanceDisplay: (vault: SgVault) => string;

package/dist/utils/vault.js

@@ -1,29 +0,0 @@
-import { formatUnits } from 'viem';
-export const vaultBalanceDisplay = (vault) => {
-    return formatUnits(BigInt(vault.balance), +(vault.token?.decimals || 0));
-};
-if (import.meta.vitest) {
-    const { it, expect } = import.meta.vitest;
-    it('formats the vault balance correctly', () => {
-        const vault = {
-            id: '1',
-            balance: '1000000000000000000',
-            token: {
-                id: '1',
-                decimals: '18',
-                address: '0x00'
-            },
-            vaultId: '1',
-            owner: '0x00',
-            ordersAsInput: [],
-            ordersAsOutput: [],
-            balanceChanges: [],
-            orderbook: {
-                id: '0x00'
-            }
-        };
-        expect(vaultBalanceDisplay(vault)).toEqual('1');
-        vault.token.decimals = '6';
-        expect(vaultBalanceDisplay(vault)).toEqual('1000000000000');
-    });
-}