ox/dist/tempo/TransactionRequest.d.ts

Ethereum Standard Library

import type * as Address from '../core/Address.js';
import type * as Errors from '../core/Errors.js';
import * as Hex from '../core/Hex.js';
import type { Compute } from '../core/internal/types.js';
import * as Signature from '../core/Signature.js';
import * as ox_TransactionRequest from '../core/TransactionRequest.js';
import * as AuthorizationTempo from './AuthorizationTempo.js';
import * as KeyAuthorization from './KeyAuthorization.js';
import type * as MultisigConfig from './MultisigConfig.js';
import * as SignatureEnvelope from './SignatureEnvelope.js';
import * as TxEnvelopeTempo from './TxEnvelopeTempo.js';
import type { Call } from './TxEnvelopeTempo.js';
type KeyType = 'secp256k1' | 'p256' | 'webAuthn';
/**
 * Bootstrap multisig config hint for node-side gas modeling (TIP-1061).
 * The node prices multisig gas from it during simulation, and ignores it
 * for registered senders.
 */
export type MultisigInit = Compute<MultisigConfig.Config & {
    salt: Hex.Hex;
}>;
/**
 * A Transaction Request that is generic to all transaction types.
 *
 * Extends the [Execution API specification](https://github.com/ethereum/execution-apis/blob/4aca1d7a3e5aab24c8f6437131289ad386944eaa/src/schemas/transaction.yaml#L358-L423)
 * with Tempo-specific fields for batched calls, fee tokens, access keys, and scheduled execution.
 *
 * @see {@link https://docs.tempo.xyz/protocol/transactions}
 */
export type TransactionRequest<bigintType = bigint, numberType = number, type extends string = string> = Compute<Omit<ox_TransactionRequest.TransactionRequest<bigintType, numberType, type>, 'authorizationList'> & {
    authorizationList?: AuthorizationTempo.ListSigned<bigintType, numberType> | undefined;
    calls?: readonly Call<bigintType>[] | undefined;
    capabilities?: Record<string, unknown> | undefined;
    feePayerSignature?: Signature.Signature<true, numberType> | null | undefined;
    keyAuthorization?: KeyAuthorization.KeyAuthorization<true> | undefined;
    keyData?: Hex.Hex | undefined;
    keyId?: Address.Address | undefined;
    keyType?: KeyType | undefined;
    feePayer?: boolean | undefined;
    feeToken?: Address.Address | undefined;
    multisigInit?: MultisigInit | undefined;
    multisigSignatureCount?: number | undefined;
    nonceKey?: 'random' | bigintType | undefined;
    signature?: SignatureEnvelope.SignatureEnvelope<numberType> | undefined;
    validBefore?: numberType | undefined;
    validAfter?: numberType | undefined;
}>;
/** RPC representation of a {@link ox#TransactionRequest.TransactionRequest}. */
export type Rpc = Omit<TransactionRequest<Hex.Hex, Hex.Hex, string>, 'authorizationList' | 'feePayerSignature' | 'feeToken' | 'keyAuthorization' | 'signature'> & {
    authorizationList?: AuthorizationTempo.ListRpc | undefined;
    feePayerSignature?: Signature.Rpc | null | undefined;
    feeToken?: Hex.Hex | undefined;
    keyAuthorization?: KeyAuthorization.Rpc | undefined;
    nonceKey?: Hex.Hex | undefined;
    signature?: SignatureEnvelope.SignatureEnvelopeRpc | undefined;
};
/**
 * Converts a {@link ox#TransactionRequest.Rpc} to a {@link ox#TransactionRequest.TransactionRequest}.
 *
 * @example
 * ```ts twoslash
 * import { TransactionRequest } from 'ox/tempo'
 *
 * const request = TransactionRequest.fromRpc({
 *   calls: [
 *     {
 *       data: '0xdeadbeef',
 *       to: '0xcafebabecafebabecafebabecafebabecafebabe'
 *     }
 *   ],
 *   feeToken: '0x20c0000000000000000000000000000000000000',
 *   type: '0x76'
 * })
 * ```
 *
 * @param request - The RPC request to convert.
 * @returns A transaction request.
 */
export declare function fromRpc(request: Rpc): TransactionRequest;
export declare namespace fromRpc {
    type ErrorType = AuthorizationTempo.fromRpcList.ErrorType | Hex.toNumber.ErrorType | Hex.toBigInt.ErrorType | Errors.GlobalErrorType;
}
/**
 * Converts a {@link ox#TransactionRequest.TransactionRequest} to a {@link ox#TransactionRequest.Rpc}.
 *
 * @see {@link https://docs.tempo.xyz/protocol/transactions}
 *
 * @example
 * ```ts twoslash
 * import { Value } from 'ox'
 * import { TransactionRequest } from 'ox/tempo'
 *
 * const request = TransactionRequest.toRpc({
 *   calls: [
 *     {
 *       data: '0xdeadbeef',
 *       to: '0xcafebabecafebabecafebabecafebabecafebabe'
 *     }
 *   ],
 *   feeToken: '0x20c0000000000000000000000000000000000000'
 * })
 * ```
 *
 * @example
 * ### Using with a Provider
 *
 * You can use {@link ox#Provider.(from:function)} to instantiate an EIP-1193 Provider and
 * send a transaction to the Wallet using the `eth_sendTransaction` method.
 *
 * ```ts twoslash
 * // @noErrors
 * import 'ox/window'
 * import { Provider, Value } from 'ox'
 * import { TransactionRequest } from 'ox/tempo'
 *
 * const provider = Provider.from(window.ethereum!)
 *
 * const request = TransactionRequest.toRpc({
 *   calls: [
 *     {
 *       data: '0xdeadbeef',
 *       to: '0xcafebabecafebabecafebabecafebabecafebabe'
 *     }
 *   ],
 *   feeToken: '0x20c0000000000000000000000000000000000000'
 * })
 *
 * const hash = await provider.request({
 *   // [!code focus]
 *   method: 'eth_sendTransaction', // [!code focus]
 *   params: [request] // [!code focus]
 * }) // [!code focus]
 * ```
 *
 * @param request - The request to convert.
 * @returns An RPC request.
 */
export declare function toRpc(request: toRpc.Input): Rpc;
export declare namespace toRpc {
    /** Numberish input accepted by {@link ox#TransactionRequest.(toRpc:function)}. */
    type Input = TransactionRequest<Hex.Hex | bigint | number, Hex.Hex | number>;
    type ErrorType = AuthorizationTempo.toRpcList.ErrorType | Hex.fromNumber.ErrorType | Errors.GlobalErrorType;
}
/**
 * Converts a Tempo {@link ox#TransactionRequest.TransactionRequest} to a {@link ox#TxEnvelopeTempo.TxEnvelopeTempo}.
 *
 * @example
 * ```ts twoslash
 * import { TransactionRequest } from 'ox/tempo'
 *
 * const envelope = TransactionRequest.toEnvelope({
 *   calls: [
 *     {
 *       data: '0xdeadbeef',
 *       to: '0xcafebabecafebabecafebabecafebabecafebabe'
 *     }
 *   ],
 *   chainId: 1,
 *   feeToken: '0x20c0000000000000000000000000000000000000',
 *   maxFeePerGas: 1n
 * })
 * ```
 *
 * @param request - The transaction request to convert.
 * @param options - Options.
 * @returns A Tempo transaction envelope.
 */
export declare function toEnvelope(request: TransactionRequest, options?: toEnvelope.Options): TxEnvelopeTempo.TxEnvelopeTempo;
export declare namespace toEnvelope {
    type Options = {
        /** Optional fee-payer signature to attach to the envelope. */
        feePayerSignature?: Signature.Signature | null | undefined;
        /** Optional signature envelope to attach. */
        signature?: SignatureEnvelope.from.Value | undefined;
    };
    type ErrorType = TxEnvelopeTempo.from.ErrorType | Hex.random.ErrorType | Hex.toBigInt.ErrorType | Errors.GlobalErrorType;
}
export {};
//# sourceMappingURL=TransactionRequest.d.ts.map