ox 1.0.0-beta.9 → 1.0.0

package/src/zod/AbiParameters.ts

@@ -0,0 +1,7 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as z_AbiParameter from './AbiParameter.js'
+import * as z from 'zod/mini'
+
+export const AbiParameters = z.readonly(z.array(z_AbiParameter.AbiParameter))
+
+export const Parameter = z_AbiParameter.AbiParameter

package/src/zod/AbiReceive.ts

@@ -0,0 +1,7 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as z from 'zod/mini'
+
+export const AbiReceive = z.object({
+  type: z.literal('receive'),
+  stateMutability: z.literal('payable'),
+})

package/src/zod/Solidity.ts

@@ -0,0 +1,83 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import type * as abitype from 'abitype'
+import * as z from 'zod/mini'
+
+export const Identifier = z
+  .string()
+  .check(
+    z.refine(
+      (value) => /^[a-zA-Z$_][a-zA-Z0-9$_]*$/.test(value),
+      'expected identifier',
+    ),
+  )
+
+export const Address = z.literal('address')
+export const Bool = z.literal('bool')
+export const Bytes = z
+  .string()
+  .check(
+    z.refine(
+      (value): value is abitype.SolidityBytes =>
+        /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(value),
+      'expected Solidity bytes type',
+    ),
+  )
+export const Function = z.literal('function')
+export const String = z.literal('string')
+export const Tuple = z.literal('tuple')
+export const Int = z
+  .string()
+  .check(
+    z.refine(
+      (value): value is abitype.SolidityInt =>
+        /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(
+          value,
+        ),
+      'expected Solidity integer type',
+    ),
+  )
+export const ArrayWithoutTuple = z
+  .string()
+  .check(
+    z.refine(
+      (value): value is abitype.SolidityArrayWithoutTuple =>
+        /^(address|bool|function|string|bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?|u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?)(\[[0-9]{0,}\])+$/.test(
+          value,
+        ),
+      'expected Solidity array type',
+    ),
+  )
+export const ArrayWithTuple = z
+  .string()
+  .check(
+    z.refine(
+      (value): value is abitype.SolidityArrayWithTuple =>
+        /^tuple(\[[0-9]{0,}\])+$/.test(value),
+      'expected Solidity tuple array type',
+    ),
+  )
+export const Array = z.union([ArrayWithTuple, ArrayWithoutTuple])
+
+export const Type = z.union([
+  Address,
+  Bool,
+  Bytes,
+  Function,
+  String,
+  Tuple,
+  Int,
+  Array,
+])
+
+export function isType(type: string) {
+  return (
+    type === 'address' ||
+    type === 'bool' ||
+    type === 'function' ||
+    type === 'string' ||
+    /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(type) ||
+    /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(
+      type,
+    )
+  )
+}

package/src/zod/TypedData.ts

@@ -0,0 +1,111 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import type * as core_TypedData from '../core/TypedData.js'
+import * as z_Address from './Address.js'
+import * as z_Solidity from './Solidity.js'
+import * as z from 'zod/mini'
+
+export const Domain = z.object({
+  chainId: z.optional(z.union([z.number(), z.bigint()])),
+  name: z.optional(z_Solidity.Identifier),
+  salt: z.optional(z.string()),
+  verifyingContract: z.optional(z_Address.Address),
+  version: z.optional(z.string()),
+})
+
+export const Type = z.union([
+  z_Solidity.Address,
+  z_Solidity.Bool,
+  z_Solidity.Bytes,
+  z_Solidity.String,
+  z_Solidity.Int,
+  z_Solidity.Array,
+])
+
+export const Parameter = z.object({
+  name: z_Solidity.Identifier,
+  type: z.string(),
+})
+
+const Raw = z.record(z_Solidity.Identifier, z.readonly(z.array(Parameter)))
+
+export const TypedData = z.pipe(
+  Raw,
+  z.transform((value, ctx) => validate(value, ctx)),
+)
+
+function validate(
+  typedData: Record<string, readonly core_TypedData.Parameter[]>,
+  ctx: z.core.ParsePayload,
+) {
+  for (const key of Object.keys(typedData)) {
+    if (z_Solidity.isType(key)) {
+      ctx.issues.push({
+        code: 'custom',
+        input: key,
+        message: `Invalid key. ${key} is a solidity type.`,
+      })
+      return z.NEVER
+    }
+
+    validateParameters(key, typedData, ctx)
+  }
+
+  return typedData as core_TypedData.TypedData
+}
+
+const typeWithoutTupleRegex =
+  /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*?)(?<array>(?:\[\d*?\])+?)?$/
+
+function validateParameters(
+  key: string,
+  typedData: Record<string, readonly core_TypedData.Parameter[]>,
+  ctx: z.core.ParsePayload,
+  ancestors = new Set<string>(),
+) {
+  const value = typedData[key]
+  if (!value) return
+
+  for (const parameter of value) {
+    if (parameter.type === key) {
+      ctx.issues.push({
+        code: 'custom',
+        input: parameter.type,
+        message: `Invalid type. ${key} is a self reference.`,
+      })
+      return z.NEVER
+    }
+
+    const match = typeWithoutTupleRegex.exec(parameter.type)?.groups as
+      | { array?: string | undefined; type?: string | undefined }
+      | undefined
+    const type = match?.type
+    if (!type) {
+      ctx.issues.push({
+        code: 'custom',
+        input: parameter.type,
+        message: `Invalid type. ${key} does not have a type.`,
+      })
+      return z.NEVER
+    }
+
+    if (type in typedData) {
+      if (ancestors.has(type)) {
+        ctx.issues.push({
+          code: 'custom',
+          input: type,
+          message: `Invalid type. ${type} is a circular reference.`,
+        })
+        return z.NEVER
+      }
+
+      validateParameters(type, typedData, ctx, new Set([...ancestors, type]))
+    } else if (!z_Solidity.isType(type)) {
+      ctx.issues.push({
+        code: 'custom',
+        input: type,
+        message: `Invalid type. ${type} is not a valid EIP-712 type.`,
+      })
+      return z.NEVER
+    }
+  }
+}

package/src/zod/_test/Abi.test-d.ts

@@ -0,0 +1,46 @@
+import type * as core_Abi from '../../core/Abi.js'
+import type * as core_AbiConstructor from '../../core/AbiConstructor.js'
+import type * as core_AbiError from '../../core/AbiError.js'
+import type * as core_AbiEvent from '../../core/AbiEvent.js'
+import type * as core_AbiFunction from '../../core/AbiFunction.js'
+import type * as core_AbiItem from '../../core/AbiItem.js'
+import type * as core_AbiParameter from '../../core/AbiParameter.js'
+import type * as core_AbiParameters from '../../core/AbiParameters.js'
+import { expectTypeOf, test } from 'vp/test'
+import * as z_Abi from '../Abi.js'
+import * as z_AbiConstructor from '../AbiConstructor.js'
+import * as z_AbiError from '../AbiError.js'
+import * as z_AbiEvent from '../AbiEvent.js'
+import * as z_AbiFunction from '../AbiFunction.js'
+import * as z_AbiItem from '../AbiItem.js'
+import * as z_AbiParameter from '../AbiParameter.js'
+import * as z_AbiParameters from '../AbiParameters.js'
+import type * as z from 'zod/mini'
+
+test('ABI schemas output Ox core ABI types', () => {
+  expectTypeOf<z.output<typeof z_Abi.Abi>>().toMatchTypeOf<core_Abi.Abi>()
+  expectTypeOf<
+    z.output<typeof z_AbiConstructor.AbiConstructor>
+  >().toMatchTypeOf<core_AbiConstructor.AbiConstructor>()
+  expectTypeOf<
+    z.output<typeof z_AbiError.AbiError>
+  >().toMatchTypeOf<core_AbiError.AbiError>()
+  expectTypeOf<
+    z.output<typeof z_AbiEvent.AbiEvent>
+  >().toMatchTypeOf<core_AbiEvent.AbiEvent>()
+  expectTypeOf<
+    z.output<typeof z_AbiFunction.AbiFunction>
+  >().toMatchTypeOf<core_AbiFunction.AbiFunction>()
+  expectTypeOf<
+    z.output<typeof z_AbiItem.AbiItem>
+  >().toMatchTypeOf<core_AbiItem.AbiItem>()
+  expectTypeOf<
+    z.output<typeof z_AbiParameter.AbiParameter>
+  >().toMatchTypeOf<core_AbiParameter.AbiParameter>()
+  expectTypeOf<
+    z.output<typeof z_AbiParameter.AbiEventParameter>
+  >().toMatchTypeOf<core_AbiParameter.AbiEventParameter>()
+  expectTypeOf<
+    z.output<typeof z_AbiParameters.AbiParameters>
+  >().toMatchTypeOf<core_AbiParameters.AbiParameters>()
+})

package/src/zod/_test/Abi.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, test } from 'vp/test'
+import * as z_Abi from '../Abi.js'
+import * as z_AbiConstructor from '../AbiConstructor.js'
+import * as z_AbiFunction from '../AbiFunction.js'
+import * as z_AbiParameter from '../AbiParameter.js'
+import * as z_Solidity from '../Solidity.js'
+import * as z from 'zod/mini'
+
+describe('Abi', () => {
+  test('decodes ABI items and normalizes legacy mutability fields', () => {
+    const input = [
+      {
+        constant: true,
+        inputs: [{ name: 'owner', type: 'address' }],
+        name: 'balanceOf',
+        outputs: [{ name: 'balance', type: 'uint256' }],
+        type: 'function',
+      },
+      {
+        inputs: [{ name: 'owner', type: 'address' }],
+        payable: true,
+        type: 'constructor',
+      },
+      {
+        payable: false,
+        type: 'fallback',
+      },
+    ] as const
+
+    expect(z.decode(z_Abi.Abi, input)).toMatchInlineSnapshot(`
+      [
+        {
+          "constant": true,
+          "inputs": [
+            {
+              "name": "owner",
+              "type": "address",
+            },
+          ],
+          "name": "balanceOf",
+          "outputs": [
+            {
+              "name": "balance",
+              "type": "uint256",
+            },
+          ],
+          "stateMutability": "view",
+          "type": "function",
+        },
+        {
+          "inputs": [
+            {
+              "name": "owner",
+              "type": "address",
+            },
+          ],
+          "payable": true,
+          "stateMutability": "payable",
+          "type": "constructor",
+        },
+        {
+          "payable": false,
+          "stateMutability": "nonpayable",
+          "type": "fallback",
+        },
+      ]
+    `)
+    expect(input[0]).not.toHaveProperty('stateMutability')
+  })
+
+  test('strips unknown keys', () => {
+    const input: unknown = {
+      type: 'function',
+      inputs: [],
+      name: 'totalSupply',
+      outputs: [{ type: 'uint256', extra: true }],
+      stateMutability: 'view',
+      extra: true,
+    }
+
+    expect(z.parse(z_AbiFunction.AbiFunction, input)).toMatchInlineSnapshot(`
+      {
+        "inputs": [],
+        "name": "totalSupply",
+        "outputs": [
+          {
+            "type": "uint256",
+          },
+        ],
+        "stateMutability": "view",
+        "type": "function",
+      }
+    `)
+  })
+
+  test('decodes tuple parameters recursively', () => {
+    expect(
+      z.decode(z_AbiParameter.AbiParameter, {
+        name: 'foo',
+        type: 'tuple[]',
+        components: [
+          { name: 'owner', type: 'address' },
+          { name: 'ids', type: 'uint256[]' },
+        ],
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "components": [
+          {
+            "name": "owner",
+            "type": "address",
+          },
+          {
+            "name": "ids",
+            "type": "uint256[]",
+          },
+        ],
+        "name": "foo",
+        "type": "tuple[]",
+      }
+    `)
+  })
+
+  test('rejects invalid parameter types', () => {
+    expect(
+      z.safeDecode(z_AbiParameter.AbiParameter, { type: 'notAValidType' })
+        .success,
+    ).toBe(false)
+  })
+
+  test('decodes constructors with explicit mutability', () => {
+    expect(
+      z.decode(z_AbiConstructor.AbiConstructor, {
+        type: 'constructor',
+        inputs: [],
+        payable: true,
+        stateMutability: 'nonpayable',
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "inputs": [],
+        "payable": true,
+        "stateMutability": "nonpayable",
+        "type": "constructor",
+      }
+    `)
+  })
+})
+
+describe('Solidity', () => {
+  test('decodes Solidity type tokens', () => {
+    expect(z.decode(z_Solidity.Address, 'address')).toMatchInlineSnapshot(
+      `"address"`,
+    )
+    expect(z.decode(z_Solidity.Int, 'uint256')).toMatchInlineSnapshot(
+      `"uint256"`,
+    )
+    expect(z.decode(z_Solidity.Array, 'tuple[2][]')).toMatchInlineSnapshot(
+      `"tuple[2][]"`,
+    )
+    expect(z.safeDecode(z_Solidity.Bytes, 'bytes33').success).toBe(false)
+  })
+})

package/src/zod/_test/TypedData.test-d.ts

@@ -0,0 +1,20 @@
+import type * as core_TypedData from '../../core/TypedData.js'
+import { expectTypeOf, test } from 'vp/test'
+import * as z_TypedData from '../TypedData.js'
+import type * as z from 'zod/mini'
+
+test('TypedData schemas output Ox core TypedData types', () => {
+  expectTypeOf<z.output<typeof z_TypedData.Domain>>().toMatchTypeOf<{
+    chainId?: number | bigint | undefined
+    name?: string | undefined
+    salt?: string | undefined
+    verifyingContract?: core_TypedData.Domain['verifyingContract'] | undefined
+    version?: string | undefined
+  }>()
+  expectTypeOf<
+    z.output<typeof z_TypedData.Parameter>
+  >().toMatchTypeOf<core_TypedData.Parameter>()
+  expectTypeOf<
+    z.output<typeof z_TypedData.TypedData>
+  >().toMatchTypeOf<core_TypedData.TypedData>()
+})

package/src/zod/_test/TypedData.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, test } from 'vp/test'
+import * as z_TypedData from '../TypedData.js'
+import * as z from 'zod/mini'
+
+describe('TypedData', () => {
+  test('decodes EIP-712 types maps', () => {
+    expect(
+      z.decode(z_TypedData.TypedData, {
+        Person: [
+          { name: 'name', type: 'string' },
+          { name: 'wallet', type: 'address' },
+        ],
+        Mail: [
+          { name: 'from', type: 'Person' },
+          { name: 'to', type: 'Person' },
+          { name: 'contents', type: 'string' },
+        ],
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "Mail": [
+          {
+            "name": "from",
+            "type": "Person",
+          },
+          {
+            "name": "to",
+            "type": "Person",
+          },
+          {
+            "name": "contents",
+            "type": "string",
+          },
+        ],
+        "Person": [
+          {
+            "name": "name",
+            "type": "string",
+          },
+          {
+            "name": "wallet",
+            "type": "address",
+          },
+        ],
+      }
+    `)
+  })
+
+  test('rejects invalid references', () => {
+    expect(
+      z.safeDecode(z_TypedData.TypedData, {
+        Mail: [{ name: 'from', type: 'Person' }],
+      }).success,
+    ).toBe(false)
+    expect(
+      z.safeDecode(z_TypedData.TypedData, {
+        Person: [{ name: 'parent', type: 'Person' }],
+      }).success,
+    ).toBe(false)
+    expect(
+      z.safeDecode(z_TypedData.TypedData, {
+        Foo: [{ name: 'bar', type: 'Bar' }],
+        Bar: [{ name: 'foo', type: 'Foo' }],
+      }).success,
+    ).toBe(false)
+  })
+
+  test('decodes domains with ABIType-compatible salt strings', () => {
+    expect(
+      z.decode(z_TypedData.Domain, {
+        chainId: 1,
+        name: 'EtherMail',
+        salt: 'not-hex',
+        verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
+        version: '1',
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "chainId": 1,
+        "name": "EtherMail",
+        "salt": "not-hex",
+        "verifyingContract": "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC",
+        "version": "1",
+      }
+    `)
+  })
+})

package/src/zod/_test/z.test-d.ts

@@ -1,5 +1,6 @@
 import type * as core_AccountProof from '../../core/AccountProof.js'
 import type * as core_AccessList from '../../core/AccessList.js'
+import type * as core_Abi from '../../core/Abi.js'
 import type * as core_Authorization from '../../core/Authorization.js'
 import type * as core_Block from '../../core/Block.js'
 import type * as core_BlockOverrides from '../../core/BlockOverrides.js'
@@ -12,12 +13,17 @@ import type * as core_Transaction from '../../core/Transaction.js'
 import type * as core_TransactionEnvelope from '../../core/TxEnvelope.js'
 import type * as core_TransactionReceipt from '../../core/TransactionReceipt.js'
 import type * as core_TransactionRequest from '../../core/TransactionRequest.js'
+import type * as core_TypedData from '../../core/TypedData.js'
 import type * as core_TxEnvelopeEip1559 from '../../core/TxEnvelopeEip1559.js'
 import { z } from 'ox/zod'
 import type * as zod from 'zod/mini'
 import { expectTypeOf, test } from 'vp/test'
 
 test('z entrypoint exposes module and direct integer schema types', () => {
+  expectTypeOf<zod.output<typeof z.Abi.Abi>>().toMatchTypeOf<core_Abi.Abi>()
+  expectTypeOf<
+    zod.output<typeof z.TypedData.TypedData>
+  >().toMatchTypeOf<core_TypedData.TypedData>()
   expectTypeOf<
     zod.output<typeof z.AccountProof.AccountProof>
   >().toEqualTypeOf<core_AccountProof.AccountProof>()

package/src/zod/_test/z.test.ts

@@ -5,6 +5,23 @@ const address = '0x0000000000000000000000000000000000000000'
 const storageKey = `0x${'11'.repeat(32)}` as const
 
 test('exports zod mini utilities, modules, and integer schemas', () => {
+  expect(
+    z.decode(z.Abi.Abi, [
+      {
+        inputs: [],
+        name: 'totalSupply',
+        outputs: [{ type: 'uint256' }],
+        stateMutability: 'view',
+        type: 'function',
+      },
+    ]),
+  ).toMatchObject([{ name: 'totalSupply', type: 'function' }])
+  expect(z.decode(z.Solidity.Int, 'uint256')).toBe('uint256')
+  expect(
+    z.decode(z.TypedData.TypedData, {
+      Person: [{ name: 'wallet', type: 'address' }],
+    }),
+  ).toMatchObject({ Person: [{ name: 'wallet', type: 'address' }] })
   expect(
     z.decode(z.AccountProof.AccountProof, {
       address,

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, {