@fileverse-dev/dsheet 2.1.5 → 3.0.1-yjs-1

package/dist/editor/utils/config-ydoc-update.d.ts

@@ -0,0 +1,20 @@
+import { WorkbookInstance } from '../../sheet-engine/react';
+import { SheetChangePath } from './update-ydoc';
+
+import * as Y from 'yjs';
+/** Diff top-level config sub-keys and emit granular Yjs updates. */
+export declare function buildConfigSubKeyChanges({ sheetId, oldConfig, newConfig, }: {
+    sheetId: string;
+    oldConfig: Record<string, any>;
+    newConfig: Record<string, any>;
+}): SheetChangePath[];
+/**
+ * Sync active sheet config sub-keys to Yjs (borderInfo, merge, rowlen, …).
+ * Replaces whole-config writes so only changed sub-keys are broadcast.
+ */
+export declare const configYdocUpdate: ({ sheetEditorRef, ydocRef, dsheetId, handleContentPortal, }: {
+    sheetEditorRef: React.RefObject<WorkbookInstance | null>;
+    ydocRef: React.RefObject<Y.Doc | null>;
+    dsheetId: string;
+    handleContentPortal?: any;
+}) => void;

package/dist/editor/utils/csv-import.d.ts

@@ -2,4 +2,6 @@ import { default as React } from 'react';
 import { WorkbookInstance } from '../../sheet-engine/react';
 
 import * as Y from 'yjs';
-export declare const handleCSVUpload: (event: React.ChangeEventHandler<HTMLInputElement> | undefined, ydoc: Y.Doc | null, setForceSheetRender: React.Dispatch<React.SetStateAction<number>>, dsheetId: string, currentDataRef: React.MutableRefObject<object | null>, sheetEditorRef: React.RefObject<WorkbookInstance | null>, updateDocumentTitle?: (title: string) => void, fileArg?: File, importType?: string, handleContentPortal?: any, separatorType?: string) => Promise<void>;
+export declare const handleCSVUpload: (event: React.ChangeEventHandler<HTMLInputElement> | undefined, ydoc: Y.Doc | null, setForceSheetRender: React.Dispatch<React.SetStateAction<number>>, dsheetId: string, currentDataRef: React.MutableRefObject<object | null>, sheetEditorRef: React.RefObject<WorkbookInstance | null>, updateDocumentTitle?: (title: string) => void, fileArg?: File, importType?: string, handleContentPortal?: any, separatorType?: string, options?: {
+    suppressUiWarnings?: boolean;
+}) => Promise<void>;

package/dist/editor/utils/data-block-error-handler.d.ts

@@ -0,0 +1,21 @@
+import { Cell, WorkbookInstance } from '../../sheet-engine/react';
+import { DataBlockEvent, ErrorMessageHandlerReturnType } from '../types';
+import { ApiKeyStorage } from './api-key-storage';
+import { SmartContractQueryHandler } from './after-update-cell';
+
+export type OpenApiKeyModalFn = (apiKeyName: string, callbacks: {
+    onSave: (key: string) => void;
+    onClose: () => void;
+}) => void;
+export interface DataBlockErrorHandlerParams {
+    data: ErrorMessageHandlerReturnType;
+    sheetEditorRef: React.RefObject<WorkbookInstance | null>;
+    row: number;
+    column: number;
+    newValue: Cell;
+    apiKeyStorage: ApiKeyStorage;
+    openApiKeyModal: OpenApiKeyModalFn;
+    onDataBlockEvent?: (event: DataBlockEvent) => void;
+    handleSmartContractQuery?: SmartContractQueryHandler;
+}
+export declare const handleDataBlockError: ({ data, sheetEditorRef, row, column, newValue, apiKeyStorage, openApiKeyModal, onDataBlockEvent, handleSmartContractQuery, }: DataBlockErrorHandlerParams) => Promise<void>;

package/dist/editor/utils/datablock-error-utils.d.ts

@@ -0,0 +1 @@
+export declare const isDatablockError: (value: unknown) => boolean;

package/dist/editor/utils/sheet-editor-safe.d.ts

@@ -0,0 +1,26 @@
+import { RefObject } from 'react';
+import { SheetEditorRef } from '../types/comments';
+
+type SheetEditorRefLike = RefObject<SheetEditorRef | null> | null | undefined;
+type WorkbookSheetLike = {
+    id?: string;
+    order?: number;
+    name?: string;
+};
+export declare function isWorkbookReady(ref: SheetEditorRefLike): boolean;
+export declare function getCurrentSheetSafe(ref: SheetEditorRefLike): WorkbookSheetLike | null;
+export declare function getCurrentSheetOrderSafe(ref: SheetEditorRefLike): number;
+export declare function getCurrentSheetIdSafe(ref: SheetEditorRefLike): string;
+export declare function getAllSheetsSafe(ref: SheetEditorRefLike): WorkbookSheetLike[];
+export declare function buildSheetOrderNameMap(ref: SheetEditorRefLike): Map<number, string>;
+/**
+ * Returns a map keyed by BOTH the sheet's immutable id AND its numeric
+ * order-as-string so that both new (UUID) and legacy (order) comment keys
+ * resolve to the correct display name in a single lookup.
+ */
+export declare function buildSheetIdNameMap(ref: SheetEditorRefLike): Map<string, string>;
+export declare function findSheetById(ref: SheetEditorRefLike, id: string): WorkbookSheetLike | null;
+export declare function activateSheetById(ref: SheetEditorRefLike, id: string): boolean;
+export declare function findSheetByOrder(ref: SheetEditorRefLike, order: number): WorkbookSheetLike | null;
+export declare function activateSheetByOrder(ref: SheetEditorRefLike, order: number): boolean;
+export {};

package/dist/editor/utils/smart-contract/constants.d.ts

@@ -0,0 +1,488 @@
+import { ContractConfig, SupportedChain } from '../../types/smart-contract';
+
+export declare const DEFAULT_RPC_URL_MAP: Record<SupportedChain, string[]>;
+export declare const SUPPORTED_VIEM_CHAIN_MAP: {
+    Sepolia: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Etherscan";
+                readonly url: "https://sepolia.etherscan.io";
+                readonly apiUrl: "https://api-sepolia.etherscan.io/api";
+            };
+        };
+        blockTime?: number | undefined | undefined;
+        contracts: {
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 751532;
+            };
+            readonly ensUniversalResolver: {
+                readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
+                readonly blockCreated: 8928790;
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 11155111;
+        name: "Sepolia";
+        nativeCurrency: {
+            readonly name: "Sepolia Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://11155111.rpc.thirdweb.com"];
+            };
+        };
+        sourceId?: number | undefined | undefined;
+        testnet: true;
+        custom?: Record<string, unknown> | undefined;
+        extendSchema?: Record<string, unknown> | undefined;
+        fees?: import('viem').ChainFees<undefined> | undefined;
+        formatters?: undefined;
+        prepareTransactionRequest?: ((args: import('viem').PrepareTransactionRequestParameters, options: {
+            client: import('viem').Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import('viem').PrepareTransactionRequestParameters>) | [fn: ((args: import('viem').PrepareTransactionRequestParameters, options: {
+            client: import('viem').Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import('viem').PrepareTransactionRequestParameters>) | undefined, options: {
+            runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+        }] | undefined;
+        serializers?: import('viem').ChainSerializers<undefined, import('viem').TransactionSerializable> | undefined;
+        verifyHash?: ((client: import('viem').Client, parameters: import('viem').VerifyHashActionParameters) => Promise<import('viem').VerifyHashActionReturnType>) | undefined;
+    };
+    Gnosis: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Gnosisscan";
+                readonly url: "https://gnosisscan.io";
+                readonly apiUrl: "https://api.gnosisscan.io/api";
+            };
+        };
+        blockTime: 5000;
+        contracts: {
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 21022491;
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 100;
+        name: "Gnosis";
+        nativeCurrency: {
+            readonly decimals: 18;
+            readonly name: "xDAI";
+            readonly symbol: "XDAI";
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://rpc.gnosischain.com"];
+                readonly webSocket: readonly ["wss://rpc.gnosischain.com/wss"];
+            };
+        };
+        sourceId?: number | undefined | undefined;
+        testnet?: boolean | undefined | undefined;
+        custom?: Record<string, unknown> | undefined;
+        extendSchema?: Record<string, unknown> | undefined;
+        fees?: import('viem').ChainFees<undefined> | undefined;
+        formatters?: undefined;
+        prepareTransactionRequest?: ((args: import('viem').PrepareTransactionRequestParameters, options: {
+            client: import('viem').Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import('viem').PrepareTransactionRequestParameters>) | [fn: ((args: import('viem').PrepareTransactionRequestParameters, options: {
+            client: import('viem').Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import('viem').PrepareTransactionRequestParameters>) | undefined, options: {
+            runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+        }] | undefined;
+        serializers?: import('viem').ChainSerializers<undefined, import('viem').TransactionSerializable> | undefined;
+        verifyHash?: ((client: import('viem').Client, parameters: import('viem').VerifyHashActionParameters) => Promise<import('viem').VerifyHashActionReturnType>) | undefined;
+    };
+    Base: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Basescan";
+                readonly url: "https://basescan.org";
+                readonly apiUrl: "https://api.basescan.org/api";
+            };
+        };
+        blockTime: 2000;
+        contracts: {
+            readonly disputeGameFactory: {
+                readonly 1: {
+                    readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
+                };
+            };
+            readonly l2OutputOracle: {
+                readonly 1: {
+                    readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
+                };
+            };
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 5022;
+            };
+            readonly portal: {
+                readonly 1: {
+                    readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
+                    readonly blockCreated: 17482143;
+                };
+            };
+            readonly l1StandardBridge: {
+                readonly 1: {
+                    readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
+                    readonly blockCreated: 17482143;
+                };
+            };
+            readonly gasPriceOracle: {
+                readonly address: "0x420000000000000000000000000000000000000F";
+            };
+            readonly l1Block: {
+                readonly address: "0x4200000000000000000000000000000000000015";
+            };
+            readonly l2CrossDomainMessenger: {
+                readonly address: "0x4200000000000000000000000000000000000007";
+            };
+            readonly l2Erc721Bridge: {
+                readonly address: "0x4200000000000000000000000000000000000014";
+            };
+            readonly l2StandardBridge: {
+                readonly address: "0x4200000000000000000000000000000000000010";
+            };
+            readonly l2ToL1MessagePasser: {
+                readonly address: "0x4200000000000000000000000000000000000016";
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 8453;
+        name: "Base";
+        nativeCurrency: {
+            readonly name: "Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://mainnet.base.org"];
+            };
+        };
+        sourceId: 1;
+        testnet?: boolean | undefined | undefined;
+        custom?: Record<string, unknown> | undefined;
+        extendSchema?: Record<string, unknown> | undefined;
+        fees?: import('viem').ChainFees<undefined> | undefined;
+        formatters: {
+            readonly block: {
+                exclude: [] | undefined;
+                format: (args: import('viem/chains').OpStackRpcBlock, action?: string | undefined) => {
+                    baseFeePerGas: bigint | null;
+                    blobGasUsed: bigint;
+                    difficulty: bigint;
+                    excessBlobGas: bigint;
+                    extraData: import('viem').Hex;
+                    gasLimit: bigint;
+                    gasUsed: bigint;
+                    hash: `0x${string}` | null;
+                    logsBloom: `0x${string}` | null;
+                    miner: import('abitype').Address;
+                    mixHash: import('viem').Hash;
+                    nonce: `0x${string}` | null;
+                    number: bigint | null;
+                    parentBeaconBlockRoot?: `0x${string}` | undefined;
+                    parentHash: import('viem').Hash;
+                    receiptsRoot: import('viem').Hex;
+                    sealFields: import('viem').Hex[];
+                    sha3Uncles: import('viem').Hash;
+                    size: bigint;
+                    stateRoot: import('viem').Hash;
+                    timestamp: bigint;
+                    totalDifficulty: bigint | null;
+                    transactions: `0x${string}`[] | import('viem/chains').OpStackTransaction<boolean>[];
+                    transactionsRoot: import('viem').Hash;
+                    uncles: import('viem').Hash[];
+                    withdrawals?: import('viem').Withdrawal[] | undefined | undefined;
+                    withdrawalsRoot?: `0x${string}` | undefined;
+                } & {};
+                type: "block";
+            };
+            readonly transaction: {
+                exclude: [] | undefined;
+                format: (args: import('viem/chains').OpStackRpcTransaction, action?: string | undefined) => ({
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    blockTimestamp?: bigint | undefined;
+                    from: import('abitype').Address;
+                    gas: bigint;
+                    hash: import('viem').Hash;
+                    input: import('viem').Hex;
+                    nonce: number;
+                    r: import('viem').Hex;
+                    s: import('viem').Hex;
+                    to: import('abitype').Address | null;
+                    transactionIndex: number | null;
+                    typeHex: import('viem').Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: boolean;
+                    mint?: bigint | undefined | undefined;
+                    sourceHash: import('viem').Hex;
+                    type: "deposit";
+                } | {
+                    r: import('viem').Hex;
+                    s: import('viem').Hex;
+                    v: bigint;
+                    to: import('abitype').Address | null;
+                    from: import('abitype').Address;
+                    gas: bigint;
+                    nonce: number;
+                    value: bigint;
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    blockTimestamp?: bigint | undefined;
+                    hash: import('viem').Hash;
+                    input: import('viem').Hex;
+                    transactionIndex: number | null;
+                    typeHex: import('viem').Hex | null;
+                    accessList?: undefined | undefined;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId?: number | undefined;
+                    yParity?: undefined | undefined;
+                    type: "legacy";
+                    gasPrice: bigint;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas?: undefined | undefined;
+                    maxPriorityFeePerGas?: undefined | undefined;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    blockTimestamp?: bigint | undefined;
+                    from: import('abitype').Address;
+                    gas: bigint;
+                    hash: import('viem').Hash;
+                    input: import('viem').Hex;
+                    nonce: number;
+                    r: import('viem').Hex;
+                    s: import('viem').Hex;
+                    to: import('abitype').Address | null;
+                    transactionIndex: number | null;
+                    typeHex: import('viem').Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: import('viem').AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip2930";
+                    gasPrice: bigint;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas?: undefined | undefined;
+                    maxPriorityFeePerGas?: undefined | undefined;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    blockTimestamp?: bigint | undefined;
+                    from: import('abitype').Address;
+                    gas: bigint;
+                    hash: import('viem').Hash;
+                    input: import('viem').Hex;
+                    nonce: number;
+                    r: import('viem').Hex;
+                    s: import('viem').Hex;
+                    to: import('abitype').Address | null;
+                    transactionIndex: number | null;
+                    typeHex: import('viem').Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: import('viem').AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip1559";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    blockTimestamp?: bigint | undefined;
+                    from: import('abitype').Address;
+                    gas: bigint;
+                    hash: import('viem').Hash;
+                    input: import('viem').Hex;
+                    nonce: number;
+                    r: import('viem').Hex;
+                    s: import('viem').Hex;
+                    to: import('abitype').Address | null;
+                    transactionIndex: number | null;
+                    typeHex: import('viem').Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: import('viem').AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes: readonly import('viem').Hex[];
+                    chainId: number;
+                    type: "eip4844";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas: bigint;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    blockTimestamp?: bigint | undefined;
+                    from: import('abitype').Address;
+                    gas: bigint;
+                    hash: import('viem').Hash;
+                    input: import('viem').Hex;
+                    nonce: number;
+                    r: import('viem').Hex;
+                    s: import('viem').Hex;
+                    to: import('abitype').Address | null;
+                    transactionIndex: number | null;
+                    typeHex: import('viem').Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: import('viem').AccessList;
+                    authorizationList: import('viem').SignedAuthorizationList;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip7702";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                }) & {};
+                type: "transaction";
+            };
+            readonly transactionReceipt: {
+                exclude: [] | undefined;
+                format: (args: import('viem/chains').OpStackRpcTransactionReceipt, action?: string | undefined) => {
+                    blobGasPrice?: bigint | undefined;
+                    blobGasUsed?: bigint | undefined;
+                    blockHash: import('viem').Hash;
+                    blockNumber: bigint;
+                    blockTimestamp?: bigint | undefined;
+                    contractAddress: import('abitype').Address | null | undefined;
+                    cumulativeGasUsed: bigint;
+                    effectiveGasPrice: bigint;
+                    from: import('abitype').Address;
+                    gasUsed: bigint;
+                    logs: import('viem').Log<bigint, number, false>[];
+                    logsBloom: import('viem').Hex;
+                    root?: `0x${string}` | undefined;
+                    status: "success" | "reverted";
+                    to: import('abitype').Address | null;
+                    transactionHash: import('viem').Hash;
+                    transactionIndex: number;
+                    type: import('viem').TransactionType;
+                    l1GasPrice: bigint | null;
+                    l1GasUsed: bigint | null;
+                    l1Fee: bigint | null;
+                    l1FeeScalar: number | null;
+                } & {};
+                type: "transactionReceipt";
+            };
+        };
+        prepareTransactionRequest?: ((args: import('viem').PrepareTransactionRequestParameters, options: {
+            client: import('viem').Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import('viem').PrepareTransactionRequestParameters>) | [fn: ((args: import('viem').PrepareTransactionRequestParameters, options: {
+            client: import('viem').Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import('viem').PrepareTransactionRequestParameters>) | undefined, options: {
+            runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+        }] | undefined;
+        serializers: {
+            readonly transaction: typeof import('viem/chains').serializeTransactionOpStack;
+        };
+        verifyHash?: ((client: import('viem').Client, parameters: import('viem').VerifyHashActionParameters) => Promise<import('viem').VerifyHashActionReturnType>) | undefined;
+    };
+    Ethereum: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Etherscan";
+                readonly url: "https://etherscan.io";
+                readonly apiUrl: "https://api.etherscan.io/api";
+            };
+        };
+        blockTime: 12000;
+        contracts: {
+            readonly ensUniversalResolver: {
+                readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
+                readonly blockCreated: 23085558;
+            };
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 14353601;
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 1;
+        name: "Ethereum";
+        nativeCurrency: {
+            readonly name: "Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://eth.merkle.io"];
+            };
+        };
+        sourceId?: number | undefined | undefined;
+        testnet?: boolean | undefined | undefined;
+        custom?: Record<string, unknown> | undefined;
+        extendSchema?: Record<string, unknown> | undefined;
+        fees?: import('viem').ChainFees<undefined> | undefined;
+        formatters?: undefined;
+        prepareTransactionRequest?: ((args: import('viem').PrepareTransactionRequestParameters, options: {
+            client: import('viem').Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import('viem').PrepareTransactionRequestParameters>) | [fn: ((args: import('viem').PrepareTransactionRequestParameters, options: {
+            client: import('viem').Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import('viem').PrepareTransactionRequestParameters>) | undefined, options: {
+            runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+        }] | undefined;
+        serializers?: import('viem').ChainSerializers<undefined, import('viem').TransactionSerializable> | undefined;
+        verifyHash?: ((client: import('viem').Client, parameters: import('viem').VerifyHashActionParameters) => Promise<import('viem').VerifyHashActionReturnType>) | undefined;
+    };
+};
+export declare const SUPPORTED_CHAIN_ID_MAP: Record<number, SupportedChain>;
+export declare const CHAIN_NAME_MAP: Record<string, SupportedChain>;
+export declare const POPULAR_CONTRACTS_MAP: Record<string, ContractConfig>;
+export declare const UNIVERSAL_ENS_RESOLVER_ADDRESS = "0xce01f8eee7E479C928F8919abD53E553a36CeF67";
+export declare const RESOLVER_FUNCTION_NAME = "findResolver";
+export declare const SMART_CONTRACT_PANEL_ID = "smart-contract-list-view";
+export declare const POPULAR_CONTRACT_NAMES: Set<string>;

package/dist/editor/utils/smart-contract/error-helper.d.ts

@@ -0,0 +1,20 @@
+import { Hex } from 'viem';
+
+export declare class ContractNotFound extends Error {
+    constructor(contractName: string);
+}
+export declare class InvalidFunctionName extends Error {
+    constructor(functionName: string);
+}
+export declare class ReadOnlyError extends Error {
+    constructor(functionName: string);
+}
+export declare class InvalidParams extends Error {
+    constructor(message: string);
+}
+export declare class UnsupportedChainError extends Error {
+    constructor(chainId: number | Hex | string);
+}
+export declare class ContractAbiFetchError extends Error {
+    constructor(contractAddress: string, chainId: number | Hex);
+}

package/dist/editor/utils/smart-contract/helpers.d.ts

@@ -0,0 +1,4 @@
+export declare function sanitizeValue(value: unknown): unknown;
+export declare function flattenArray(arr: unknown[]): unknown[];
+export declare function flattenObject(obj: Record<string, unknown>): Record<string, unknown>;
+export declare function isPlainObject(val: unknown): val is Record<string, unknown>;

package/dist/editor/utils/smart-contract/reading-utils.d.ts

@@ -0,0 +1,34 @@
+import { Abi, AbiParameter, Chain, Hex } from 'viem';
+import { CallerParams, ContractConfig, ContractRegistry, FetchAbiParams, ParsedFunction, SupportedChain } from '../../types/smart-contract';
+
+export type SmartContractRuntimeDeps = {
+    resolveAbi?: (abiHash: string) => Promise<Abi>;
+    rpcConfig?: Partial<Record<SupportedChain, string>>;
+    abiCache: Record<string, Abi>;
+};
+export declare const getContractConfig: (contractName: string, contractRegistry: ContractRegistry) => ContractConfig;
+export declare const fetchAbi: (params: FetchAbiParams, deps: SmartContractRuntimeDeps) => Promise<Abi>;
+export declare const validateParams: (functionInput: readonly AbiParameter[], args: unknown[]) => boolean;
+export declare const getChainFromChainId: (chainId: number | Hex | string) => Chain;
+export declare const fetchVerifiedAbi: (contractAddress: Hex, chain: Chain, exactFields?: string[]) => Promise<Abi>;
+export declare function parseAbiViewFunctions(abi: Abi): ParsedFunction[];
+export declare const getCallerParamsByAddress: (callSignature: unknown[], deps: SmartContractRuntimeDeps) => Promise<CallerParams>;
+export declare const getCallerParamsByName: (callSignature: unknown[], registry: ContractRegistry, deps: SmartContractRuntimeDeps) => Promise<CallerParams>;
+export declare const parseCallSignature: (callSignature: unknown[], registry: ContractRegistry, deps: SmartContractRuntimeDeps) => Promise<CallerParams>;
+export declare const executeSmartContractCall: (params: CallerParams, deps: SmartContractRuntimeDeps) => Promise<{
+    response: {
+        'Function name': string;
+        Argument: string;
+        stateMutability: import('abitype').AbiStateMutability;
+    }[];
+    staticInstructions: string[];
+    outputType?: undefined;
+} | {
+    response: unknown;
+    outputType: readonly AbiParameter[];
+    staticInstructions?: undefined;
+}>;
+export declare const validateAbi: (abi: unknown) => void;
+export declare const normalizeGridArray: (input: unknown[], functionName: string, abi: Abi) => any[];
+export declare const fetchContractAbi: (contract: ContractConfig, deps: SmartContractRuntimeDeps) => Promise<Abi>;
+export declare const isPopularContract: (name: string, popularNames: Set<string>) => boolean;

package/dist/editor/utils/smart-contract/signature-utils.d.ts

@@ -0,0 +1,9 @@
+export declare function parseFunctionSignature(signature: string): {
+    name: string;
+    args: string;
+} | null;
+export declare function getFunctionWithArguments(functions: {
+    functionName: string;
+}[]): {
+    functionName: string;
+} | null;

package/dist/editor/utils/spreadsheet-import.d.ts

@@ -0,0 +1,12 @@
+export type SpreadsheetImportFileType = 'xlsx' | 'csv';
+export type ImportSpreadsheetFileOptions = {
+    type: SpreadsheetImportFileType;
+    separator?: 'auto' | 'tab' | 'comma' | string;
+    dsheetId: string;
+};
+export type ImportSpreadsheetFileResult = {
+    encodedContent: string;
+    title?: string;
+    warnings?: string[];
+};
+export declare function importSpreadsheetFile(file: File, options: ImportSpreadsheetFileOptions): Promise<ImportSpreadsheetFileResult>;