@account-kit/wallet-client 0.0.1-alpha.1

package/src/schemas.ts

@@ -0,0 +1,257 @@
+import {
+  FormatRegistry,
+  Type,
+  type SchemaOptions,
+  type Static,
+} from "@sinclair/typebox";
+import { toHex, slice, pad, concat, hexToBigInt } 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 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(), Type.Literal("0x")]),
+  callData: TypeHex(),
+  callGasLimit: TypeHex(),
+  verificationGasLimit: TypeHex(),
+  preVerificationGas: TypeHex(),
+  maxFeePerGas: TypeHex(),
+  maxPriorityFeePerGas: TypeHex(),
+  paymasterAndData: Type.Union([TypeHex(), Type.Literal("0x")]),
+  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 TypeWebAuthnPublicKey = Type.Object({
+  x: TypeU256,
+  y: TypeU256,
+});
+
+export const TypePersistedInitcode = Type.Object({
+  factoryAddress: TypeAddress,
+  initcode: Type.Union([
+    Type.Object({
+      factoryType: Type.Literal("unknown"),
+      factoryData: TypeHex(),
+    }),
+    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,
+    }),
+    Type.Object({
+      factoryType: Type.Union([
+        Type.Literal("MAv1.0.0-MultiOwner"),
+        Type.Literal("LightAccountV2.0.0-MultiOwner"),
+      ]),
+      salt: TypeU256,
+      initialOwners: Type.Array(TypeAddress),
+    }),
+    Type.Object({
+      factoryType: Type.Literal("MAv1.0.0-MultiSig"),
+      salt: TypeU256,
+      initialOwners: Type.Array(TypeAddress),
+      threshold: TypeU256,
+    }),
+    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,
+        }),
+        Type.Object({
+          mav2type: Type.Literal("sma-b"),
+          initialOwner: TypeAddress,
+        }),
+        Type.Object({
+          mav2type: Type.Literal("ma-webauthn"),
+          initialOwner: TypeWebAuthnPublicKey,
+          entityId: TypeU32,
+        }),
+      ]),
+    ]),
+  ]),
+});
+
+export const TypeSerializedInitcode = Type.Object({
+  factoryType: Type.Union([
+    Type.Literal("LightAccountV1.0.1"),
+    Type.Literal("LightAccountV1.0.2"),
+    Type.Literal("LightAccountV1.1.0"),
+    Type.Literal("LightAccountV2.0.0"),
+    Type.Literal("LightAccountV2.0.0-MultiOwner"),
+    Type.Literal("MAv1.0.0-MultiOwner"),
+    Type.Literal("MAv1.0.0-MultiSig"),
+    Type.Literal("MAv2.0.0-sma-b"),
+    Type.Literal("MAv2.0.0-ma-ssv"),
+    Type.Literal("MAv2.0.0-ma-webauthn"),
+    Type.Literal("unknown"),
+  ]),
+  factoryAddress: TypeAddress,
+  factoryData: TypeHex(),
+});
+
+export const TypeCounterfactualInfo = Type.Intersect([
+  Type.Object({
+    accountAddress: TypeAddress,
+  }),
+  Type.Union([
+    Type.Intersect([
+      Type.Object({
+        type: Type.Literal("sca"),
+      }),
+      TypePersistedInitcode,
+    ]),
+    Type.Object({
+      type: Type.Literal("7702"),
+    }),
+  ]),
+]);
+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.Literal("sma-b")),
+      salt: Type.Optional(TypeHex()),
+    }),
+    // TODO: add more options after v0.
+  ]),
+);
+export type TypeCreationOptions = Static<typeof TypeCreationOptions>;
+
+export type TypeAccountType = Exclude<
+  Static<typeof TypeCreationOptions>,
+  undefined
+>["accountType"];
+
+export const KeySigner = Type.Object({
+  type: Type.Union([Type.Literal("secp256k1"), Type.Literal("contract")]),
+  publicKey: TypeHex(),
+});
+export type KeySigner = Static<typeof KeySigner>;
+
+export const TTypedDataDefinition = Type.Transform(
+  Type.Object({
+    domain: Type.Optional(
+      Type.Object({
+        chainId: Type.Optional(Type.Number()),
+        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 TypeSignatureRequest = Type.Union([
+  Type.Object({
+    type: Type.Literal("personal_sign"),
+    data: Type.Union([
+      Type.String({ minLength: 1 }),
+      Type.Object({
+        raw: TypeHex(),
+      }),
+    ]),
+  }),
+  Type.Object({
+    type: Type.Literal("eth_signTypedData_v4"),
+    data: TTypedDataDefinition,
+  }),
+]);
+
+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]);
+  });

package/src/types.ts

@@ -0,0 +1,60 @@
+import type { AlchemyTransport } from "@account-kit/infra";
+import type {
+  Address,
+  Chain,
+  Client,
+  Hex,
+  IsUndefined,
+  JsonRpcAccount,
+  Transport,
+} from "viem";
+import type { WalletServerViemRpcSchema } from "./rpc/schema";
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import type {
+  GrantPermissionsParams,
+  GrantPermissionsResult,
+} from "./client/actions/grantPermissions";
+
+export type CreateInnerClientParams<
+  TAccount extends JsonRpcAccount<Address> | undefined =
+    | JsonRpcAccount<Address>
+    | undefined,
+> = {
+  chain: Chain;
+  transport: AlchemyTransport;
+  policyId?: string;
+} & (IsUndefined<TAccount> extends true
+  ? {
+      account?: never;
+    }
+  : {
+      account: Address;
+    });
+
+export type InnerWalletApiClientBase<
+  TAccount extends JsonRpcAccount<Address> | undefined =
+    | JsonRpcAccount<Address>
+    | undefined,
+  TExtend extends { [key: string]: unknown } | undefined =
+    | { [key: string]: unknown }
+    | undefined,
+> = Client<
+  Transport,
+  Chain,
+  TAccount,
+  WalletServerViemRpcSchema,
+  { policyId?: string } & TExtend
+>;
+
+export type InnerClientActions = {
+  grantPermissions: (
+    signer: SmartAccountSigner,
+    params: GrantPermissionsParams & { chainId: Hex },
+  ) => Promise<GrantPermissionsResult>;
+};
+
+export type InnerWalletApiClient<
+  TAccount extends JsonRpcAccount<Address> | undefined =
+    | JsonRpcAccount<Address>
+    | undefined,
+> = InnerWalletApiClientBase<TAccount, InnerClientActions>;

package/src/utils.ts

@@ -0,0 +1,13 @@
+import { isHex, toHex, type Hex } from "viem";
+
+export const assertNever = (_val: never, msg: string): never => {
+  throw new Error(msg);
+};
+
+/** If the value is already Hex, it is returned unchanged. If it's a string, number or bigint, it's converted. */
+export const castToHex = (val: string | number | bigint | Hex): Hex => {
+  if (isHex(val)) {
+    return val;
+  }
+  return toHex(val);
+};