tempo.ts 0.0.0 → 0.0.1

package/dist/ox/TransactionEnvelopeFeeToken.js

@@ -0,0 +1,452 @@
+import * as AccessList from 'ox/AccessList';
+import * as Address from 'ox/Address';
+import * as Authorization from 'ox/Authorization';
+import * as Hash from 'ox/Hash';
+import * as Hex from 'ox/Hex';
+import * as Rlp from 'ox/Rlp';
+import * as Signature from 'ox/Signature';
+import * as TransactionEnvelope from 'ox/TransactionEnvelope';
+import * as TransactionEnvelopeEip1559 from 'ox/TransactionEnvelopeEip1559';
+import * as TokenId from "./TokenId.js";
+export const feePayerMagic = '0x78';
+export const serializedType = '0x77';
+export const type = 'feeToken';
+/**
+ * Asserts a {@link ox#TransactionEnvelopeFeeToken.TransactionEnvelopeFeeToken} is valid.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Value } from 'ox'
+ * import { TransactionEnvelopeFeeToken } from 'ox/tempo'
+ *
+ * TransactionEnvelopeFeeToken.assert({
+ *   feeToken: '0x20c0000000000000000000000000000000000000',
+ *   maxFeePerGas: 2n ** 256n - 1n + 1n,
+ *   chainId: 1,
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1'),
+ * })
+ * // @error: FeeCapTooHighError:
+ * // @error: The fee cap (`masFeePerGas` = 115792089237316195423570985008687907853269984665640564039457584007913 gwei) cannot be
+ * // @error: higher than the maximum allowed value (2^256-1).
+ * ```
+ *
+ * @param envelope - The transaction envelope to assert.
+ */
+export function assert(envelope) {
+    const { authorizationList } = envelope;
+    if (authorizationList) {
+        for (const authorization of authorizationList) {
+            const { address, chainId } = authorization;
+            if (address)
+                Address.assert(address, { strict: false });
+            if (Number(chainId) < 0)
+                throw new TransactionEnvelope.InvalidChainIdError({ chainId });
+        }
+    }
+    TransactionEnvelopeEip1559.assert(envelope);
+}
+/**
+ * Deserializes a {@link ox#TransactionEnvelopeFeeToken.TransactionEnvelopeFeeToken} from its serialized form.
+ *
+ * @example
+ * ```ts twoslash
+ * import { TransactionEnvelopeFeeToken } from 'ox/tempo'
+ *
+ * const envelope = TransactionEnvelopeFeeToken.deserialize('0x77ef0182031184773594008477359400809470997970c51812dc3a010c7d01b50e0d17dc79c8880de0b6b3a764000080c0')
+ * // @log: {
+ * // @log:   type: 'feeToken',
+ * // @log:   nonce: 785n,
+ * // @log:   maxFeePerGas: 2000000000n,
+ * // @log:   gas: 1000000n,
+ * // @log:   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ * // @log:   value: 1000000000000000000n,
+ * // @log: }
+ * ```
+ *
+ * @param serialized - The serialized transaction.
+ * @returns Deserialized Transaction Envelope.
+ */
+export function deserialize(serialized) {
+    const transactionArray = Rlp.toHex(Hex.slice(serialized, 1));
+    const [chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gas, to, value, data, accessList, authorizationList, feeToken, feePayerSignatureOrSender, yParity, r, s,] = transactionArray;
+    if (!(transactionArray.length === 12 || transactionArray.length === 15))
+        throw new TransactionEnvelope.InvalidSerializedError({
+            attributes: {
+                chainId,
+                nonce,
+                feeToken,
+                maxPriorityFeePerGas,
+                maxFeePerGas,
+                gas,
+                to,
+                value,
+                data,
+                accessList,
+                authorizationList,
+                feePayerSignatureOrSender,
+                ...(transactionArray.length > 9
+                    ? {
+                        yParity,
+                        r,
+                        s,
+                    }
+                    : {}),
+            },
+            serialized,
+            type,
+        });
+    let transaction = {
+        chainId: Number(chainId),
+        type,
+    };
+    if (Hex.validate(to) && to !== '0x')
+        transaction.to = to;
+    if (Hex.validate(feeToken) && feeToken !== '0x')
+        transaction.feeToken = feeToken;
+    if (Hex.validate(gas) && gas !== '0x')
+        transaction.gas = BigInt(gas);
+    if (Hex.validate(data) && data !== '0x')
+        transaction.data = data;
+    if (Hex.validate(nonce))
+        transaction.nonce = nonce === '0x' ? 0n : BigInt(nonce);
+    if (Hex.validate(value) && value !== '0x')
+        transaction.value = BigInt(value);
+    if (Hex.validate(maxFeePerGas) && maxFeePerGas !== '0x')
+        transaction.maxFeePerGas = BigInt(maxFeePerGas);
+    if (Hex.validate(maxPriorityFeePerGas) && maxPriorityFeePerGas !== '0x')
+        transaction.maxPriorityFeePerGas = BigInt(maxPriorityFeePerGas);
+    if (accessList?.length !== 0 && accessList !== '0x')
+        transaction.accessList = AccessList.fromTupleList(accessList);
+    if (authorizationList !== '0x' && (authorizationList?.length ?? 0) > 0)
+        transaction.authorizationList = Authorization.fromTupleList(authorizationList);
+    if (feePayerSignatureOrSender !== '0x' &&
+        feePayerSignatureOrSender !== undefined) {
+        if (feePayerSignatureOrSender === '0x00' ||
+            Address.validate(feePayerSignatureOrSender))
+            transaction.feePayerSignature = null;
+        else
+            transaction.feePayerSignature = Signature.fromTuple(feePayerSignatureOrSender);
+    }
+    const signature = r && s && yParity ? Signature.fromTuple([yParity, r, s]) : undefined;
+    if (signature)
+        transaction = {
+            ...transaction,
+            ...signature,
+        };
+    assert(transaction);
+    return transaction;
+}
+/**
+ * Converts an arbitrary transaction object into an Fee Token Transaction Envelope.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Value } from 'ox'
+ * import { TransactionEnvelopeFeeToken } from 'ox/tempo'
+ *
+ * const envelope = TransactionEnvelopeFeeToken.from({ // [!code focus]
+ *   chainId: 1, // [!code focus]
+ *   feeToken: '0x20c0000000000000000000000000000000000000', // [!code focus]
+ *   maxFeePerGas: Value.fromGwei('10'), // [!code focus]
+ *   maxPriorityFeePerGas: Value.fromGwei('1'), // [!code focus]
+ *   to: '0x0000000000000000000000000000000000000000', // [!code focus]
+ *   value: Value.fromEther('1'), // [!code focus]
+ * }) // [!code focus]
+ * ```
+ *
+ * @example
+ * ### Attaching Signatures
+ *
+ * It is possible to attach a `signature` to the transaction envelope.
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { Secp256k1, Value } from 'ox'
+ * import { TransactionEnvelopeFeeToken } from 'ox/tempo'
+ *
+ * const envelope = TransactionEnvelopeFeeToken.from({
+ *   chainId: 1,
+ *   feeToken: '0x20c0000000000000000000000000000000000000',
+ *   maxFeePerGas: Value.fromGwei('10'),
+ *   maxPriorityFeePerGas: Value.fromGwei('1'),
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1'),
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   payload: TransactionEnvelopeFeeToken.getSignPayload(envelope),
+ *   privateKey: '0x...',
+ * })
+ *
+ * const envelope_signed = TransactionEnvelopeFeeToken.from(envelope, { // [!code focus]
+ *   signature, // [!code focus]
+ * }) // [!code focus]
+ * // @log: {
+ * // @log:   chainId: 1,
+ * // @log:   feeToken: '0x20c0000000000000000000000000000000000000',
+ * // @log:   maxFeePerGas: 10000000000n,
+ * // @log:   maxPriorityFeePerGas: 1000000000n,
+ * // @log:   to: '0x0000000000000000000000000000000000000000',
+ * // @log:   type: 'feeToken',
+ * // @log:   value: 1000000000000000000n,
+ * // @log:   r: 125...n,
+ * // @log:   s: 642...n,
+ * // @log:   yParity: 0,
+ * // @log: }
+ * ```
+ *
+ * @example
+ * ### From Serialized
+ *
+ * It is possible to instantiate an Fee Token Transaction Envelope from a {@link ox#TransactionEnvelopeFeeToken.Serialized} value.
+ *
+ * ```ts twoslash
+ * import { TransactionEnvelopeFeeToken } from 'ox/tempo'
+ *
+ * const envelope = TransactionEnvelopeFeeToken.from('0x77f858018203118502540be4008504a817c800809470997970c51812dc3a010c7d01b50e0d17dc79c8880de0b6b3a764000080c08477359400e1a001627c687261b0e7f8638af1112efa8a77e23656f6e7945275b19e9deed80261')
+ * // @log: {
+ * // @log:   chainId: 1,
+ * // @log:   feeToken: '0x20c0000000000000000000000000000000000000',
+ * // @log:   maxFeePerGas: 10000000000n,
+ * // @log:   to: '0x0000000000000000000000000000000000000000',
+ * // @log:   type: 'feeToken',
+ * // @log:   value: 1000000000000000000n,
+ * // @log: }
+ * ```
+ *
+ * @param envelope - The transaction object to convert.
+ * @param options - Options.
+ * @returns An Fee Token Transaction Envelope.
+ */
+export function from(envelope, options = {}) {
+    const { feePayerSignature, signature } = options;
+    const envelope_ = (typeof envelope === 'string' ? deserialize(envelope) : envelope);
+    assert(envelope_);
+    return {
+        ...envelope_,
+        ...(signature ? Signature.from(signature) : {}),
+        ...(feePayerSignature
+            ? { feePayerSignature: Signature.from(feePayerSignature) }
+            : {}),
+        type: 'feeToken',
+    };
+}
+/**
+ * Returns the fee payer payload to sign for a {@link ox#TransactionEnvelopeFeeToken.TransactionEnvelopeFeeToken}.
+ *
+ * @example
+ * TODO
+ *
+ * @param envelope - The transaction envelope to get the fee payer sign payload for.
+ * @returns The fee payer sign payload.
+ */
+export function getFeePayerSignPayload(envelope, options) {
+    const { sender } = options;
+    const serialized = serialize({ ...envelope, r: undefined, s: undefined, yParity: undefined }, {
+        sender,
+        format: 'feePayer',
+    });
+    return Hash.keccak256(serialized);
+}
+/**
+ * Returns the payload to sign for a {@link ox#TransactionEnvelopeFeeToken.TransactionEnvelopeFeeToken}.
+ *
+ * @example
+ * The example below demonstrates how to compute the sign payload which can be used
+ * with ECDSA signing utilities like {@link ox#Secp256k1.(sign:function)}.
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { Secp256k1 } from 'ox'
+ * import { TransactionEnvelopeFeeToken } from 'ox/tempo'
+ *
+ * const envelope = TransactionEnvelopeFeeToken.from({
+ *   chainId: 1,
+ *   feeToken: '0x20c0000000000000000000000000000000000000',
+ *   nonce: 0n,
+ *   maxFeePerGas: 1000000000n,
+ *   gas: 21000n,
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ * })
+ *
+ * const payload = TransactionEnvelopeFeeToken.getSignPayload(envelope) // [!code focus]
+ * // @log: '0x...'
+ *
+ * const signature = Secp256k1.sign({ payload, privateKey: '0x...' })
+ * ```
+ *
+ * @param envelope - The transaction envelope to get the sign payload for.
+ * @returns The sign payload.
+ */
+export function getSignPayload(envelope) {
+    return hash(envelope, { presign: true });
+}
+/**
+ * Hashes a {@link ox#TransactionEnvelopeFeeToken.TransactionEnvelopeFeeToken}. This is the "transaction hash".
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Secp256k1 } from 'ox'
+ * import { TransactionEnvelopeFeeToken } from 'ox/tempo'
+ *
+ * const envelope = TransactionEnvelopeFeeToken.from({
+ *   chainId: 1,
+ *   feeToken: '0x20c0000000000000000000000000000000000000',
+ *   nonce: 0n,
+ *   maxFeePerGas: 1000000000n,
+ *   gas: 21000n,
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   payload: TransactionEnvelopeFeeToken.getSignPayload(envelope),
+ *   privateKey: '0x...'
+ * })
+ *
+ * const envelope_signed = TransactionEnvelopeFeeToken.from(envelope, { signature })
+ *
+ * const hash = TransactionEnvelopeFeeToken.hash(envelope_signed) // [!code focus]
+ * ```
+ *
+ * @param envelope - The Fee Token Transaction Envelope to hash.
+ * @param options - Options.
+ * @returns The hash of the transaction envelope.
+ */
+export function hash(envelope, options = {}) {
+    const serialized = serialize({
+        ...envelope,
+        ...(options.presign
+            ? {
+                r: undefined,
+                s: undefined,
+                yParity: undefined,
+            }
+            : {}),
+    });
+    return Hash.keccak256(serialized);
+}
+/**
+ * Serializes a {@link ox#TransactionEnvelopeFeeToken.TransactionEnvelopeFeeToken}.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Value } from 'ox'
+ * import { TransactionEnvelopeFeeToken } from 'ox/tempo'
+ *
+ * const envelope = TransactionEnvelopeFeeToken.from({
+ *   chainId: 1,
+ *   feeToken: '0x20c0000000000000000000000000000000000000',
+ *   maxFeePerGas: Value.fromGwei('10'),
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1'),
+ * })
+ *
+ * const serialized = TransactionEnvelopeFeeToken.serialize(envelope) // [!code focus]
+ * ```
+ *
+ * @example
+ * ### Attaching Signatures
+ *
+ * It is possible to attach a `signature` to the serialized Transaction Envelope.
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { Secp256k1, Value } from 'ox'
+ * import { TransactionEnvelopeFeeToken } from 'ox/tempo'
+ *
+ * const envelope = TransactionEnvelopeFeeToken.from({
+ *   chainId: 1,
+ *   feeToken: '0x20c0000000000000000000000000000000000000',
+ *   maxFeePerGas: Value.fromGwei('10'),
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1'),
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   payload: TransactionEnvelopeFeeToken.getSignPayload(envelope),
+ *   privateKey: '0x...',
+ * })
+ *
+ * const serialized = TransactionEnvelopeFeeToken.serialize(envelope, { // [!code focus]
+ *   signature, // [!code focus]
+ * }) // [!code focus]
+ *
+ * // ... send `serialized` transaction to JSON-RPC `eth_sendRawTransaction`
+ * ```
+ *
+ * @param envelope - The Transaction Envelope to serialize.
+ * @param options - Options.
+ * @returns The serialized Transaction Envelope.
+ */
+export function serialize(envelope, options = {}) {
+    const { authorizationList, chainId, feeToken, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data, input, } = envelope;
+    assert(envelope);
+    const accessTupleList = AccessList.toTupleList(accessList);
+    const authorizationTupleList = Authorization.toTupleList(authorizationList);
+    const signature = Signature.extract(options.signature || envelope);
+    const feePayerSignatureOrSender = (() => {
+        if (options.sender)
+            return options.sender;
+        const feePayerSignature = typeof options.feePayerSignature !== 'undefined'
+            ? options.feePayerSignature
+            : envelope.feePayerSignature;
+        if (feePayerSignature === null)
+            return '0x00';
+        if (!feePayerSignature)
+            return '0x';
+        return Signature.toTuple(feePayerSignature);
+    })();
+    const serialized = [
+        Hex.fromNumber(chainId),
+        nonce ? Hex.fromNumber(nonce) : '0x',
+        maxPriorityFeePerGas ? Hex.fromNumber(maxPriorityFeePerGas) : '0x',
+        maxFeePerGas ? Hex.fromNumber(maxFeePerGas) : '0x',
+        gas ? Hex.fromNumber(gas) : '0x',
+        to ?? '0x',
+        value ? Hex.fromNumber(value) : '0x',
+        data ?? input ?? '0x',
+        accessTupleList,
+        authorizationTupleList,
+        typeof feeToken === 'bigint' || typeof feeToken === 'string'
+            ? TokenId.toAddress(feeToken)
+            : '0x',
+        feePayerSignatureOrSender,
+        ...(signature ? Signature.toTuple(signature) : []),
+    ];
+    return Hex.concat(options.format === 'feePayer' ? feePayerMagic : serializedType, Rlp.fromHex(serialized));
+}
+/**
+ * Validates a {@link ox#TransactionEnvelopeFeeToken.TransactionEnvelopeFeeToken}. Returns `true` if the envelope is valid, `false` otherwise.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Value } from 'ox'
+ * import { TransactionEnvelopeFeeToken } from 'ox/tempo'
+ *
+ * const valid = TransactionEnvelopeFeeToken.validate({
+ *   feeToken: '0x20c0000000000000000000000000000000000000',
+ *   maxFeePerGas: 2n ** 256n - 1n + 1n,
+ *   chainId: 1,
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1'),
+ * })
+ * // @log: false
+ * ```
+ *
+ * @param envelope - The transaction envelope to validate.
+ */
+export function validate(envelope) {
+    try {
+        assert(envelope);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=TransactionEnvelopeFeeToken.js.map

package/dist/ox/TransactionEnvelopeFeeToken.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionEnvelopeFeeToken.js","sourceRoot":"","sources":["../../src/ox/TransactionEnvelopeFeeToken.ts"],"names":[],"mappings":"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"}

package/dist/ox/TransactionRequest.d.ts

@@ -0,0 +1,62 @@
+import type * as Authorization from 'ox/Authorization';
+import type * as Errors from 'ox/Errors';
+import type * as Calls from 'ox/erc7821/Calls';
+import type * as Hex from 'ox/Hex';
+import * as ox_TransactionRequest from 'ox/TransactionRequest';
+import type { Compute } from "../internal/types.js";
+import * as TokenId from "./TokenId.js";
+/** A Transaction Request that is generic to all transaction types, as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/4aca1d7a3e5aab24c8f6437131289ad386944eaa/src/schemas/transaction.yaml#L358-L423). */
+export type TransactionRequest<bigintType = bigint, numberType = number, type extends string = string> = Compute<ox_TransactionRequest.TransactionRequest<bigintType, numberType, type> & {
+    calls?: readonly Calls.Call[] | undefined;
+    feeToken?: TokenId.TokenIdOrAddress | undefined;
+}>;
+/** RPC representation of a {@link ox#TransactionRequest.TransactionRequest}. */
+export type Rpc = TransactionRequest<Hex.Hex, Hex.Hex, string>;
+/**
+ * Converts a {@link ox#TransactionRequest.TransactionRequest} to a {@link ox#TransactionRequest.Rpc}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Value } from 'ox'
+ * import { TransactionRequest } from 'ox/tempo'
+ *
+ * const request = TransactionRequest.toRpc({
+ *   feeToken: '0x20c0000000000000000000000000000000000000',
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('0.01'),
+ * })
+ * ```
+ *
+ * @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
+ * import 'ox/window'
+ * import { Provider, Value } from 'ox'
+ * import { TransactionRequest } from 'ox/tempo'
+ *
+ * const provider = Provider.from(window.ethereum!)
+ *
+ * const request = TransactionRequest.toRpc({
+ *   feeToken: '0x20c0000000000000000000000000000000000000',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: Value.fromEther('0.01'),
+ * })
+ *
+ * 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: TransactionRequest): Rpc;
+export declare namespace toRpc {
+    type ErrorType = Authorization.toRpcList.ErrorType | Hex.fromNumber.ErrorType | Errors.GlobalErrorType;
+}
+//# sourceMappingURL=TransactionRequest.d.ts.map

package/dist/ox/TransactionRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionRequest.d.ts","sourceRoot":"","sources":["../../src/ox/TransactionRequest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,aAAa,MAAM,kBAAkB,CAAA;AACtD,OAAO,KAAK,KAAK,MAAM,MAAM,WAAW,CAAA;AACxC,OAAO,KAAK,KAAK,KAAK,MAAM,kBAAkB,CAAA;AAE9C,OAAO,KAAK,KAAK,GAAG,MAAM,QAAQ,CAAA;AAClC,OAAO,KAAK,qBAAqB,MAAM,uBAAuB,CAAA;AAC9D,OAAO,KAAK,EAAE,OAAO,EAAE,6BAA4B;AACnD,OAAO,KAAK,OAAO,qBAAoB;AAGvC,wPAAwP;AACxP,MAAM,MAAM,kBAAkB,CAC5B,UAAU,GAAG,MAAM,EACnB,UAAU,GAAG,MAAM,EACnB,IAAI,SAAS,MAAM,GAAG,MAAM,IAC1B,OAAO,CACT,qBAAqB,CAAC,kBAAkB,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,CAAC,GAAG;IACvE,KAAK,CAAC,EAAE,SAAS,KAAK,CAAC,IAAI,EAAE,GAAG,SAAS,CAAA;IACzC,QAAQ,CAAC,EAAE,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAA;CAChD,CACF,CAAA;AAED,gFAAgF;AAChF,MAAM,MAAM,GAAG,GAAG,kBAAkB,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,kBAAkB,GAAG,GAAG,CAwBtD;AAED,MAAM,CAAC,OAAO,WAAW,KAAK,CAAC;IAC7B,KAAY,SAAS,GACjB,aAAa,CAAC,SAAS,CAAC,SAAS,GACjC,GAAG,CAAC,UAAU,CAAC,SAAS,GACxB,MAAM,CAAC,eAAe,CAAA;CAC3B"}

package/dist/ox/TransactionRequest.js

@@ -0,0 +1,66 @@
+import * as Execute from 'ox/erc7821/Execute';
+import * as ox_TransactionRequest from 'ox/TransactionRequest';
+import * as TokenId from "./TokenId.js";
+import * as Transaction from "./Transaction.js";
+/**
+ * Converts a {@link ox#TransactionRequest.TransactionRequest} to a {@link ox#TransactionRequest.Rpc}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Value } from 'ox'
+ * import { TransactionRequest } from 'ox/tempo'
+ *
+ * const request = TransactionRequest.toRpc({
+ *   feeToken: '0x20c0000000000000000000000000000000000000',
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('0.01'),
+ * })
+ * ```
+ *
+ * @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
+ * import 'ox/window'
+ * import { Provider, Value } from 'ox'
+ * import { TransactionRequest } from 'ox/tempo'
+ *
+ * const provider = Provider.from(window.ethereum!)
+ *
+ * const request = TransactionRequest.toRpc({
+ *   feeToken: '0x20c0000000000000000000000000000000000000',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: Value.fromEther('0.01'),
+ * })
+ *
+ * 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 function toRpc(request) {
+    const request_rpc = ox_TransactionRequest.toRpc(request);
+    request_rpc.calls = request.calls;
+    if (typeof request.feeToken !== 'undefined')
+        request_rpc.feeToken = TokenId.toAddress(request.feeToken);
+    if (request.calls && request.from) {
+        delete request_rpc.to;
+        delete request_rpc.value;
+        delete request_rpc.data;
+        request_rpc.to = request.from;
+        request_rpc.data = Execute.encodeData(request.calls);
+    }
+    if (request.calls ||
+        typeof request.feeToken !== 'undefined' ||
+        request.type === 'feeToken')
+        request_rpc.type = Transaction.toRpcType.feeToken;
+    return request_rpc;
+}
+//# sourceMappingURL=TransactionRequest.js.map

package/dist/ox/TransactionRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionRequest.js","sourceRoot":"","sources":["../../src/ox/TransactionRequest.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAA;AAE7C,OAAO,KAAK,qBAAqB,MAAM,uBAAuB,CAAA;AAE9D,OAAO,KAAK,OAAO,qBAAoB;AACvC,OAAO,KAAK,WAAW,yBAAwB;AAiB/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,UAAU,KAAK,CAAC,OAA2B;IAC/C,MAAM,WAAW,GAAG,qBAAqB,CAAC,KAAK,CAAC,OAAO,CAAQ,CAAA;IAE/D,WAAW,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAA;IAEjC,IAAI,OAAO,OAAO,CAAC,QAAQ,KAAK,WAAW;QACzC,WAAW,CAAC,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;IAE5D,IAAI,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;QAClC,OAAO,WAAW,CAAC,EAAE,CAAA;QACrB,OAAO,WAAW,CAAC,KAAK,CAAA;QACxB,OAAO,WAAW,CAAC,IAAI,CAAA;QACvB,WAAW,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAA;QAC7B,WAAW,CAAC,IAAI,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IACtD,CAAC;IAED,IACE,OAAO,CAAC,KAAK;QACb,OAAO,OAAO,CAAC,QAAQ,KAAK,WAAW;QACvC,OAAO,CAAC,IAAI,KAAK,UAAU;QAE3B,WAAW,CAAC,IAAI,GAAG,WAAW,CAAC,SAAS,CAAC,QAAQ,CAAA;IAEnD,OAAO,WAAW,CAAA;AACpB,CAAC"}

package/dist/ox/index.d.ts

@@ -0,0 +1,5 @@
+export * as TokenId from "./TokenId.js";
+export * as TokenRole from "./TokenRole.js";
+export * as Transaction from "./Transaction.js";
+export * as TransactionEnvelopeFeeToken from "./TransactionEnvelopeFeeToken.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/ox/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ox/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,qBAAoB;AACvC,OAAO,KAAK,SAAS,uBAAsB;AAC3C,OAAO,KAAK,WAAW,yBAAwB;AAC/C,OAAO,KAAK,2BAA2B,yCAAwC"}

package/dist/ox/index.js

@@ -0,0 +1,5 @@
+export * as TokenId from "./TokenId.js";
+export * as TokenRole from "./TokenRole.js";
+export * as Transaction from "./Transaction.js";
+export * as TransactionEnvelopeFeeToken from "./TransactionEnvelopeFeeToken.js";
+//# sourceMappingURL=index.js.map

package/dist/ox/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/ox/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,qBAAoB;AACvC,OAAO,KAAK,SAAS,uBAAsB;AAC3C,OAAO,KAAK,WAAW,yBAAwB;AAC/C,OAAO,KAAK,2BAA2B,yCAAwC"}