@account-kit/wallet-client 0.1.0-alpha.8 → 4.50.0

package/src/schemas.ts

@@ -1,585 +0,0 @@
-import {
-  FormatRegistry,
-  Type,
-  type SchemaOptions,
-  type Static,
-} from "@sinclair/typebox";
-import { yParityToV } from "ox/Signature";
-import {
-  toHex,
-  slice,
-  pad,
-  concat,
-  hexToBigInt,
-  serializeSignature,
-  hexToNumber,
-  parseSignature,
-  numberToHex,
-} from "viem";
-
-const UUID_V4_REGEX =
-  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-FormatRegistry.Set("uuid", (value) => UUID_V4_REGEX.test(value));
-
-const BASE_64_URL_REGEX = /^[A-Za-z0-9_-]+$/; // Matches base64url encoded strings (without padding)
-FormatRegistry.Set("base64url", (value) => BASE_64_URL_REGEX.test(value));
-
-export const baseAccountTypes = [
-  "sma-b",
-  "la-v2",
-  "la-v1.0.1",
-  "la-v1.0.2",
-  "la-v1.1.0",
-] as const;
-
-export type BaseAccountType = (typeof baseAccountTypes)[number];
-
-export const accountTypes = [...baseAccountTypes, "7702"] as const;
-
-export type AccountType = (typeof accountTypes)[number];
-
-export const TypeHex = (options?: SchemaOptions) =>
-  Type.TemplateLiteral("0x${string}", {
-    ...options,
-  });
-
-export const TypeAddress = Type.TemplateLiteral("0x${string}", {});
-
-export const TypeUuid = Type.String({
-  format: "uuid",
-});
-
-export const TypeBase64UrlEncodedString = Type.String({
-  format: "base64url",
-});
-
-// BigInt is not json-serializable, so it must be encoded as a string.
-export const TypeU256 = Type.Transform(Type.String({}))
-  .Decode((value) => BigInt(value))
-  .Encode((value) => toHex(value));
-
-export const TypeU32 = Type.Transform(Type.String({}))
-  .Decode((value) => Number.parseInt(value, 16))
-  .Encode((value) => toHex(value));
-
-export const TypeUserOperationRequest_v6 = Type.Object({
-  sender: TypeAddress,
-  nonce: TypeHex(),
-  initCode: Type.Union([
-    TypeHex({
-      description: "Present",
-    }),
-    Type.Literal("0x", {
-      description: "Absent",
-    }),
-  ]),
-  callData: TypeHex(),
-  callGasLimit: TypeHex(),
-  verificationGasLimit: TypeHex(),
-  preVerificationGas: TypeHex(),
-  maxFeePerGas: TypeHex(),
-  maxPriorityFeePerGas: TypeHex(),
-  paymasterAndData: Type.Union([
-    TypeHex({
-      description: "Present",
-    }),
-    Type.Literal("0x", {
-      description: "Absent",
-    }),
-  ]),
-  signature: TypeHex(),
-});
-
-export const TypeUserOperationRequest_v7 = Type.Object({
-  sender: TypeAddress,
-  nonce: TypeHex(),
-  factory: Type.Optional(TypeAddress),
-  factoryData: Type.Optional(TypeHex()),
-  callData: TypeHex(),
-  callGasLimit: TypeHex(),
-  verificationGasLimit: TypeHex(),
-  preVerificationGas: TypeHex(),
-  maxFeePerGas: TypeHex(),
-  maxPriorityFeePerGas: TypeHex(),
-  paymaster: Type.Optional(TypeAddress),
-  paymasterData: Type.Optional(TypeHex()),
-  paymasterVerificationGasLimit: Type.Optional(TypeHex()),
-  paymasterPostOpGasLimit: Type.Optional(TypeHex()),
-  signature: TypeHex(),
-});
-
-export const TypeEip7702UnsignedAuth = Type.Object({
-  chainId: TypeHex(),
-  address: TypeAddress,
-  nonce: TypeHex(),
-});
-
-export const TypeEip7702SignedAuth = Type.Intersect([
-  TypeEip7702UnsignedAuth,
-  Type.Object({
-    r: TypeHex(),
-    s: TypeHex(),
-    yParity: TypeHex(),
-  }),
-]);
-
-export const TypeWebAuthnPublicKey = Type.Object({
-  x: TypeU256,
-  y: TypeU256,
-});
-
-export const TypePersistedInitcode = Type.Object({
-  factoryAddress: TypeAddress,
-  initcode: Type.Union([
-    Type.Object(
-      {
-        factoryType: Type.Literal("unknown", {
-          description: "Unknown factory type",
-        }),
-        factoryData: TypeHex({}),
-      },
-      {
-        description: "Unknown factory type",
-      },
-    ),
-    Type.Object(
-      {
-        factoryType: Type.Union([
-          Type.Literal("LightAccountV2.0.0"),
-          Type.Literal("LightAccountV1.1.0"),
-          Type.Literal("LightAccountV1.0.2"),
-          Type.Literal("LightAccountV1.0.1"),
-        ]),
-        salt: TypeU256,
-        initialOwner: TypeAddress,
-      },
-      {
-        description: "Light Account",
-      },
-    ),
-    Type.Object(
-      {
-        factoryType: Type.Union([
-          Type.Literal("MAv1.0.0-MultiOwner"),
-          Type.Literal("LightAccountV2.0.0-MultiOwner"),
-        ]),
-        salt: TypeU256,
-        initialOwners: Type.Array(TypeAddress),
-      },
-      {
-        description: "Multi-Owner Modular Account",
-      },
-    ),
-    Type.Object(
-      {
-        factoryType: Type.Literal("MAv1.0.0-MultiSig"),
-        salt: TypeU256,
-        initialOwners: Type.Array(TypeAddress),
-        threshold: TypeU256,
-      },
-      {
-        description: "Multi-Sig Modular Account",
-      },
-    ),
-    Type.Intersect([
-      Type.Object({
-        factoryType: Type.Literal("MAv2.0.0"),
-        salt: TypeU256,
-      }),
-      Type.Union([
-        Type.Object(
-          {
-            mav2type: Type.Literal("ma-ssv"),
-            initialOwner: TypeAddress,
-            entityId: TypeU32,
-          },
-          {
-            description: "Modular Account V2 SSV",
-          },
-        ),
-        Type.Object(
-          {
-            mav2type: Type.Literal("sma-b"),
-            initialOwner: TypeAddress,
-          },
-          {
-            description: "Modular Account V2 SMA-B",
-          },
-        ),
-        Type.Object(
-          {
-            mav2type: Type.Literal("ma-webauthn"),
-            initialOwner: TypeWebAuthnPublicKey,
-            entityId: TypeU32,
-          },
-          {
-            description: "Modular Account V2 WebAuthn",
-          },
-        ),
-      ]),
-    ]),
-  ]),
-});
-
-export const TypeSerializedInitcode = Type.Object({
-  factoryType: Type.Union([
-    Type.Literal("LightAccountV1.0.1", { description: "Light Account v1.0.1" }),
-    Type.Literal("LightAccountV1.0.2", { description: "Light Account v1.0.2" }),
-    Type.Literal("LightAccountV1.1.0", { description: "Light Account v1.1.0" }),
-    Type.Literal("LightAccountV2.0.0", { description: "Light Account v2.0.0" }),
-    Type.Literal("LightAccountV2.0.0-MultiOwner", {
-      description: "Light Account v2.0.0 MultiOwner",
-    }),
-    Type.Literal("MAv1.0.0-MultiOwner", {
-      description: "Modular Account v1.0.0 MultiOwner",
-    }),
-    Type.Literal("MAv1.0.0-MultiSig", {
-      description: "Modular Account v1.0.0 MultiSig",
-    }),
-    Type.Literal("MAv2.0.0-sma-b", {
-      description: "Modular Account v2.0.0 SMA-B",
-    }),
-    Type.Literal("MAv2.0.0-ma-ssv", {
-      description: "Modular Account v2.0.0 SSV",
-    }),
-    Type.Literal("MAv2.0.0-ma-webauthn", {
-      description: "Modular Account v2.0.0 WebAuthn",
-    }),
-    Type.Literal("unknown", { description: "Unknown factory type" }),
-  ]),
-  factoryAddress: TypeAddress,
-  factoryData: TypeHex({}),
-});
-
-export const TypeCounterfactualInfo = Type.Intersect([
-  Type.Object({
-    accountAddress: TypeAddress,
-  }),
-  Type.Union([
-    Type.Intersect(
-      [
-        Type.Object({
-          type: Type.Literal("sca"),
-        }),
-        TypePersistedInitcode,
-      ],
-      {
-        description: "Smart Contract Account",
-      },
-    ),
-    Type.Object(
-      {
-        type: Type.Literal("7702"),
-        implementationAddress: TypeAddress,
-      },
-      {
-        description: "7702 Account",
-      },
-    ),
-  ]),
-]);
-export type TypeCounterfactualInfo = Static<typeof TypeCounterfactualInfo>;
-
-export const TypeCreationOptions = Type.Optional(
-  Type.Union([
-    Type.Object(
-      {
-        // Optional b/c `sma-b` is the default if no accountType is specified.
-        accountType: Type.Optional(
-          Type.Union(baseAccountTypes.map((lit) => Type.Literal(lit))),
-        ),
-        salt: Type.Optional(TypeHex()),
-      },
-      {
-        description: "SMA-B account type",
-      },
-    ),
-    Type.Object(
-      {
-        accountType: Type.Literal("7702"),
-        // TODO: Add support for specifying a delegation address.
-        // Currently we only support delegating to MAv2, and it's important
-        // that wallet applications maintain a strict shortlist of well-known
-        // accounts: https://github.com/ethereum/ERCs/pull/947/files#diff-dab085f963ca621595044bcbc0922705aa38b69f5bf8770dcb3d0496a633efcfR189
-        // delegation: TypeAddress,
-      },
-      {
-        description: "7702 account type",
-      },
-    ),
-  ]),
-);
-export type TypeCreationOptions = Static<typeof TypeCreationOptions>;
-
-export type TypeAccountType = Exclude<
-  Static<typeof TypeCreationOptions>,
-  undefined
->["accountType"];
-
-export const TypeSignatureType = Type.Union([
-  Type.Literal("secp256k1", { description: "Secp256k1" }),
-  Type.Literal("ecdsa", { description: "ECDSA (alias for secp256k1)" }),
-  Type.Literal("contract", { description: "Contract" }),
-]);
-export type TypeSignatureType = Static<typeof TypeSignatureType>;
-
-export const KeySigner = Type.Object({
-  type: TypeSignatureType,
-  publicKey: TypeHex({}),
-});
-export type KeySigner = Static<typeof KeySigner>;
-
-export const TTypedDataDefinition = Type.Transform(
-  Type.Object({
-    domain: Type.Optional(
-      Type.Object({
-        chainId: Type.Optional(Type.Integer()),
-        name: Type.Optional(Type.String()),
-        salt: Type.Optional(TypeHex()),
-        verifyingContract: Type.Optional(TypeAddress),
-        version: Type.Optional(Type.String()),
-      }),
-    ),
-    types: Type.Record(
-      Type.String(),
-      Type.Array(
-        Type.Object({
-          name: Type.String(),
-          type: Type.String(),
-        }),
-      ),
-    ),
-    primaryType: Type.String(),
-    message: Type.Record(Type.String(), Type.Unknown()),
-  }),
-)
-  // No-op b/c Viem is happy w/ the encoded version too.
-  .Decode((it) => it)
-  // Encode the TypedDataDefinition into our json-serialized format.
-  .Encode(({ domain, types, primaryType, message }) => {
-    return {
-      domain: {
-        ...domain,
-        chainId:
-          typeof domain?.chainId === "bigint"
-            ? Number(domain.chainId)
-            : domain?.chainId,
-      },
-      types,
-      primaryType,
-      message: JSON.parse(
-        JSON.stringify(message, (_, v) =>
-          typeof v === "bigint" ? toHex(v) : v,
-        ),
-      ),
-    };
-  });
-
-export const TypePersonalSignSignatureRequest = Type.Object(
-  {
-    type: Type.Literal("personal_sign"),
-    data: Type.Union([
-      Type.String({ minLength: 1, description: "Message" }),
-      Type.Object(
-        {
-          raw: TypeHex(),
-        },
-        { description: "Raw message" },
-      ),
-    ]),
-    rawPayload: TypeHex(),
-  },
-  { description: "Personal sign" },
-);
-
-export const TypeTypedDataSignatureRequest = Type.Object(
-  {
-    type: Type.Literal("eth_signTypedData_v4"),
-    data: TTypedDataDefinition,
-    rawPayload: TypeHex(),
-  },
-  {
-    description: "Typed data",
-  },
-);
-
-export const TypeAuthorizationSignatureRequest = Type.Object({
-  type: Type.Literal("eip7702Auth"),
-  rawPayload: TypeHex(),
-});
-
-export const TypeSignatureRequest = Type.Union([
-  TypePersonalSignSignatureRequest,
-  TypeTypedDataSignatureRequest,
-  TypeAuthorizationSignatureRequest,
-]);
-
-export const TypeCallId = Type.Transform(TypeHex())
-  .Decode((value) => {
-    return {
-      chainId: toHex(hexToBigInt(slice(value, 0, 32))),
-      hash: slice(value, 32),
-    };
-  })
-  .Encode(({ chainId, hash }) => {
-    const chainIdPadded = pad(chainId, { size: 32 });
-    return concat([chainIdPadded, hash]);
-  });
-
-export const PreparedCall_UserOpV060 = Type.Object(
-  {
-    type: Type.Literal("user-operation-v060", {
-      description: "User Operation (Entrypoint v0.6.0)",
-    }),
-    data: Type.Omit(TypeUserOperationRequest_v6, ["signature"], {
-      description: "Unsigned User Operation (Entrypoint v0.6.0)",
-    }),
-    chainId: TypeHex(),
-    signatureRequest: Type.Union([
-      TypePersonalSignSignatureRequest,
-      TypeTypedDataSignatureRequest,
-    ]),
-  },
-  {
-    description: "Prepared User Operation (Entrypoint v0.6.0)",
-  },
-);
-
-export const PreparedCall_UserOpV070 = Type.Object(
-  {
-    type: Type.Literal("user-operation-v070", {
-      description: "User Operation (Entrypoint v0.7.0)",
-    }),
-    data: Type.Omit(TypeUserOperationRequest_v7, ["signature"], {
-      description: "Unsigned User Operation (Entrypoint v0.7.0)",
-    }),
-    chainId: TypeHex(),
-    signatureRequest: Type.Union([
-      TypePersonalSignSignatureRequest,
-      TypeTypedDataSignatureRequest,
-    ]),
-  },
-  {
-    description: "Prepared User Operation (Entrypoint v0.7.0)",
-  },
-);
-
-export const PreparedCall_Authorization = Type.Object(
-  {
-    type: Type.Literal("authorization", {
-      description: "EIP-7702 Authorization Request",
-    }),
-    data: Type.Omit(TypeEip7702UnsignedAuth, ["chainId"]),
-    chainId: TypeHex(),
-    signatureRequest: TypeAuthorizationSignatureRequest,
-  },
-  {
-    description: "Prepared EIP-7702 Authorization",
-  },
-);
-
-export const TypeEdcsaSigData = Type.Union([
-  TypeHex({
-    description: "Hex-encoded signature",
-  }),
-  Type.Transform(
-    Type.Object(
-      {
-        r: TypeHex(),
-        s: TypeHex(),
-        yParity: TypeHex(),
-      },
-      { description: "r, s, yParity" },
-    ),
-  )
-    .Decode((sig) =>
-      serializeSignature({ ...sig, yParity: hexToNumber(sig.yParity) }),
-    )
-    .Encode((hex) => {
-      const parsed = parseSignature(hex);
-      return {
-        ...parsed,
-        yParity: numberToHex(parsed.yParity),
-      };
-    }),
-  Type.Transform(
-    Type.Object(
-      {
-        r: TypeHex(),
-        s: TypeHex(),
-        v: TypeHex(),
-      },
-      {
-        description: "r, s, v",
-      },
-    ),
-  )
-    .Decode((sig) => serializeSignature({ ...sig, v: hexToBigInt(sig.v) }))
-    .Encode((hex) => {
-      const parsed = parseSignature(hex);
-      return {
-        ...parsed,
-        v: numberToHex(yParityToV(parsed.yParity)),
-      };
-    }),
-]);
-
-export const TypeEcdsaSig = Type.Object({
-  signature: Type.Union([
-    Type.Object(
-      {
-        type: Type.Literal("secp256k1"),
-        data: TypeEdcsaSigData,
-      },
-      {
-        description: "Secp256k1 signature",
-      },
-    ),
-    Type.Object(
-      {
-        type: Type.Literal("ecdsa"),
-        data: TypeEdcsaSigData,
-      },
-      {
-        description: "ECDSA signature (alias for secp256k1)",
-      },
-    ),
-  ]),
-});
-
-export const TypePrepareCall_UserOpV060_Signed = Type.Intersect(
-  [Type.Omit(PreparedCall_UserOpV060, ["signatureRequest"]), TypeEcdsaSig],
-  {
-    description: "Prepared User Operation (Entrypoint v0.6.0) with signature",
-  },
-);
-
-export const TypePrepareCall_UserOpV070_Signed = Type.Intersect(
-  [Type.Omit(PreparedCall_UserOpV070, ["signatureRequest"]), TypeEcdsaSig],
-  {
-    description: "Prepared User Operation (Entrypoint v0.7.0) with signature",
-  },
-);
-
-export const TypePrepareCall_Authorization_Signed = Type.Intersect(
-  [Type.Omit(PreparedCall_Authorization, ["signatureRequest"]), TypeEcdsaSig],
-  {
-    description: "Prepared EIP-7702 Authorization with signature",
-  },
-);
-
-export const TypeCallArray = Type.Object(
-  {
-    type: Type.Literal("array"),
-    data: Type.Array(
-      Type.Union([
-        TypePrepareCall_UserOpV060_Signed,
-        TypePrepareCall_UserOpV070_Signed,
-        TypePrepareCall_Authorization_Signed,
-      ]),
-    ),
-  },
-  {
-    description: "Array of prepared calls with signatures",
-  },
-);