ox 1.0.0-beta.8 → 1.0.0

package/src/zod/internal/rpcSchemas/Eth.ts

@@ -181,6 +181,12 @@ export const eth_getProof = from({
   returns: z_AccountProof.AccountProof,
 })
 
+export const eth_getRawTransactionByHash = from({
+  method: 'eth_getRawTransactionByHash',
+  params: z.tuple([z_Hex.Hex]),
+  returns: z.nullable(z_Hex.Hex),
+})
+
 export const eth_getStorageAt = from({
   method: 'eth_getStorageAt',
   params: z.tuple([z_Address.Address, z_Hex.Hex, BlockNumberOrTagOrIdentifier]),

package/src/zod/tempo/KeyAuthorization.ts

@@ -12,31 +12,34 @@ import * as z_SignatureEnvelope from './SignatureEnvelope.js'
 /** RPC token spending limit schema. */
 export const RpcTokenLimit = z.object({
   limit: z_Hex.Hex,
-  period: z.optional(z_Hex.Hex),
+  period: z.optional(z.nullable(z_Hex.Hex)),
   token: z_Address.Address,
 })
 
 /** RPC selector rule schema. */
 export const RpcSelectorRule = z.object({
-  recipients: z.optional(z.readonly(z.array(z_Address.Address))),
+  recipients: z.optional(z.nullable(z.readonly(z.array(z_Address.Address)))),
   selector: z_Hex.Hex,
 })
 
 /** RPC call scope schema. */
 export const RpcCallScope = z.object({
-  selectorRules: z.optional(z.readonly(z.array(RpcSelectorRule))),
+  selectorRules: z.optional(z.nullable(z.readonly(z.array(RpcSelectorRule)))),
   target: z_Address.Address,
 })
 
 /** RPC key authorization schema. */
 export const Rpc = z.object({
-  allowedCalls: z.optional(z.readonly(z.array(RpcCallScope))),
+  account: z.optional(z.nullable(z_Address.Address)),
+  allowedCalls: z.optional(z.nullable(z.readonly(z.array(RpcCallScope)))),
   chainId: z_Hex.Hex,
   expiry: z.optional(z.nullable(z_Hex.Hex)),
+  isAdmin: z.optional(z.nullable(z.boolean())),
   keyId: z_Address.Address,
   keyType: z_SignatureEnvelope.Type,
-  limits: z.optional(z.readonly(z.array(RpcTokenLimit))),
+  limits: z.optional(z.nullable(z.readonly(z.array(RpcTokenLimit)))),
   signature: z_SignatureEnvelope.Rpc,
+  witness: z.optional(z.nullable(z_Hex.Hex)),
 })
 
 /** Token spending limit schema. */
@@ -60,8 +63,7 @@ export const Scope = z.object({
   selector: z.optional(z.union([z_Hex.Hex, z.string()])),
 })
 
-/** Decoded key authorization schema. */
-export const Domain = z.object({
+const domainShape = {
   address: z_Address.Address,
   chainId: z.bigint(),
   expiry: z.optional(z.number()),
@@ -69,18 +71,35 @@ export const Domain = z.object({
   scopes: z.optional(z.readonly(z.array(Scope))),
   signature: z_SignatureEnvelope.Domain,
   type: z_SignatureEnvelope.Type,
-})
+  witness: z.optional(z_Hex.Hex),
+}
 
-/** Encode-only decoded key authorization schema accepting numberish `toRpc` inputs. */
-export const DomainToRpc = z.object({
-  address: z_Address.Address,
+/** Decoded key authorization schema (TIP-1049 admin fields are paired: both or neither). */
+export const Domain = z.union([
+  z.object({
+    ...domainShape,
+    account: z_Address.Address,
+    isAdmin: z.boolean(),
+  }),
+  z.object(domainShape),
+])
+
+const domainToRpcShape = {
+  ...domainShape,
   chainId: uintBigintNumberish(),
   expiry: z.optional(uintNumberNumberish()),
   limits: z.optional(z.readonly(z.array(TokenLimitToRpc))),
-  scopes: z.optional(z.readonly(z.array(Scope))),
-  signature: z_SignatureEnvelope.Domain,
-  type: z_SignatureEnvelope.Type,
-})
+}
+
+/** Encode-only decoded key authorization schema accepting numberish `toRpc` inputs. */
+export const DomainToRpc = z.union([
+  z.object({
+    ...domainToRpcShape,
+    account: z_Address.Address,
+    isAdmin: z.boolean(),
+  }),
+  z.object(domainToRpcShape),
+])
 
 /** Codec decoding an RPC key authorization into a signed key authorization. */
 export const KeyAuthorization = z.codec(Rpc, Domain, {

package/src/zod/tempo/SignatureEnvelope.ts

@@ -83,7 +83,6 @@ export const KeychainRpc = z.object({
 /** RPC native multisig signature envelope schema. */
 export const MultisigRpc = z.object({
   account: z_Address.Address,
-  configId: z_Hex.Hex,
   init: z.optional(z_MultisigConfig.Config),
   // Owner approvals are raw serialized signatures (node `Vec<Bytes>`).
   signatures: z.readonly(z.array(z_Hex.Hex)),
@@ -140,7 +139,6 @@ export const Keychain = z.object({
 /** Native multisig signature envelope schema. */
 export const Multisig = z.object({
   account: z_Address.Address,
-  genesisConfigId: z_Hex.Hex,
   init: z.optional(z_MultisigConfig.Config),
   // `signatures` is recursive; type the getter concretely to break the cycle.
   signatures: z.lazy(

package/src/zod/tempo/Transaction.ts

@@ -22,12 +22,16 @@ const FeePayerSignature = z.object({
   yParity: z_Number.Number,
 })
 
+/** Nullable RPC call field schema (the node serializes absent fields as `null`). */
+const NullableHex = z.optional(z.union([z_Hex.Hex, z.null()]))
+
 /** Tempo transaction call schema (decodes the RPC `input` field to `data`). */
 const Call = z.codec(
   z.object({
-    input: z.optional(z_Hex.Hex),
-    to: z.optional(z_Hex.Hex),
-    value: z.optional(z_Hex.Hex),
+    data: NullableHex,
+    input: NullableHex,
+    to: NullableHex,
+    value: NullableHex,
   }),
   z.object({
     data: z.optional(z_Hex.Hex),
@@ -36,9 +40,9 @@ const Call = z.codec(
   }),
   {
     decode: (value) => ({
-      data: value.input,
-      to: value.to,
-      value: value.value === '0x' ? undefined : value.value,
+      data: value.input ?? value.data ?? undefined,
+      to: value.to ?? undefined,
+      value: !value.value || value.value === '0x' ? undefined : value.value,
     }),
     encode: (value) => ({
       input: value.data,
@@ -51,9 +55,10 @@ const Call = z.codec(
 /** Encode-only tempo transaction call schema accepting numberish `toRpc` inputs. */
 const CallToRpc = z.codec(
   z.object({
-    input: z.optional(z_Hex.Hex),
-    to: z.optional(z_Hex.Hex),
-    value: z.optional(z_Hex.Hex),
+    data: NullableHex,
+    input: NullableHex,
+    to: NullableHex,
+    value: NullableHex,
   }),
   z.object({
     data: z.optional(z_Hex.Hex),
@@ -62,9 +67,9 @@ const CallToRpc = z.codec(
   }),
   {
     decode: (value) => ({
-      data: value.input,
-      to: value.to,
-      value: value.value === '0x' ? undefined : value.value,
+      data: value.input ?? value.data ?? undefined,
+      to: value.to ?? undefined,
+      value: !value.value || value.value === '0x' ? undefined : value.value,
     }),
     encode: (value) => ({
       input: value.data,
@@ -74,21 +79,78 @@ const CallToRpc = z.codec(
   },
 )
 
+/** Optional fields the node serializes as `null` when absent. */
+const nullableFields = [
+  'feePayer',
+  'feePayerSignature',
+  'gasPrice',
+  'keyAuthorization',
+  'nonceKey',
+  'validAfter',
+  'validBefore',
+] as const
+
+/**
+ * Wraps a tempo transaction object schema in a wire-shape codec: scrubs
+ * node-null optionals and maps the `aaAuthorizationList` RPC field to
+ * `authorizationList` (and back on encode).
+ */
+function wire<schema extends z.ZodMiniType>(schema: schema) {
+  return z.codec(z.looseObject({ type: z.literal('0x76') }), schema, {
+    decode: (rpc) => {
+      const { aaAuthorizationList, ...rest } = rpc as Record<string, unknown>
+      for (const key of nullableFields) if (rest[key] === null) delete rest[key]
+      if (Array.isArray(aaAuthorizationList) && aaAuthorizationList.length > 0)
+        rest.authorizationList = aaAuthorizationList
+      return rest as never
+    },
+    encode: (rpc) => {
+      const { authorizationList, ...rest } = rpc as Record<string, unknown>
+      return {
+        ...rest,
+        ...(authorizationList
+          ? { aaAuthorizationList: authorizationList }
+          : {}),
+      } as never
+    },
+  })
+}
+
 /** Tempo transaction schema (type `0x76`). */
-export const Tempo = z.object(
-  fields(z_Uint.Uint, z_Number.Number, Call, z_AuthorizationTempo.ListSigned),
+export const Tempo = wire(
+  z.object(
+    fields(z_Uint.Uint, z_Number.Number, Call, z_AuthorizationTempo.ListSigned),
+  ),
 )
 
 /** Encode-only tempo transaction schema accepting numberish `toRpc` inputs. */
-export const TempoToRpc = z.object(
-  fields(
-    z_Uint.UintToRpc,
-    z_Number.NumberToRpc,
-    CallToRpc,
-    z_AuthorizationTempo.ListSignedToRpc,
+export const TempoToRpc = wire(
+  z.object(
+    fields(
+      z_Uint.UintToRpc,
+      z_Number.NumberToRpc,
+      CallToRpc,
+      z_AuthorizationTempo.ListSignedToRpc,
+    ),
   ),
 )
 
+/** Pending tempo transaction schema (type `0x76`, not yet included in a block). */
+export const PendingTempo = wire(
+  z.object({
+    ...fields(
+      z_Uint.Uint,
+      z_Number.Number,
+      Call,
+      z_AuthorizationTempo.ListSigned,
+    ),
+    blockHash: z.null(),
+    blockNumber: z.null(),
+    blockTimestamp: z.optional(z.null()),
+    transactionIndex: z.null(),
+  }),
+)
+
 function fields<
   uint extends z.ZodMiniType,
   num extends z.ZodMiniType,
@@ -132,5 +194,5 @@ export const TransactionToRpc = z.union([
   z_Transaction.TransactionToRpc,
 ])
 
-/** Pending tempo transaction schema. */
-export const Pending = z_Transaction.Pending
+/** Pending tempo transaction schema (union of tempo + standard transaction types). */
+export const Pending = z.union([PendingTempo, z_Transaction.Pending])

package/src/zod/tempo/TransactionRequest.ts

@@ -14,7 +14,6 @@ import * as z from 'zod/mini'
 import * as z_AuthorizationTempo from './AuthorizationTempo.js'
 import * as z_KeyAuthorization from './KeyAuthorization.js'
 import * as z_SignatureEnvelope from './SignatureEnvelope.js'
-import * as z_TokenId from './TokenId.js'
 
 const fromRpcType = { '0x76': 'tempo' } as const
 const toRpcType = { tempo: '0x76' } as const
@@ -57,6 +56,16 @@ const CallToRpc = z.object({
   value: z.optional(uintBigintNumberish()),
 })
 
+const Capabilities = z.record(z.string(), z.unknown())
+
+const MultisigInit = z.object({
+  salt: z_Hex.Hex,
+  threshold: z.number(),
+  owners: z.readonly(
+    z.array(z.object({ owner: z_Address.Address, weight: z.number() })),
+  ),
+})
+
 /** RPC tempo transaction request schema. */
 export const Rpc = z.object({
   accessList: z.optional(z_AccessList.AccessList),
@@ -64,6 +73,7 @@ export const Rpc = z.object({
   blobVersionedHashes: z.optional(z.readonly(z.array(z_Hex.Hex))),
   blobs: z.optional(z.readonly(z.array(z_Hex.Hex))),
   calls: z.optional(z.readonly(z.array(CallRpc))),
+  capabilities: z.optional(Capabilities),
   chainId: z.optional(z_Hex.Hex),
   data: z.optional(z_Hex.Hex),
   feePayer: z.optional(z.boolean()),
@@ -75,10 +85,13 @@ export const Rpc = z.object({
   input: z.optional(z_Hex.Hex),
   keyAuthorization: z.optional(z_KeyAuthorization.Rpc),
   keyData: z.optional(z_Hex.Hex),
+  keyId: z.optional(z_Address.Address),
   keyType: z.optional(KeyType),
   maxFeePerBlobGas: z.optional(z_Hex.Hex),
   maxFeePerGas: z.optional(z_Hex.Hex),
   maxPriorityFeePerGas: z.optional(z_Hex.Hex),
+  multisigInit: z.optional(MultisigInit),
+  multisigSignatureCount: z.optional(z.number()),
   nonce: z.optional(z_Hex.Hex),
   nonceKey: z.optional(z_Hex.Hex),
   r: z.optional(z_Hex.Hex),
@@ -114,21 +127,25 @@ export const Domain = z.object({
   blobVersionedHashes: z.optional(z.readonly(z.array(z_Hex.Hex))),
   blobs: z.optional(z.readonly(z.array(z_Hex.Hex))),
   calls: z.optional(z.readonly(z.array(Call))),
+  capabilities: z.optional(Capabilities),
   chainId: z.optional(z.number()),
   data: z.optional(z_Hex.Hex),
   feePayer: z.optional(z.boolean()),
   feePayerSignature: z.optional(z.union([SignatureDecoded, z.null()])),
-  feeToken: z.optional(z.union([z_Address.Address, z.bigint()])),
+  feeToken: z.optional(z_Address.Address),
   from: z.optional(z_Address.Address),
   gas: z.optional(z.bigint()),
   gasPrice: z.optional(z.bigint()),
   input: z.optional(z_Hex.Hex),
   keyAuthorization: z.optional(z_KeyAuthorization.Domain),
   keyData: z.optional(z_Hex.Hex),
+  keyId: z.optional(z_Address.Address),
   keyType: z.optional(KeyType),
   maxFeePerBlobGas: z.optional(z.bigint()),
   maxFeePerGas: z.optional(z.bigint()),
   maxPriorityFeePerGas: z.optional(z.bigint()),
+  multisigInit: z.optional(MultisigInit),
+  multisigSignatureCount: z.optional(z.number()),
   nonce: z.optional(z.bigint()),
   nonceKey: z.optional(z.union([z.bigint(), z.literal('random')])),
   r: z.optional(z_Hex.Hex),
@@ -150,21 +167,25 @@ export const DomainToRpc = z.object({
   blobVersionedHashes: z.optional(z.readonly(z.array(z_Hex.Hex))),
   blobs: z.optional(z.readonly(z.array(z_Hex.Hex))),
   calls: z.optional(z.readonly(z.array(CallToRpc))),
+  capabilities: z.optional(Capabilities),
   chainId: z.optional(uintNumberNumberish()),
   data: z.optional(z_Hex.Hex),
   feePayer: z.optional(z.boolean()),
   feePayerSignature: z.optional(z.union([SignatureDecoded, z.null()])),
-  feeToken: z.optional(z.union([z_Address.Address, z.bigint()])),
+  feeToken: z.optional(z_Address.Address),
   from: z.optional(z_Address.Address),
   gas: z.optional(uintBigintNumberish()),
   gasPrice: z.optional(uintBigintNumberish()),
   input: z.optional(z_Hex.Hex),
   keyAuthorization: z.optional(z_KeyAuthorization.DomainToRpc),
   keyData: z.optional(z_Hex.Hex),
+  keyId: z.optional(z_Address.Address),
   keyType: z.optional(KeyType),
   maxFeePerBlobGas: z.optional(uintBigintNumberish()),
   maxFeePerGas: z.optional(uintBigintNumberish()),
   maxPriorityFeePerGas: z.optional(uintBigintNumberish()),
+  multisigInit: z.optional(MultisigInit),
+  multisigSignatureCount: z.optional(z.number()),
   nonce: z.optional(uintBigintNumberish()),
   nonceKey: z.optional(z.union([uintBigintNumberish(), z.literal('random')])),
   r: z.optional(z_Hex.Hex),
@@ -232,6 +253,17 @@ function fromRpc(
       z_KeyAuthorization.KeyAuthorization,
       request.keyAuthorization as never,
     ) as never
+  if (typeof request.capabilities !== 'undefined')
+    request_.capabilities = request.capabilities
+  if (typeof request.feePayer !== 'undefined')
+    request_.feePayer = request.feePayer
+  if (typeof request.keyData !== 'undefined') request_.keyData = request.keyData
+  if (typeof request.keyId !== 'undefined') request_.keyId = request.keyId
+  if (typeof request.keyType !== 'undefined') request_.keyType = request.keyType
+  if (typeof request.multisigInit !== 'undefined')
+    request_.multisigInit = request.multisigInit
+  if (typeof request.multisigSignatureCount !== 'undefined')
+    request_.multisigSignatureCount = request.multisigSignatureCount
   if (typeof request.validBefore !== 'undefined')
     request_.validBefore = core_Hex.toNumber(request.validBefore)
   if (typeof request.validAfter !== 'undefined')
@@ -251,6 +283,22 @@ function toRpc(
     authorizationList: undefined,
   } as never) as core_TransactionRequest.Rpc
 
+  const tempo =
+    typeof request.calls !== 'undefined' ||
+    typeof request.capabilities !== 'undefined' ||
+    typeof request.feePayer !== 'undefined' ||
+    typeof request.feeToken !== 'undefined' ||
+    typeof request.keyAuthorization !== 'undefined' ||
+    typeof request.keyData !== 'undefined' ||
+    typeof request.keyId !== 'undefined' ||
+    typeof request.keyType !== 'undefined' ||
+    typeof request.multisigInit !== 'undefined' ||
+    typeof request.multisigSignatureCount !== 'undefined' ||
+    typeof request.nonceKey !== 'undefined' ||
+    typeof request.validBefore !== 'undefined' ||
+    typeof request.validAfter !== 'undefined' ||
+    request.type === 'tempo'
+
   if (request.authorizationList)
     request_rpc.authorizationList = z.encode(
       z_AuthorizationTempo.ListSignedToRpc,
@@ -269,24 +317,41 @@ function toRpc(
       value: call.value ? encodeNumberish(call.value) : '0x',
       data: call.data ?? '0x',
     }))
-  else if (request.to || request.data || request.value)
+  else if (request.to || request.data || request.value || tempo)
     request_rpc.calls = [
       {
-        to: request.to ?? undefined,
+        to:
+          request.to ||
+          (tempo && (!request.data || request.data === '0x')
+            ? '0x0000000000000000000000000000000000000000'
+            : undefined),
         value: request.value ? encodeNumberish(request.value) : '0x',
         data: request.data ?? '0x',
       },
     ]
-  if (typeof request.feeToken !== 'undefined')
-    request_rpc.feeToken =
-      typeof request.feeToken === 'bigint'
-        ? z.encode(z_TokenId.address, request.feeToken)
-        : request.feeToken
+  if (
+    typeof request.feeToken !== 'undefined' &&
+    !(request.feePayer === true && !request.feePayerSignature)
+  )
+    request_rpc.feeToken = request.feeToken
   if (request.keyAuthorization)
     request_rpc.keyAuthorization = z.encode(
       z_KeyAuthorization.KeyAuthorizationToRpc,
       request.keyAuthorization as never,
     ) as never
+  if (typeof request.capabilities !== 'undefined')
+    request_rpc.capabilities = request.capabilities
+  if (typeof request.feePayer !== 'undefined')
+    request_rpc.feePayer = request.feePayer
+  if (typeof request.keyData !== 'undefined')
+    request_rpc.keyData = shimKeyData(request.keyData)
+  if (typeof request.keyId !== 'undefined') request_rpc.keyId = request.keyId
+  if (typeof request.keyType !== 'undefined')
+    request_rpc.keyType = request.keyType
+  if (typeof request.multisigInit !== 'undefined')
+    request_rpc.multisigInit = request.multisigInit
+  if (typeof request.multisigSignatureCount !== 'undefined')
+    request_rpc.multisigSignatureCount = request.multisigSignatureCount
   if (typeof request.validBefore !== 'undefined')
     request_rpc.validBefore = encodeNumberish(request.validBefore)
   if (typeof request.validAfter !== 'undefined')
@@ -300,16 +365,7 @@ function toRpc(
   })()
   if (nonceKey) request_rpc.nonceKey = nonceKey
 
-  if (
-    typeof request.calls !== 'undefined' ||
-    typeof request.feePayer !== 'undefined' ||
-    typeof request.feeToken !== 'undefined' ||
-    typeof request.keyAuthorization !== 'undefined' ||
-    typeof request.nonceKey !== 'undefined' ||
-    typeof request.validBefore !== 'undefined' ||
-    typeof request.validAfter !== 'undefined' ||
-    request.type === 'tempo'
-  ) {
+  if (tempo) {
     request_rpc.type = toRpcType.tempo
     delete request_rpc.data
     delete request_rpc.input
@@ -320,6 +376,16 @@ function toRpc(
   return request_rpc
 }
 
+/**
+ * Shims key data longer than 4 bytes into a 2-byte big-endian length hint
+ * (the node's gas estimator only accepts 1, 2, or 4-byte key data).
+ */
+function shimKeyData(data: core_Hex.Hex): core_Hex.Hex {
+  const byteLength = core_Hex.size(data)
+  if (byteLength <= 4) return data
+  return core_Hex.fromNumber(byteLength, { size: 2 })
+}
+
 /** Decodes an RPC signature into a recovered signature. */
 function signatureFromRpc(signature: {
   r: core_Hex.Hex

package/src/zod/tempo/TxEnvelopeTempo.ts

@@ -31,7 +31,7 @@ const baseFields = {
   calls: z.readonly(z.array(Call)),
   chainId: z.number(),
   feePayerSignature: z.optional(z.union([FeePayerSignature, z.null()])),
-  feeToken: z.optional(z.union([z_Address.Address, z.bigint()])),
+  feeToken: z.optional(z_Address.Address),
   from: z.optional(z_Address.Address),
   gas: z.optional(z.bigint()),
   keyAuthorization: z.optional(z_KeyAuthorization.Domain),

package/src/zod/tempo/_test/KeyAuthorization.test.ts

@@ -26,6 +26,59 @@ describe('KeyAuthorization', () => {
     )
   })
 
+  test('decodes node-null optional fields', () => {
+    const withNulls = {
+      ...rpc,
+      allowedCalls: null,
+      expiry: null,
+      limits: null,
+    } as const
+    expect(z.decode(z_KeyAuthorization.KeyAuthorization, withNulls)).toEqual(
+      core_KeyAuthorization.fromRpc(withNulls),
+    )
+  })
+
+  test('decodes nested node-null optional fields', () => {
+    const withNestedNulls = {
+      ...rpc,
+      allowedCalls: [
+        {
+          selectorRules: [{ recipients: null, selector: '0xa9059cbb' }],
+          target: '0x20c0000000000000000000000000000000000001',
+        },
+        {
+          selectorRules: null,
+          target: '0x20c0000000000000000000000000000000000002',
+        },
+      ],
+      limits: [
+        {
+          limit: '0x989680',
+          period: null,
+          token: '0x20c0000000000000000000000000000000000001',
+        },
+      ],
+    } as const
+    expect(
+      z.decode(z_KeyAuthorization.KeyAuthorization, withNestedNulls),
+    ).toEqual(core_KeyAuthorization.fromRpc(withNestedNulls))
+  })
+
+  test('decodes witness and admin fields', () => {
+    const withAdmin = {
+      ...rpc,
+      account: '0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6',
+      isAdmin: true,
+      witness:
+        '0x0000000000000000000000000000000000000000000000000000000000000001',
+    } as const
+    const decoded = z.decode(z_KeyAuthorization.KeyAuthorization, withAdmin)
+    expect(decoded).toEqual(core_KeyAuthorization.fromRpc(withAdmin))
+    expect(z.encode(z_KeyAuthorization.KeyAuthorization, decoded)).toEqual(
+      core_KeyAuthorization.toRpc(decoded),
+    )
+  })
+
   test('decodes nested allowedCalls into scopes', () => {
     const withScopes = {
       ...rpc,

package/src/zod/tempo/_test/SignatureEnvelope.test.ts

@@ -21,8 +21,6 @@ const p256 = {
 
 const multisig = {
   account: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
-  configId:
-    '0x0000000000000000000000000000000000000000000000000000000000000000',
   signatures: [
     core_SignatureEnvelope.serialize(core_SignatureEnvelope.fromRpc(secp256k1)),
   ],