viem 0.0.0-main.20231026T220458 → 0.0.0-main.20231026T222229

package/_types/chains/definitions/celoCannoli.d.ts

@@ -82,6 +82,9 @@ export declare const celoCannoli: import("../../types/utils.js").Assign<{
             gatewayFee: `0x${string}` | null;
             gatewayFeeRecipient: `0x${string}` | null;
             type: "0x7c";
+        }) | (import("../../types/utils.js").Assign_<Partial<Omit<import("../../index.js").TransactionLegacy<`0x${string}`, `0x${string}`, boolean, "0x0">, "typeHex">>, import("../celo/types.js").CeloRpcTransaction> & import("../../index.js").TransactionBase<`0x${string}`, `0x${string}`, boolean> & import("../../index.js").FeeValuesEIP1559<`0x${string}`> & {
+            feeCurrency: `0x${string}` | null;
+            type: "0x7b";
         }) | (import("../../types/utils.js").Assign_<Partial<Omit<import("../../index.js").TransactionEIP2930<`0x${string}`, `0x${string}`, boolean, "0x1">, "typeHex">>, import("../celo/types.js").CeloRpcTransaction> & Omit<import("../../index.js").TransactionLegacy<`0x${string}`, `0x${string}`, boolean, "0x0">, "typeHex"> & {
             feeCurrency: `0x${string}` | null;
             gatewayFee: `0x${string}` | null;
@@ -99,6 +102,9 @@ export declare const celoCannoli: import("../../types/utils.js").Assign<{
             gatewayFee: `0x${string}` | null;
             gatewayFeeRecipient: `0x${string}` | null;
             type: "0x7c";
+        }) | (import("../../types/utils.js").Assign_<Partial<Omit<import("../../index.js").TransactionEIP2930<`0x${string}`, `0x${string}`, boolean, "0x1">, "typeHex">>, import("../celo/types.js").CeloRpcTransaction> & import("../../index.js").TransactionBase<`0x${string}`, `0x${string}`, boolean> & import("../../index.js").FeeValuesEIP1559<`0x${string}`> & {
+            feeCurrency: `0x${string}` | null;
+            type: "0x7b";
         }) | (import("../../types/utils.js").Assign_<Partial<Omit<import("../../index.js").TransactionEIP1559<`0x${string}`, `0x${string}`, boolean, "0x2">, "typeHex">>, import("../celo/types.js").CeloRpcTransaction> & Omit<import("../../index.js").TransactionLegacy<`0x${string}`, `0x${string}`, boolean, "0x0">, "typeHex"> & {
             feeCurrency: `0x${string}` | null;
             gatewayFee: `0x${string}` | null;
@@ -116,6 +122,9 @@ export declare const celoCannoli: import("../../types/utils.js").Assign<{
             gatewayFee: `0x${string}` | null;
             gatewayFeeRecipient: `0x${string}` | null;
             type: "0x7c";
+        }) | (import("../../types/utils.js").Assign_<Partial<Omit<import("../../index.js").TransactionEIP1559<`0x${string}`, `0x${string}`, boolean, "0x2">, "typeHex">>, import("../celo/types.js").CeloRpcTransaction> & import("../../index.js").TransactionBase<`0x${string}`, `0x${string}`, boolean> & import("../../index.js").FeeValuesEIP1559<`0x${string}`> & {
+            feeCurrency: `0x${string}` | null;
+            type: "0x7b";
         })) => ({
             blockHash: `0x${string}` | null;
             blockNumber: bigint | null;
@@ -164,6 +173,30 @@ export declare const celoCannoli: import("../../types/utils.js").Assign<{
             feeCurrency: `0x${string}` | null;
             gatewayFee: bigint | null;
             gatewayFeeRecipient: `0x${string}` | null;
+        } | {
+            blockHash: `0x${string}` | null;
+            blockNumber: bigint | null;
+            from: `0x${string}`;
+            gas: bigint;
+            hash: `0x${string}`;
+            input: `0x${string}`;
+            nonce: number;
+            r: `0x${string}`;
+            s: `0x${string}`;
+            to: `0x${string}` | null;
+            transactionIndex: number | null;
+            typeHex: `0x${string}` | null;
+            v: bigint;
+            value: bigint;
+            gasPrice: undefined;
+            maxFeePerGas: bigint;
+            maxPriorityFeePerGas: bigint;
+            accessList?: undefined;
+            chainId?: number | undefined;
+            type: "cip64";
+            feeCurrency: `0x${string}` | null;
+            gatewayFee?: undefined;
+            gatewayFeeRecipient?: undefined;
         } | {
             blockHash: `0x${string}` | null;
             blockNumber: bigint | null;
@@ -236,6 +269,30 @@ export declare const celoCannoli: import("../../types/utils.js").Assign<{
             feeCurrency: `0x${string}` | null;
             gatewayFee: bigint | null;
             gatewayFeeRecipient: `0x${string}` | null;
+        } | {
+            blockHash: `0x${string}` | null;
+            blockNumber: bigint | null;
+            from: `0x${string}`;
+            gas: bigint;
+            hash: `0x${string}`;
+            input: `0x${string}`;
+            nonce: number;
+            r: `0x${string}`;
+            s: `0x${string}`;
+            to: `0x${string}` | null;
+            transactionIndex: number | null;
+            typeHex: `0x${string}` | null;
+            v: bigint;
+            value: bigint;
+            gasPrice: undefined;
+            maxFeePerGas: bigint;
+            maxPriorityFeePerGas: bigint;
+            accessList: import("../../index.js").AccessList;
+            chainId: number;
+            type: "cip64";
+            feeCurrency: `0x${string}` | null;
+            gatewayFee?: undefined;
+            gatewayFeeRecipient?: undefined;
         } | {
             blockHash: `0x${string}` | null;
             blockNumber: bigint | null;
@@ -308,6 +365,30 @@ export declare const celoCannoli: import("../../types/utils.js").Assign<{
             feeCurrency: `0x${string}` | null;
             gatewayFee: bigint | null;
             gatewayFeeRecipient: `0x${string}` | null;
+        } | {
+            blockHash: `0x${string}` | null;
+            blockNumber: bigint | null;
+            from: `0x${string}`;
+            gas: bigint;
+            hash: `0x${string}`;
+            input: `0x${string}`;
+            nonce: number;
+            r: `0x${string}`;
+            s: `0x${string}`;
+            to: `0x${string}` | null;
+            transactionIndex: number | null;
+            typeHex: `0x${string}` | null;
+            v: bigint;
+            value: bigint;
+            gasPrice?: undefined;
+            maxFeePerGas: bigint;
+            maxPriorityFeePerGas: bigint;
+            accessList: import("../../index.js").AccessList;
+            chainId: number;
+            type: "cip64";
+            feeCurrency: `0x${string}` | null;
+            gatewayFee?: undefined;
+            gatewayFeeRecipient?: undefined;
         }) & {};
         type: "transaction";
     };
@@ -396,6 +477,21 @@ export declare const celoCannoli: import("../../types/utils.js").Assign<{
             feeCurrency?: `0x${string}` | undefined;
             gatewayFee?: `0x${string}` | undefined;
             gatewayFeeRecipient?: `0x${string}` | undefined;
+        } | {
+            data?: `0x${string}` | undefined;
+            from: `0x${string}`;
+            gas?: `0x${string}` | undefined;
+            nonce?: `0x${string}` | undefined;
+            to?: `0x${string}` | null | undefined;
+            value?: `0x${string}` | undefined;
+            gasPrice?: undefined;
+            maxFeePerGas?: `0x${string}` | undefined;
+            maxPriorityFeePerGas?: `0x${string}` | undefined;
+            accessList?: import("../../index.js").AccessList | undefined;
+            type?: "0x7b" | undefined;
+            feeCurrency?: `0x${string}` | undefined;
+            gatewayFee?: undefined;
+            gatewayFeeRecipient?: undefined;
         } | {
             data?: `0x${string}` | undefined;
             from: `0x${string}`;
@@ -456,6 +552,21 @@ export declare const celoCannoli: import("../../types/utils.js").Assign<{
             feeCurrency?: `0x${string}` | undefined;
             gatewayFee?: `0x${string}` | undefined;
             gatewayFeeRecipient?: `0x${string}` | undefined;
+        } | {
+            data?: `0x${string}` | undefined;
+            from: `0x${string}`;
+            gas?: `0x${string}` | undefined;
+            nonce?: `0x${string}` | undefined;
+            to?: `0x${string}` | null | undefined;
+            value?: `0x${string}` | undefined;
+            gasPrice?: undefined;
+            maxFeePerGas?: `0x${string}` | undefined;
+            maxPriorityFeePerGas?: `0x${string}` | undefined;
+            accessList?: import("../../index.js").AccessList | undefined;
+            type?: "0x7b" | undefined;
+            feeCurrency?: `0x${string}` | undefined;
+            gatewayFee?: undefined;
+            gatewayFeeRecipient?: undefined;
         } | {
             data?: `0x${string}` | undefined;
             from: `0x${string}`;
@@ -516,6 +627,21 @@ export declare const celoCannoli: import("../../types/utils.js").Assign<{
             feeCurrency?: `0x${string}` | undefined;
             gatewayFee?: `0x${string}` | undefined;
             gatewayFeeRecipient?: `0x${string}` | undefined;
+        } | {
+            data?: `0x${string}` | undefined;
+            from: `0x${string}`;
+            gas?: `0x${string}` | undefined;
+            nonce?: `0x${string}` | undefined;
+            to?: `0x${string}` | null | undefined;
+            value?: `0x${string}` | undefined;
+            gasPrice?: undefined;
+            maxFeePerGas?: `0x${string}` | undefined;
+            maxPriorityFeePerGas?: `0x${string}` | undefined;
+            accessList?: import("../../index.js").AccessList | undefined;
+            type?: "0x7b" | undefined;
+            feeCurrency?: `0x${string}` | undefined;
+            gatewayFee?: undefined;
+            gatewayFeeRecipient?: undefined;
         }) & {};
         type: "transactionRequest";
     };

package/_types/chains/definitions/celoCannoli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"celoCannoli.d.ts","sourceRoot":"","sources":["../../../chains/definitions/celoCannoli.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCvB,CAAA"}
+{"version":3,"file":"celoCannoli.d.ts","sourceRoot":"","sources":["../../../chains/definitions/celoCannoli.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCvB,CAAA"}

package/_types/chains/utils/index.d.ts

@@ -1,7 +1,7 @@
 export { formattersCelo } from '../celo/formatters.js';
 export { serializeTransactionCelo, serializersCelo, } from '../celo/serializers.js';
 export { parseTransactionCelo } from '../celo/parsers.js';
-export type { CeloBlock, CeloBlockOverrides, CeloRpcBlock, CeloRpcBlockOverrides, CeloRpcTransaction, CeloRpcTransactionReceipt, CeloRpcTransactionReceiptOverrides, CeloRpcTransactionRequest, CeloTransaction, CeloTransactionReceipt, CeloTransactionReceiptOverrides, CeloTransactionRequest, CeloTransactionSerializable, CeloTransactionSerialized, CeloTransactionType, RpcTransactionCIP42, RpcTransactionRequestCIP42, TransactionCIP42, TransactionRequestCIP42, TransactionSerializableCIP42, TransactionSerializedCIP42, } from '../celo/types.js';
+export type { CeloBlock, CeloBlockOverrides, CeloRpcBlock, CeloRpcBlockOverrides, CeloRpcTransaction, CeloRpcTransactionReceipt, CeloRpcTransactionReceiptOverrides, CeloRpcTransactionRequest, CeloTransaction, CeloTransactionReceipt, CeloTransactionReceiptOverrides, CeloTransactionRequest, CeloTransactionSerializable, CeloTransactionSerialized, CeloTransactionType, RpcTransactionCIP42, RpcTransactionCIP64, RpcTransactionRequestCIP42, RpcTransactionRequestCIP64, TransactionCIP42, TransactionCIP64, TransactionRequestCIP42, TransactionRequestCIP64, TransactionSerializableCIP42, TransactionSerializableCIP64, TransactionSerializedCIP42, TransactionSerializedCIP64, } from '../celo/types.js';
 export { formattersOptimism } from '../optimism/formatters.js';
 export type { OptimismBlock, OptimismBlockOverrides, OptimismDepositTransaction, OptimismRpcBlock, OptimismRpcBlockOverrides, OptimismRpcDepositTransaction, OptimismRpcTransaction, OptimismRpcTransactionReceipt, OptimismRpcTransactionReceiptOverrides, OptimismTransaction, OptimismTransactionReceipt, OptimismTransactionReceiptOverrides, } from '../optimism/types.js';
 export { formattersZkSync } from '../zksync/formatters.js';

package/_types/chains/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../chains/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AACtD,OAAO,EACL,wBAAwB,EACxB,eAAe,GAChB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AACzD,YAAY,EACV,SAAS,EACT,kBAAkB,EAClB,YAAY,EACZ,qBAAqB,EACrB,kBAAkB,EAClB,yBAAyB,EACzB,kCAAkC,EAClC,yBAAyB,EACzB,eAAe,EACf,sBAAsB,EACtB,+BAA+B,EAC/B,sBAAsB,EACtB,2BAA2B,EAC3B,yBAAyB,EACzB,mBAAmB,EACnB,mBAAmB,EACnB,0BAA0B,EAC1B,gBAAgB,EAChB,uBAAuB,EACvB,4BAA4B,EAC5B,0BAA0B,GAC3B,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAC9D,YAAY,EACV,aAAa,EACb,sBAAsB,EACtB,0BAA0B,EAC1B,gBAAgB,EAChB,yBAAyB,EACzB,6BAA6B,EAC7B,sBAAsB,EACtB,6BAA6B,EAC7B,sCAAsC,EACtC,mBAAmB,EACnB,0BAA0B,EAC1B,mCAAmC,GACpC,MAAM,sBAAsB,CAAA;AAE7B,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAC1D,YAAY,EACV,WAAW,EACX,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,SAAS,EACT,cAAc,EACd,uBAAuB,EACvB,kBAAkB,EAClB,YAAY,EACZ,oBAAoB,EACpB,0BAA0B,EAC1B,4BAA4B,EAC5B,oCAAoC,EACpC,2BAA2B,EAC3B,iCAAiC,EACjC,iBAAiB,EACjB,uBAAuB,EACvB,wBAAwB,EACxB,iCAAiC,EACjC,wBAAwB,EACxB,8BAA8B,EAC9B,6BAA6B,EAC7B,mCAAmC,EACnC,2BAA2B,EAC3B,iCAAiC,EACjC,qBAAqB,GACtB,MAAM,oBAAoB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../chains/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AACtD,OAAO,EACL,wBAAwB,EACxB,eAAe,GAChB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AACzD,YAAY,EACV,SAAS,EACT,kBAAkB,EAClB,YAAY,EACZ,qBAAqB,EACrB,kBAAkB,EAClB,yBAAyB,EACzB,kCAAkC,EAClC,yBAAyB,EACzB,eAAe,EACf,sBAAsB,EACtB,+BAA+B,EAC/B,sBAAsB,EACtB,2BAA2B,EAC3B,yBAAyB,EACzB,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,0BAA0B,EAC1B,0BAA0B,EAC1B,gBAAgB,EAChB,gBAAgB,EAChB,uBAAuB,EACvB,uBAAuB,EACvB,4BAA4B,EAC5B,4BAA4B,EAC5B,0BAA0B,EAC1B,0BAA0B,GAC3B,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAC9D,YAAY,EACV,aAAa,EACb,sBAAsB,EACtB,0BAA0B,EAC1B,gBAAgB,EAChB,yBAAyB,EACzB,6BAA6B,EAC7B,sBAAsB,EACtB,6BAA6B,EAC7B,sCAAsC,EACtC,mBAAmB,EACnB,0BAA0B,EAC1B,mCAAmC,GACpC,MAAM,sBAAsB,CAAA;AAE7B,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAC1D,YAAY,EACV,WAAW,EACX,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,SAAS,EACT,cAAc,EACd,uBAAuB,EACvB,kBAAkB,EAClB,YAAY,EACZ,oBAAoB,EACpB,0BAA0B,EAC1B,4BAA4B,EAC5B,oCAAoC,EACpC,2BAA2B,EAC3B,iCAAiC,EACjC,iBAAiB,EACjB,uBAAuB,EACvB,wBAAwB,EACxB,iCAAiC,EACjC,wBAAwB,EACxB,8BAA8B,EAC9B,6BAA6B,EAC7B,mCAAmC,EACnC,2BAA2B,EAC3B,iCAAiC,EACjC,qBAAqB,GACtB,MAAM,oBAAoB,CAAA"}

package/_types/errors/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "0.0.0-main.20231026T220458";
+export declare const version = "0.0.0-main.20231026T222229";
 //# sourceMappingURL=version.d.ts.map

package/chains/celo/formatters.ts

@@ -20,6 +20,22 @@ import type {
   CeloTransactionRequest,
 } from './types.js'
 
+function isTransactionRequestCIP64(args: CeloTransactionRequest): boolean {
+  if (args.type === 'cip64') return true
+  if (args.type) return false
+  return (
+    'feeCurrency' in args &&
+    args.gatewayFee === undefined &&
+    args.gatewayFeeRecipient === undefined
+  )
+}
+
+function isTransactionRequestCIP42(args: CeloTransactionRequest): boolean {
+  if (args.type === 'cip42') return true
+  if (args.type) return false
+  return args.gatewayFee !== undefined || args.gatewayFeeRecipient !== undefined
+}
+
 export const formattersCelo = {
   block: /*#__PURE__*/ defineBlock({
     exclude: ['difficulty', 'gasLimit', 'mixHash', 'nonce', 'uncles'],
@@ -35,10 +51,15 @@ export const formattersCelo = {
         return {
           ...formatTransaction(transaction as RpcTransaction),
           feeCurrency: transaction.feeCurrency,
-          gatewayFee: transaction.gatewayFee
-            ? hexToBigInt(transaction.gatewayFee)
-            : null,
-          gatewayFeeRecipient: transaction.gatewayFeeRecipient,
+
+          ...(transaction.type !== '0x7b'
+            ? {
+                gatewayFee: transaction.gatewayFee
+                  ? hexToBigInt(transaction.gatewayFee)
+                  : null,
+                gatewayFeeRecipient: transaction.gatewayFeeRecipient || null,
+              }
+            : {}),
         }
       }) as Hash[] | CeloTransaction[]
       return {
@@ -49,6 +70,10 @@ export const formattersCelo = {
   }),
   transaction: /*#__PURE__*/ defineTransaction({
     format(args: CeloRpcTransaction): CeloTransaction {
+      if (args.type === '0x7b')
+        return {
+          feeCurrency: args.feeCurrency,
+        } as CeloTransaction
       return {
         feeCurrency: args.feeCurrency,
         gatewayFee: args.gatewayFee ? hexToBigInt(args.gatewayFee) : null,
@@ -67,8 +92,15 @@ export const formattersCelo = {
       }
     },
   }),
+
   transactionRequest: /*#__PURE__*/ defineTransactionRequest({
     format(args: CeloTransactionRequest): CeloRpcTransactionRequest {
+      if (isTransactionRequestCIP64(args))
+        return {
+          type: '0x7b',
+          feeCurrency: args.feeCurrency,
+        } as CeloRpcTransactionRequest
+
       const request = {
         feeCurrency: args.feeCurrency,
         gatewayFee:
@@ -77,7 +109,9 @@ export const formattersCelo = {
             : undefined,
         gatewayFeeRecipient: args.gatewayFeeRecipient,
       } as CeloRpcTransactionRequest
-      if (args.type === 'cip42') request.type = '0x7c'
+
+      if (isTransactionRequestCIP42(args)) request.type = '0x7c'
+
       return request
     },
   }),

package/chains/celo/parsers.ts

@@ -11,12 +11,17 @@ import {
   parseTransaction,
   toTransactionArray,
 } from '../../utils/transaction/parseTransaction.js'
-import { assertTransactionCIP42 } from './serializers.js'
+import {
+  assertTransactionCIP42,
+  assertTransactionCIP64,
+} from './serializers.js'
 import type {
   CeloTransactionSerialized,
   CeloTransactionType,
   TransactionSerializableCIP42,
+  TransactionSerializableCIP64,
   TransactionSerializedCIP42,
+  TransactionSerializedCIP64,
 } from './types.js'
 
 export type ParseTransactionCeloReturnType<
@@ -38,6 +43,11 @@ export function parseTransactionCelo<
       serializedTransaction as TransactionSerializedCIP42,
     ) as ParseTransactionCeloReturnType<TSerialized>
 
+  if (serializedType === '0x7b')
+    return parseTransactionCIP64(
+      serializedTransaction as TransactionSerializedCIP64,
+    ) as ParseTransactionCeloReturnType<TSerialized>
+
   return parseTransaction(
     serializedTransaction,
   ) as ParseTransactionCeloReturnType<TSerialized>
@@ -121,3 +131,74 @@ function parseTransactionCIP42(
 
   return transaction as TransactionSerializableCIP42
 }
+
+function parseTransactionCIP64(
+  serializedTransaction: TransactionSerializedCIP64,
+): TransactionSerializableCIP64 {
+  const transactionArray = toTransactionArray(serializedTransaction)
+
+  const [
+    chainId,
+    nonce,
+    maxPriorityFeePerGas,
+    maxFeePerGas,
+    gas,
+    to,
+    value,
+    data,
+    accessList,
+    feeCurrency,
+    v,
+    r,
+    s,
+  ] = transactionArray
+
+  if (transactionArray.length !== 13 && transactionArray.length !== 10) {
+    throw new InvalidSerializedTransactionError({
+      attributes: {
+        chainId,
+        nonce,
+        maxPriorityFeePerGas,
+        maxFeePerGas,
+        gas,
+        to,
+        value,
+        data,
+        accessList,
+        feeCurrency,
+        ...(transactionArray.length > 10
+          ? {
+              v,
+              r,
+              s,
+            }
+          : {}),
+      },
+      serializedTransaction,
+      type: 'cip64',
+    })
+  }
+
+  const transaction: Partial<TransactionSerializableCIP64> = {
+    chainId: hexToNumber(chainId as Hex),
+    type: 'cip64',
+  }
+
+  if (isHex(to) && to !== '0x') transaction.to = to
+  if (isHex(gas) && gas !== '0x') transaction.gas = hexToBigInt(gas)
+  if (isHex(data) && data !== '0x') transaction.data = data
+  if (isHex(nonce) && nonce !== '0x') transaction.nonce = hexToNumber(nonce)
+  if (isHex(value) && value !== '0x') transaction.value = hexToBigInt(value)
+  if (isHex(feeCurrency) && feeCurrency !== '0x')
+    transaction.feeCurrency = feeCurrency
+  if (isHex(maxFeePerGas) && maxFeePerGas !== '0x')
+    transaction.maxFeePerGas = hexToBigInt(maxFeePerGas)
+  if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== '0x')
+    transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas)
+  if (accessList.length !== 0 && accessList !== '0x')
+    transaction.accessList = parseAccessList(accessList as RecursiveArray<Hex>)
+
+  assertTransactionCIP64(transaction as TransactionSerializableCIP64)
+
+  return transaction as TransactionSerializableCIP64
+}

package/chains/celo/serializers.ts

@@ -18,21 +18,27 @@ import {
 import type {
   CeloTransactionSerializable,
   TransactionSerializableCIP42,
+  TransactionSerializableCIP64,
   TransactionSerializedCIP42,
+  TransactionSerializedCIP64,
 } from './types.js'
 
 export const serializeTransactionCelo: SerializeTransactionFn<
   CeloTransactionSerializable
 > = (tx, signature) => {
-  // Handle CIP-42 transactions
-  if (isCIP42(tx))
+  if (isCIP64(tx)) {
+    return serializeTransactionCIP64(
+      tx as TransactionSerializableCIP64,
+      signature,
+    )
+  } else if (isCIP42(tx)) {
     return serializeTransactionCIP42(
       tx as TransactionSerializableCIP42,
       signature,
     )
-
-  // Handle other transaction types
-  return serializeTransaction(tx as TransactionSerializable, signature)
+  } else {
+    return serializeTransaction(tx as TransactionSerializable, signature)
+  }
 }
 
 export const serializersCelo = {
@@ -43,6 +49,7 @@ export const serializersCelo = {
 // Serializers
 
 export type SerializeTransactionCIP42ReturnType = TransactionSerializedCIP42
+export type SerializeTransactionCIP64ReturnType = TransactionSerializedCIP64
 
 // There shall be a typed transaction with the code 0x7c that has the following format:
 // 0x7c || rlp([chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, feecurrency, gatewayFeeRecipient, gatewayfee, destination, amount, data, access_list, signature_y_parity, signature_r, signature_s]).
@@ -96,20 +103,83 @@ function serializeTransactionCIP42(
   ]) as SerializeTransactionCIP42ReturnType
 }
 
+function serializeTransactionCIP64(
+  transaction: TransactionSerializableCIP64,
+  signature?: Signature,
+): SerializeTransactionCIP64ReturnType {
+  assertTransactionCIP64(transaction)
+  const {
+    chainId,
+    gas,
+    nonce,
+    to,
+    value,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    accessList,
+    feeCurrency,
+    data,
+  } = transaction
+
+  const serializedTransaction = [
+    toHex(chainId),
+    nonce ? toHex(nonce) : '0x',
+    maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : '0x',
+    maxFeePerGas ? toHex(maxFeePerGas) : '0x',
+    gas ? toHex(gas) : '0x',
+    to ?? '0x',
+    value ? toHex(value) : '0x',
+    data ?? '0x',
+    serializeAccessList(accessList),
+    feeCurrency ?? '0x',
+  ]
+
+  if (signature) {
+    serializedTransaction.push(
+      signature.v === 27n ? '0x' : toHex(1), // yParity
+      trim(signature.r),
+      trim(signature.s),
+    )
+  }
+
+  return concatHex([
+    '0x7b',
+    toRlp(serializedTransaction),
+  ]) as SerializeTransactionCIP64ReturnType
+}
+
 //////////////////////////////////////////////////////////////////////////////
 // Utilities
 
 // process as CIP42 if any of these fields are present. realistically gatewayfee is not used but is part of spec
-function isCIP42(transaction: CeloTransactionSerializable) {
-  if (
+function isCIP42(transaction: CeloTransactionSerializable): boolean {
+  if (transaction.type === 'cip42') return true
+  // if the type is defined as anything else, assume it is *not* cip42
+  if (transaction.type) return false
+
+  // if the type is undefined, check if the fields match the expectations for cip42
+  return (
     'maxFeePerGas' in transaction &&
     'maxPriorityFeePerGas' in transaction &&
     ('feeCurrency' in transaction ||
       'gatewayFee' in transaction ||
       'gatewayFeeRecipient' in transaction)
   )
-    return true
-  return false
+}
+
+function isCIP64(transaction: CeloTransactionSerializable): boolean {
+  if (transaction.type === 'cip64') return true
+  // if the type is defined as anything else, assume it is *not* cip64
+  if (transaction.type) return false
+
+  // if the type is undefined, check if the fields match the expectations for cip64
+  return (
+    'maxFeePerGas' in transaction &&
+    'maxPriorityFeePerGas' in transaction &&
+    'feeCurrency' in transaction &&
+    !('gatewayFee' in transaction) &&
+    !('gatewayFeeRecipient' in transaction)
+  )
 }
 
 // maxFeePerGas must be less than 2^256 - 1: however writing like that caused exceptions to be raised
@@ -167,3 +237,45 @@ export function assertTransactionCIP42(
     )
   }
 }
+
+export function assertTransactionCIP64(
+  transaction: TransactionSerializableCIP64,
+) {
+  const {
+    chainId,
+    maxPriorityFeePerGas,
+    gasPrice,
+    maxFeePerGas,
+    to,
+    feeCurrency,
+  } = transaction
+
+  if (chainId <= 0) throw new InvalidChainIdError({ chainId })
+  if (to && !isAddress(to)) throw new InvalidAddressError({ address: to })
+
+  if (gasPrice)
+    throw new BaseError(
+      '`gasPrice` is not a valid CIP-64 Transaction attribute.',
+    )
+
+  if (maxFeePerGas && maxFeePerGas > MAX_MAX_FEE_PER_GAS)
+    throw new FeeCapTooHighError({ maxFeePerGas })
+  if (
+    maxPriorityFeePerGas &&
+    maxFeePerGas &&
+    maxPriorityFeePerGas > maxFeePerGas
+  )
+    throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas })
+
+  if (feeCurrency && !feeCurrency?.startsWith('0x')) {
+    throw new BaseError(
+      '`feeCurrency` MUST be a token address for CIP-64 transactions.',
+    )
+  }
+
+  if (!feeCurrency) {
+    throw new BaseError(
+      '`feeCurrency` must be provided for CIP-64 transactions.',
+    )
+  }
+}