seismic-viem 1.0.0

package/dist/_types/actions/public.d.ts

@@ -0,0 +1,9 @@
+import type { Account, BlockTag, Chain, GetStorageAtParameters, GetStorageAtReturnType, GetTransactionParameters, GetTransactionReturnType, Hex, RpcSchema, Transport } from 'viem';
+import type { ShieldedPublicClient } from '../client';
+export type ShieldedPublicActions<TChain extends Chain | undefined = Chain | undefined> = {
+    getTeePublicKey: () => Promise<Hex | string>;
+    getStorageAt: (args: GetStorageAtParameters) => Promise<GetStorageAtReturnType>;
+    getTransaction: (args: GetTransactionParameters) => Promise<GetTransactionReturnType<TChain, BlockTag>>;
+};
+export declare const shieldedPublicActions: <TTransport extends Transport, TChain extends Chain | undefined = Chain | undefined, TAccount extends Account | undefined = Account | undefined, TRpcSchema extends RpcSchema | undefined = undefined>(client: ShieldedPublicClient<TTransport, TChain, TAccount, TRpcSchema>) => ShieldedPublicActions<TChain>;
+//# sourceMappingURL=public.d.ts.map

package/dist/_types/actions/wallet.d.ts

@@ -0,0 +1,15 @@
+import type { Account, Chain, Hex, Transport } from 'viem';
+import { ShieldedWalletClient } from '../client';
+import type { SignedReadContract } from '../contract/read';
+import type { SeismicWriteContract } from '../contract/write';
+import type { SendSeismicTransactionParameters, SendSeismicTransactionRequest, SendSeismicTransactionReturnType } from '../sendTransaction.js';
+import type { SignedCall } from '../signedCall';
+export type ShieldedWalletActions<TChain extends Chain | undefined = Chain | undefined, TAccount extends Account | undefined = Account | undefined> = {
+    writeContract: SeismicWriteContract<TChain, TAccount>;
+    readContract: SignedReadContract;
+    signedCall: SignedCall<TChain>;
+    sendShieldedTransaction: <const request extends SendSeismicTransactionRequest<TChain, TChainOverride>, TChainOverride extends Chain | undefined = undefined>(args: SendSeismicTransactionParameters<TChain, TAccount, TChainOverride, request>) => Promise<SendSeismicTransactionReturnType>;
+    getEncryption: () => Hex;
+};
+export declare const shieldedWalletActions: <TTransport extends Transport, TChain extends Chain | undefined = Chain | undefined, TAccount extends Account | undefined = Account | undefined>(client: ShieldedWalletClient<TTransport, TChain, TAccount>, encryption: Hex) => ShieldedWalletActions<TChain, TAccount>;
+//# sourceMappingURL=wallet.d.ts.map

package/dist/_types/chain.d.ts

@@ -0,0 +1,47 @@
+import type { Hex, Signature, TransactionSerializable } from 'viem';
+export declare const serializeSeismicTransaction: (transaction: TransactionSerializable & {
+    seismicInput?: Hex | undefined;
+}, signature?: Signature) => `0x${string}`;
+export declare const seismicDevnet: {
+    blockExplorers?: {
+        [key: string]: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+        default: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+    } | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        universalSignatureVerifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    id: 1337;
+    name: "Seismic";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["http://127.0.0.1:8545"];
+            readonly webSocket: readonly ["ws://127.0.0.1:8545"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, TransactionSerializable> | undefined;
+};
+//# sourceMappingURL=chain.d.ts.map

package/dist/_types/client.d.ts

@@ -0,0 +1,23 @@
+import type { Account, Chain, Client, Hex, Prettify, PublicActions, PublicRpcSchema, RpcSchema, Transport, WalletActions } from 'viem';
+import type { PublicClientConfig } from 'viem';
+import type { ShieldedPublicActions } from './actions/public';
+import type { ShieldedWalletActions } from './actions/wallet';
+export type ShieldedPublicClient<transport extends Transport = Transport, chain extends Chain | undefined = Chain | undefined, accountOrAddress extends Account | undefined = undefined, rpcSchema extends RpcSchema | undefined = undefined> = Prettify<Client<transport, chain, accountOrAddress, rpcSchema extends RpcSchema ? [...PublicRpcSchema, ...rpcSchema] : PublicRpcSchema, PublicActions<transport, chain> & ShieldedPublicActions<chain>>>;
+export type ShieldedWalletClient<transport extends Transport = Transport, chain extends Chain | undefined = Chain | undefined, account extends Account | undefined = Account | undefined> = Client<transport, chain, account, RpcSchema, PublicActions<transport, chain, account> & WalletActions<chain, account> & ShieldedWalletActions<chain, account>>;
+type SeismicClients<transport extends Transport, chain extends Chain | undefined, account extends Account | undefined> = {
+    public: ShieldedPublicClient<transport, chain, undefined>;
+    wallet: ShieldedWalletClient<transport, chain, account>;
+    encryption: Hex;
+};
+type GetPublicClientParameters = {
+    chain: Chain;
+    transport: Transport;
+};
+type GetSeismicClientsParameters = GetPublicClientParameters & {
+    privateKey: Hex;
+};
+export declare function createShieldedPublicClient<transport extends Transport, chain extends Chain | undefined = undefined, rpcSchema extends RpcSchema | undefined = undefined>(parameters: PublicClientConfig<transport, chain, undefined, rpcSchema>): ShieldedPublicClient<transport, chain, undefined, rpcSchema>;
+export declare const createShieldedWalletClient: ({ chain, transport, privateKey, }: GetSeismicClientsParameters) => Promise<ShieldedWalletClient<Transport, Chain, Account>>;
+export declare const getSeismicAnvilClients: (privateKey: Hex) => Promise<SeismicClients<Transport, Chain, Account>>;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/_types/contract/abi.d.ts

@@ -0,0 +1,5 @@
+import { type AbiFunction } from 'viem';
+export declare const remapSeismicAbiInputs: (abiFunction: AbiFunction) => AbiFunction;
+export declare const hasShieldedInputs: (abiFunction: AbiFunction) => boolean;
+export declare function getProcessedArgs<abiItem extends AbiFunction, args extends readonly unknown[] | undefined>(abiItem: abiItem, args: args): any[];
+//# sourceMappingURL=abi.d.ts.map

package/dist/_types/contract/contract.d.ts

@@ -0,0 +1,15 @@
+import type { ExtractAbiFunctionNames } from 'abitype';
+import type { Abi, Account, Address, Chain, Client, ContractFunctionName, GetContractParameters, GetContractReturnType, IsNarrowable, IsNever, Transport } from 'viem';
+import type { ShieldedWalletClient } from '../client';
+import type { KeyedClient } from '../viem-internal/client';
+import type { GetReadFunction } from '../viem-internal/function';
+type SignedReadContractReturnType<TAbi extends Abi | readonly unknown[], TClient extends Client | KeyedClient = Client | KeyedClient, _readFunctionNames extends string = TAbi extends Abi ? Abi extends TAbi ? string : ExtractAbiFunctionNames<TAbi, 'pure' | 'view'> : string, _narrowable extends boolean = IsNarrowable<TAbi, Abi>, _walletClient extends Client | unknown = TClient extends {
+    wallet: Client;
+} ? TClient['wallet'] : TClient> = _walletClient extends Client ? IsNever<_readFunctionNames> extends true ? unknown : {
+    sread: {
+        [functionName in _readFunctionNames]: GetReadFunction<_narrowable, TAbi, functionName extends ContractFunctionName<TAbi, 'pure' | 'view'> ? functionName : never>;
+    };
+} : unknown;
+export declare function getShieldedContract<TTransport extends Transport, TAddress extends Address, const TAbi extends Abi | readonly unknown[], const TClient extends ShieldedWalletClient<TTransport, TChain, TAccount> | KeyedClient<TTransport, TChain, TAccount>, TChain extends Chain | undefined = Chain | undefined, TAccount extends Account | undefined = Account | undefined>({ abi, address, client, }: GetContractParameters<TTransport, TChain, TAccount, TAbi, TClient, TAddress>): GetContractReturnType<TAbi, TClient, TAddress> & SignedReadContractReturnType<TAbi, TClient>;
+export {};
+//# sourceMappingURL=contract.d.ts.map

package/dist/_types/contract/read.d.ts

@@ -0,0 +1,4 @@
+import type { Abi, Account, Chain, Client, ContractFunctionArgs, ContractFunctionName, ReadContractParameters, ReadContractReturnType, Transport } from 'viem';
+export declare function signedReadContract<TChain extends Chain | undefined, TAccount extends Account | undefined, const TAbi extends Abi | readonly unknown[], TFunctionName extends ContractFunctionName<TAbi, 'nonpayable' | 'payable'>, TArgs extends ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', TFunctionName>>(client: Client<Transport, TChain, TAccount>, parameters: ReadContractParameters<TAbi, TFunctionName, TArgs>): Promise<ReadContractReturnType>;
+export type SignedReadContract<TAbi extends Abi | readonly unknown[] = Abi | readonly unknown[], TFunctionName extends ContractFunctionName<TAbi, 'nonpayable' | 'payable'> = ContractFunctionName<TAbi, 'nonpayable' | 'payable'>, TArgs extends ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', TFunctionName> = ContractFunctionArgs<TAbi, 'payable' | 'nonpayable', TFunctionName>> = (args: ReadContractParameters<TAbi, TFunctionName, TArgs>) => Promise<ReadContractReturnType>;
+//# sourceMappingURL=read.d.ts.map

package/dist/_types/contract/write.d.ts

@@ -0,0 +1,61 @@
+import type { Abi, AbiItemName, Account, Chain, ContractFunctionArgs, ContractFunctionName, GetAbiItemParameters, Transport, WriteContractParameters, WriteContractReturnType } from 'viem';
+import type { ShieldedWalletClient } from '../client';
+/**
+  Determine whether the contract has shielded parameters.
+  If so, we will encrypt the entire payload;
+  If not, we will send a normal Ethereum transaction
+  */
+export declare function useSeismicWrite<const abi extends Abi | readonly unknown[], name extends AbiItemName<abi>>(parameters: GetAbiItemParameters<abi, name, undefined>): boolean;
+/**
+ * Executes a write function on a contract.
+ *
+ * - Docs: https://viem.sh/docs/contract/writeContract
+ * - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts/writing-to-contracts
+ *
+ * A "write" function on a Solidity contract modifies the state of the blockchain. These types of functions require gas to be executed, and hence a [Transaction](https://viem.sh/docs/glossary/terms) is needed to be broadcast in order to change the state.
+ *
+ * Internally, uses a [Wallet Client](https://viem.sh/docs/clients/wallet) to call the [`sendTransaction` action](https://viem.sh/docs/actions/wallet/sendTransaction) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData).
+ *
+ * __Warning: The `write` internally sends a transaction – it does not validate if the contract write will succeed (the contract may throw an error). It is highly recommended to [simulate the contract write with `contract.simulate`](https://viem.sh/docs/contract/writeContract#usage) before you execute it.__
+ *
+ * @param client - Client to use
+ * @param parameters - {@link WriteContractParameters}
+ * @returns A [Transaction Hash](https://viem.sh/docs/glossary/terms#hash). {@link WriteContractReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom, parseAbi } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { writeContract } from 'viem/contract'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const hash = await writeContract(client, {
+ *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+ *   abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
+ *   functionName: 'mint',
+ *   args: [69420],
+ * })
+ *
+ * @example
+ * // With Validation
+ * import { createWalletClient, http, parseAbi } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { simulateContract, writeContract } from 'viem/contract'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const { request } = await simulateContract(client, {
+ *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+ *   abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
+ *   functionName: 'mint',
+ *   args: [69420],
+ * }
+ * const hash = await writeContract(client, request)
+ */
+export declare function shieldedWriteContract<TTransport extends Transport, TChain extends Chain | undefined, TAccount extends Account | undefined, const TAbi extends Abi | readonly unknown[], TFunctionName extends ContractFunctionName<TAbi, 'nonpayable' | 'payable'>, TArgs extends ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', TFunctionName>, chainOverride extends Chain | undefined = undefined>(client: ShieldedWalletClient<TTransport, TChain, TAccount>, parameters: WriteContractParameters<TAbi, TFunctionName, TArgs, TChain, TAccount, chainOverride>): Promise<WriteContractReturnType>;
+export type SeismicWriteContract<TChain extends Chain | undefined, TAccount extends Account | undefined, abi extends Abi | readonly unknown[] = Abi | readonly unknown[], functionName extends ContractFunctionName<abi, 'payable' | 'nonpayable'> = ContractFunctionName<abi, 'payable' | 'nonpayable'>, args extends ContractFunctionArgs<abi, 'payable' | 'nonpayable', functionName> = ContractFunctionArgs<abi, 'payable' | 'nonpayable', functionName>, TChainOverride extends Chain | undefined = undefined> = (args: WriteContractParameters<abi, functionName, args, TChain, TAccount, TChainOverride>) => Promise<WriteContractReturnType>;
+//# sourceMappingURL=write.d.ts.map

package/dist/_types/crypto/aes.d.ts

@@ -0,0 +1,45 @@
+import type { Hex } from 'viem';
+export declare class AesGcmCrypto {
+    private readonly key;
+    private readonly ALGORITHM;
+    private readonly TAG_LENGTH;
+    private readonly NONCE_LENGTH;
+    private readonly U64_SIZE;
+    constructor(key: Hex);
+    /**
+     * Creates a nonce from a u64 number, matching Rust's implementation
+     * @param num - The number to convert (will be treated as u64)
+     */
+    private numberToNonce;
+    /**
+     * RLP encodes the input data
+     * @param data - The hex data to encode
+     */
+    private rlpEncodeInput;
+    /**
+     * Validates and converts a hex nonce to buffer
+     * @param nonce - The nonce in hex format
+     */
+    private validateAndConvertNonce;
+    /**
+     * Creates a nonce from a number in a way compatible with the Rust backend
+     */
+    createNonce(num: number | bigint): Hex;
+    /**
+     * Encrypts data using either a number-based nonce or hex nonce
+     */
+    encrypt(plaintext: Hex, nonce: number | bigint | Hex): {
+        ciphertext: Hex;
+    };
+    /**
+     * Decrypts data using either a number-based nonce or hex nonce
+     */
+    decrypt(ciphertext: Hex, nonce: number | bigint | Hex): Hex;
+}
+type AesInputKeys = {
+    privateKey: Hex;
+    networkPublicKey: string;
+};
+export declare const generateAesKey: (aesKeys: AesInputKeys) => Hex;
+export {};
+//# sourceMappingURL=aes.d.ts.map

package/dist/_types/error/account.d.ts

@@ -0,0 +1,20 @@
+import { BaseError } from 'viem';
+export type AccountNotFoundErrorType = AccountNotFoundError & {
+    name: 'AccountNotFoundError';
+};
+export declare class AccountNotFoundError extends BaseError {
+    constructor({ docsPath }?: {
+        docsPath?: string | undefined;
+    });
+}
+export type AccountTypeNotSupportedErrorType = AccountTypeNotSupportedError & {
+    name: 'AccountTypeNotSupportedError';
+};
+export declare class AccountTypeNotSupportedError extends BaseError {
+    constructor({ docsPath, metaMessages, type, }: {
+        docsPath?: string | undefined;
+        metaMessages?: string[] | undefined;
+        type: string;
+    });
+}
+//# sourceMappingURL=account.d.ts.map

package/dist/_types/index.d.ts

@@ -0,0 +1,9 @@
+export { seismicDevnet } from './chain';
+export { signedCall } from './signedCall';
+export { sendShieldedTransaction } from './sendTransaction';
+export { getShieldedContract } from './contract/contract';
+export { signedReadContract } from './contract/read';
+export { shieldedWriteContract } from './contract/write';
+export { createShieldedPublicClient, createShieldedWalletClient, } from './client';
+export type { ShieldedPublicClient, ShieldedWalletClient } from './client';
+//# sourceMappingURL=index.d.ts.map

package/dist/_types/sendTransaction.d.ts

@@ -0,0 +1,20 @@
+import type { Account, Address, AssertCurrentChainErrorType, Chain, Client, DeriveChain, FormattedTransactionRequest, GetChainIdErrorType, GetChainParameter, GetTransactionRequestKzgParameter, Hash, Hex, PrepareTransactionRequestErrorType, SendRawTransactionErrorType, Transport, UnionOmit } from 'viem';
+import type { ParseAccountErrorType, SignTransactionErrorType } from 'viem/accounts';
+import type { RecoverAuthorizationAddressErrorType } from 'viem/experimental';
+import type { AssertRequestErrorType, GetTransactionErrorReturnType, RequestErrorType } from 'viem/utils';
+import type { AccountNotFoundErrorType, AccountTypeNotSupportedErrorType } from './error/account';
+import type { GetAccountParameter } from './viem-internal/account';
+import type { ErrorType } from './viem-internal/error';
+export type SendSeismicTransactionRequest<chain extends Chain | undefined = Chain | undefined, chainOverride extends Chain | undefined = Chain | undefined, _derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>> = UnionOmit<FormattedTransactionRequest<_derivedChain>, 'from'> & GetTransactionRequestKzgParameter & {
+    seismicInput: Hex;
+};
+export type SendSeismicTransactionParameters<chain extends Chain | undefined = Chain | undefined, account extends Account | undefined = Account | undefined, chainOverride extends Chain | undefined = Chain | undefined, request extends SendSeismicTransactionRequest<chain, chainOverride> = SendSeismicTransactionRequest<chain, chainOverride>> = request & GetAccountParameter<account, Account | Address, true, true> & GetChainParameter<chain, chainOverride> & GetTransactionRequestKzgParameter<request>;
+export type SendSeismicTransactionReturnType = Hash;
+export type SendSeismicTransactionErrorType = ParseAccountErrorType | GetTransactionErrorReturnType<AccountNotFoundErrorType | AccountTypeNotSupportedErrorType | AssertCurrentChainErrorType | AssertRequestErrorType | GetChainIdErrorType | PrepareTransactionRequestErrorType | SendRawTransactionErrorType | RecoverAuthorizationAddressErrorType | SignTransactionErrorType | RequestErrorType> | ErrorType;
+/**
+ * Sends a Seismic transaction,
+ * taking in `seismicInput` as the (ciphered) input
+ * to the node.
+ */
+export declare function sendShieldedTransaction<TChain extends Chain | undefined, TAccount extends Account | undefined, const TRequest extends SendSeismicTransactionRequest<TChain, TChainOverride>, TChainOverride extends Chain | undefined = undefined>(client: Client<Transport, TChain, TAccount>, parameters: SendSeismicTransactionParameters<TChain, TAccount, TChainOverride, TRequest>): Promise<SendSeismicTransactionReturnType>;
+//# sourceMappingURL=sendTransaction.d.ts.map

package/dist/_types/signedCall.d.ts

@@ -0,0 +1,7 @@
+import type { CallParameters, CallReturnType, Chain, Client, Hex, Transport } from 'viem';
+export type SignedCallParameters<chain extends Chain | undefined> = CallParameters<chain> & {
+    seismicInput?: Hex | undefined;
+};
+export type SignedCall<chain extends Chain | undefined> = (args: SignedCallParameters<chain>) => Promise<CallReturnType>;
+export declare function signedCall<chain extends Chain | undefined>(client: Client<Transport, chain>, args: SignedCallParameters<chain>): Promise<CallReturnType>;
+//# sourceMappingURL=signedCall.d.ts.map

package/dist/_types/viem-internal/account.d.ts

@@ -0,0 +1,5 @@
+import type { Account, Address, IsUndefined, MaybeRequired } from 'viem';
+export type GetAccountParameter<account extends Account | undefined = Account | undefined, accountOverride extends Account | Address | undefined = Account | Address, required extends boolean = true, nullish extends boolean = false> = MaybeRequired<{
+    account?: accountOverride | Account | Address | (nullish extends true ? null : never) | undefined;
+}, IsUndefined<account> extends true ? required extends true ? true : false : false>;
+//# sourceMappingURL=account.d.ts.map

package/dist/_types/viem-internal/call.d.ts

@@ -0,0 +1,64 @@
+import type { AccountStateConflictErrorType, Address, CallParameters, Chain, Client, Hex, InvalidAddressErrorType, NumberToHexErrorType, RpcStateOverride, StateAssignmentConflictErrorType, StateOverride, TransactionRequest, Transport } from 'viem';
+import { BaseError } from 'viem';
+export declare function shouldPerformMulticall({ request, }: {
+    request: TransactionRequest;
+}): boolean;
+type InvalidBytesLengthErrorType = InvalidBytesLengthError & {
+    name: 'InvalidBytesLengthError';
+};
+declare class InvalidBytesLengthError extends BaseError {
+    constructor({ size, targetSize, type, }: {
+        size: number;
+        targetSize: number;
+        type: 'hex' | 'bytes';
+    });
+}
+type SerializeStateOverrideParameters = StateOverride | undefined;
+type SerializeStateMappingErrorType = InvalidBytesLengthErrorType;
+type SerializeAccountStateOverrideErrorType = NumberToHexErrorType | StateAssignmentConflictErrorType | SerializeStateMappingErrorType;
+export type SerializeStateOverrideErrorType = InvalidAddressErrorType | AccountStateConflictErrorType | SerializeAccountStateOverrideErrorType;
+export declare function serializeStateOverride(parameters?: SerializeStateOverrideParameters): RpcStateOverride | undefined;
+export type ScheduleMulticallParameters<chain extends Chain | undefined> = Pick<CallParameters<chain>, 'blockNumber' | 'blockTag'> & {
+    data: Hex;
+    multicallAddress?: Address | undefined;
+    to: Address;
+};
+export declare function scheduleMulticall<chain extends Chain | undefined>(client: Client<Transport>, args: ScheduleMulticallParameters<chain>): Promise<{
+    data: undefined;
+} | {
+    data: `0x${string}`;
+}>;
+export type ErrorType<name extends string = 'Error'> = Error & {
+    name: name;
+};
+export declare function toDeploylessCallViaBytecodeData(parameters: {
+    code: Hex;
+    data: Hex;
+}): `0x${string}`;
+export declare function toDeploylessCallViaFactoryData(parameters: {
+    data: Hex;
+    factory: Address;
+    factoryData: Hex;
+    to: Address;
+}): `0x${string}`;
+export declare function getRevertErrorData(err: unknown): `0x${string}` | undefined;
+type Resolved<returnType extends readonly unknown[] = any> = [
+    result: returnType[number],
+    results: returnType
+];
+type BatchResultsCompareFn<result = unknown> = (a: result, b: result) => number;
+type CreateBatchSchedulerArguments<parameters = unknown, returnType extends readonly unknown[] = readonly unknown[]> = {
+    fn: (args: parameters[]) => Promise<returnType>;
+    id: number | string;
+    shouldSplitBatch?: ((args: parameters[]) => boolean) | undefined;
+    wait?: number | undefined;
+    sort?: BatchResultsCompareFn<returnType[number]> | undefined;
+};
+type CreateBatchSchedulerReturnType<parameters = unknown, returnType extends readonly unknown[] = readonly unknown[]> = {
+    flush: () => void;
+    schedule: parameters extends undefined ? (args?: parameters | undefined) => Promise<Resolved<returnType>> : (args: parameters) => Promise<Resolved<returnType>>;
+};
+export declare function withResolvers<type>(): PromiseWithResolvers<type>;
+export declare function createBatchScheduler<parameters, returnType extends readonly unknown[]>({ fn, id, shouldSplitBatch, wait, sort, }: CreateBatchSchedulerArguments<parameters, returnType>): CreateBatchSchedulerReturnType<parameters, returnType>;
+export {};
+//# sourceMappingURL=call.d.ts.map

package/dist/_types/viem-internal/client.d.ts

@@ -0,0 +1,9 @@
+import type { Account, Chain, Client, Transport } from 'viem';
+export type KeyedClient<transport extends Transport = Transport, chain extends Chain | undefined = Chain | undefined, account extends Account | undefined = Account | undefined> = {
+    public?: Client<transport, chain> | undefined;
+    wallet: Client<transport, chain, account>;
+} | {
+    public: Client<transport, chain>;
+    wallet?: Client<transport, chain, account> | undefined;
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/_types/viem-internal/error.d.ts

@@ -0,0 +1,4 @@
+export type ErrorType<name extends string = 'Error'> = Error & {
+    name: name;
+};
+//# sourceMappingURL=error.d.ts.map

package/dist/_types/viem-internal/function.d.ts

@@ -0,0 +1,8 @@
+import type { AbiParametersToPrimitiveTypes, ExtractAbiFunction } from 'abitype';
+import type { Abi, AbiFunction, ContractFunctionArgs, ContractFunctionName, Prettify, ReadContractParameters, ReadContractReturnType, UnionOmit } from 'viem';
+export declare function getFunctionParameters(values: [args?: readonly unknown[] | undefined, options?: object | undefined]): {
+    args: readonly unknown[];
+    options: object;
+};
+export type GetReadFunction<narrowable extends boolean, abi extends Abi | readonly unknown[], functionName extends ContractFunctionName<abi, 'pure' | 'view'>, args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName> = ContractFunctionArgs<abi, 'pure' | 'view', functionName>, abiFunction extends AbiFunction = abi extends Abi ? ExtractAbiFunction<abi, functionName> : AbiFunction, _args = AbiParametersToPrimitiveTypes<abiFunction['inputs']>, _options = Prettify<UnionOmit<ReadContractParameters<abi, functionName, args>, 'abi' | 'address' | 'args' | 'functionName'>>> = narrowable extends true ? (...parameters: _args extends readonly [] ? [options?: _options] : [args: _args, options?: _options]) => Promise<ReadContractReturnType<abi, functionName, args>> : (...parameters: [options?: _options] | [args: readonly unknown[], options?: _options]) => Promise<ReadContractReturnType>;
+//# sourceMappingURL=function.d.ts.map

package/dist/_types/viem-internal/request.d.ts

@@ -0,0 +1,3 @@
+import { Chain, ExactPartial, SendTransactionParameters } from 'viem';
+export type AssertRequestParameters = ExactPartial<SendTransactionParameters<Chain>>;
+//# sourceMappingURL=request.d.ts.map

package/dist/_types/viem-internal/signature.d.ts

@@ -0,0 +1,3 @@
+import type { Signature, TransactionSerializableGeneric } from 'viem';
+export declare function toYParitySignatureArray(transaction: TransactionSerializableGeneric, signature_?: Signature | undefined): `0x${string}`[];
+//# sourceMappingURL=signature.d.ts.map

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "seismic-viem",
+  "version": "1.0.0",
+  "description": "Typescript interface for Seismic",
+  "type": "module",
+  "main": "dist/_cjs/index.js",
+  "module": "dist/_esm/index.ts",
+  "types": "dist/_types/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/_cjs/index.js",
+      "import": "./dist/_esm/index.js",
+      "types": "./dist/_types/index.d.ts"
+    }
+  },
+  "files": [
+    "dist/_cjs/*.js",
+    "dist/_esm/*.js",
+    "dist/_types/**/*.d.ts",
+    "README.md"
+  ],
+  "scripts": {
+    "clean": "rimraf dist",
+    "typecheck": "tsc --noEmit; rm tsconfig.tsbuildinfo",
+    "build": "bun build:cjs && bun build:esm && bun build:types",
+    "build:cjs": "bun build src/index.ts --outdir dist/_cjs --target node --format cjs",
+    "build:esm": "bun build src/index.ts --outdir dist/_esm --target browser --format esm",
+    "build:types": "tsc --project tsconfig.types.json && tsc-alias --project tsconfig.types.json",
+    "postbuild": "rimraf ./dist/tsconfig.types.tsbuildinfo"
+  },
+  "dependencies": {
+    "viem": "^2.21.50"
+  },
+  "devDependencies": {
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-no-relative-import-paths": "^1.5.5"
+  },
+  "license": "MIT",
+  "author": "Seismic Systems",
+  "homepage": "https://seismic.systems",
+  "repository": "https://github.com/SeismicSystems/seismic-client",
+  "keywords": [
+    "seismic",
+    "crypto",
+    "shielding",
+    "eth",
+    "ethereum",
+    "dapps",
+    "wallet",
+    "web3",
+    "typescript"
+  ]
+}