@account-kit/wallet-client 0.1.0-alpha.1 → 0.1.0-alpha.10

package/src/capabilities/permissions/index.ts

@@ -1,142 +0,0 @@
-import { PermissionType } from "@account-kit/smart-contracts/experimental";
-import {
-  Type,
-  type TLiteral,
-  type TLiteralValue,
-  type TObject,
-  type TSchema,
-} from "@sinclair/typebox";
-import { KeySigner, TypeAddress, TypeHex } from "../../schemas.js";
-
-const Permission = <
-  TData extends TSchema,
-  TLiteralVal extends TLiteralValue,
-  TType extends TLiteral<TLiteralVal>,
->(
-  typeString: TLiteralVal, // e.g., "root"
-  typeEnum: TLiteralVal, // e.g., PermissionType.ROOT
-  data: TData,
-  description: string,
-): TObject<{ type: TType; data: TData }> => {
-  return Type.Transform(
-    Type.Object(
-      {
-        type: Type.Literal(typeEnum),
-        data,
-      },
-      { description },
-    ),
-  )
-    .Decode((value) => ({
-      ...value,
-      type: typeString, // enum → string
-    }))
-    .Encode((value) => ({
-      ...value,
-      type: typeEnum, // string → enum
-    })) as never;
-};
-
-const NativeTokenTransfer = Permission(
-  "native-token-transfer",
-  PermissionType.NATIVE_TOKEN_TRANSFER,
-  Type.Object({
-    allowance: TypeHex(),
-  }),
-  "allows transfer of native tokens from the account",
-);
-
-const Erc20TokenTransfer = Permission(
-  "erc20-token-transfer",
-  PermissionType.ERC20_TOKEN_TRANSFER,
-  Type.Object({
-    allowance: TypeHex(),
-    address: TypeAddress,
-  }),
-  "allows transfer or approval of erc20 tokens from the account",
-);
-
-const GasLimit = Permission(
-  "gas-limit",
-  PermissionType.GAS_LIMIT,
-  Type.Object({
-    limit: TypeHex(),
-  }),
-  "allows the key to spend gas for UOs",
-);
-
-const ContractAccess = Permission(
-  "contract-access",
-  PermissionType.CONTRACT_ACCESS,
-  Type.Object({
-    address: TypeAddress,
-  }),
-  "grants access to all functions in a contract",
-);
-
-const AccountFunction = Permission(
-  "account-functions",
-  PermissionType.ACCOUNT_FUNCTIONS,
-  Type.Object({
-    functions: Type.Array(TypeHex(), { minItems: 1 }),
-  }),
-  "grants access to functions in the account",
-);
-
-const AllExternalFunctionAccess = Permission(
-  "functions-on-all-contracts",
-  PermissionType.FUNCTIONS_ON_ALL_CONTRACTS,
-  Type.Object({
-    functions: Type.Array(TypeHex(), { minItems: 1 }),
-  }),
-  "access to a function selector in any address or contract",
-);
-
-const ContractFunctionAccess = Permission(
-  "functions-on-contract",
-  PermissionType.FUNCTIONS_ON_CONTRACT,
-  Type.Object({
-    address: TypeAddress,
-    functions: Type.Array(TypeHex(), { minItems: 1 }),
-  }),
-  "grants access to specified functions on a specific contract",
-);
-
-const Root = Permission(
-  "root",
-  PermissionType.ROOT,
-  Type.Optional(Type.Never()),
-  "grants full access to everything",
-);
-
-export const TypePermission = Type.Union([
-  // 7715 permissions
-  NativeTokenTransfer,
-  Erc20TokenTransfer,
-  GasLimit,
-  // additional permissions
-  ContractAccess,
-  AccountFunction,
-  AllExternalFunctionAccess,
-  ContractFunctionAccess,
-  Root,
-]);
-
-export const PermissionsArray = Type.Array(TypePermission, { minItems: 1 });
-
-export const PermissionsContext = Type.Object({
-  context: TypeHex(),
-});
-
-export const PermissionsData = Type.Object({
-  chainId: TypeHex(),
-  expiry: Type.Optional(Type.Number()),
-  key: KeySigner,
-  permissions: PermissionsArray,
-});
-
-export const PermissionsCapability = Type.Union([
-  PermissionsContext,
-  // TODO: support permissions object here instead of only context-encoded permissions
-  // PermissionsData,
-]);

package/src/capabilities/permissions/mav2.ts

@@ -1,127 +0,0 @@
-import { PermissionType } from "@account-kit/smart-contracts/experimental";
-import type { Static } from "@sinclair/typebox";
-import { concatHex, sliceHex, type Hex } from "viem";
-import type { PermissionsData } from ".";
-import type { KeySigner } from "../../schemas";
-import { assertNever } from "../../utils.js";
-
-export const SESSION_ID_LENGTH_BYTES = 16;
-export const ENTITY_ID_LENGTH_BYTES = 4;
-
-export const PermissionsContextVersion = {
-  REMOTE_MODE_DEFERRED_ACTION: "0x00",
-  LOCAL_MODE_DEFERRED_ACTION: "0x01",
-  NON_DEFERRED_ACTION: "0x02",
-} as const;
-
-type ContextVersionHex =
-  (typeof PermissionsContextVersion)[keyof typeof PermissionsContextVersion];
-
-type DecodedPermissionsContext = {
-  contextVersion: keyof typeof PermissionsContextVersion;
-} & (
-  | {
-      contextVersion: "REMOTE_MODE_DEFERRED_ACTION";
-      sessionId: Hex;
-      signature: Hex;
-      deferredAction?: never;
-    }
-  | {
-      contextVersion: "LOCAL_MODE_DEFERRED_ACTION";
-      deferredAction: Hex;
-      sessionId?: never;
-      signature?: never;
-    }
-  | {
-      contextVersion: "NON_DEFERRED_ACTION";
-      deferredAction?: never;
-      sessionId?: never;
-      signature?: never;
-      entityId: Hex;
-      isGlobalValidation: boolean;
-    }
-);
-
-export const encodePermissionsContext = (
-  context: DecodedPermissionsContext,
-): Hex => {
-  switch (context.contextVersion) {
-    case "REMOTE_MODE_DEFERRED_ACTION":
-      return concatHex([
-        PermissionsContextVersion.REMOTE_MODE_DEFERRED_ACTION,
-        context.sessionId,
-        context.signature,
-      ]);
-    case "LOCAL_MODE_DEFERRED_ACTION":
-      return concatHex([
-        PermissionsContextVersion.LOCAL_MODE_DEFERRED_ACTION,
-        context.deferredAction,
-      ]);
-    case "NON_DEFERRED_ACTION":
-      return concatHex([
-        PermissionsContextVersion.NON_DEFERRED_ACTION,
-        context.isGlobalValidation ? "0x01" : "0x00",
-        context.entityId,
-      ]);
-    default:
-      return assertNever(context, "Unexpected context version");
-  }
-};
-
-export const decodePermissionsContext = (
-  input: Hex,
-): DecodedPermissionsContext => {
-  const contextVersion = sliceHex(input, 0, 1) as ContextVersionHex;
-  switch (contextVersion) {
-    case "0x00": {
-      const sessionId = sliceHex(input, 1, SESSION_ID_LENGTH_BYTES + 1);
-      const signature = sliceHex(input, SESSION_ID_LENGTH_BYTES + 1);
-      return {
-        contextVersion: "REMOTE_MODE_DEFERRED_ACTION",
-        sessionId,
-        signature,
-      };
-    }
-    case "0x01": {
-      const deferredAction = sliceHex(input, 1);
-      return {
-        contextVersion: "LOCAL_MODE_DEFERRED_ACTION",
-        deferredAction,
-      };
-    }
-    case "0x02": {
-      const isGlobalValidation = sliceHex(input, 1, 2) === "0x01";
-      const entityId = sliceHex(input, 2, ENTITY_ID_LENGTH_BYTES + 2);
-      return {
-        contextVersion: "NON_DEFERRED_ACTION",
-        isGlobalValidation,
-        entityId,
-      };
-    }
-    default:
-      return assertNever(
-        contextVersion,
-        `Unexpected context version: ${contextVersion}`,
-      );
-  }
-};
-
-export const prefixSignatureKeyType = (
-  sig: Hex,
-  type: KeySigner["type"],
-): Hex => {
-  switch (type) {
-    case "secp256k1":
-      return concatHex(["0x00", sig]);
-    case "contract":
-      return concatHex(["0x01", sig]);
-    default:
-      return assertNever(type, "Unexpected session key type");
-  }
-};
-
-export const isGlobalValidation = (
-  data: Pick<Static<typeof PermissionsData>, "permissions">,
-): boolean => {
-  return data.permissions.some((p) => p.type === PermissionType.ROOT);
-};

package/src/rpc/request.ts

@@ -1,273 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import { Capabilities } from "../capabilities/index.js";
-import {
-  PermissionsContext,
-  PermissionsData,
-} from "../capabilities/permissions/index.js";
-import {
-  TypeAddress,
-  TypeBase64UrlEncodedString,
-  TypeCreationOptions,
-  TypeHex,
-  TypeSerializedInitcode,
-  TypeSignatureRequest,
-  TypeUserOperationRequest_v6,
-  TypeUserOperationRequest_v7,
-  TypeUuid,
-} from "../schemas.js";
-
-export const wallet_sendPreparedCalls = Type.Object(
-  {
-    Request: Type.Object({
-      method: Type.Literal("wallet_sendPreparedCalls"),
-      params: Type.Tuple([
-        Type.Object({
-          type: Type.Union([
-            Type.Literal("user-operation-v060"),
-            Type.Literal("user-operation-v070"),
-          ]),
-          data: Type.Union([
-            Type.Omit(TypeUserOperationRequest_v6, ["signature"]),
-            Type.Omit(TypeUserOperationRequest_v7, ["signature"]),
-          ]),
-          chainId: TypeHex(),
-          signature: Type.Object({
-            type: Type.Transform(Type.String())
-              .Decode((value) => {
-                if (value.toLowerCase() !== "ecdsa") {
-                  throw new Error("Invalid signature type, must be 'ecdsa'");
-                }
-
-                return "ecdsa" as const;
-              })
-              .Encode((value) => value),
-            signature: TypeHex(),
-          }),
-          capabilities: Type.Optional(
-            Type.Object({ permissions: PermissionsContext }),
-          ),
-        }),
-      ]),
-    }),
-    ReturnType: Type.Object({
-      preparedCallIds: Type.Array(TypeHex()),
-    }),
-  },
-  {
-    description:
-      "This method is used after signing the signatureRequest returned from prepareCalls to submit a user operation",
-  },
-);
-
-export const wallet_prepareCalls = Type.Object(
-  {
-    Request: Type.Object({
-      method: Type.Literal("wallet_prepareCalls"),
-      params: Type.Tuple([
-        Type.Object({
-          calls: Type.Array(
-            Type.Object({
-              to: TypeAddress,
-              data: Type.Optional(TypeHex()),
-              value: Type.Optional(TypeHex()),
-            }),
-          ),
-          from: TypeAddress,
-          chainId: TypeHex(),
-          capabilities: Type.Optional(Capabilities),
-        }),
-      ]),
-    }),
-    ReturnType: Type.Object({
-      type: Type.Union([
-        Type.Literal("user-operation-v060"),
-        Type.Literal("user-operation-v070"),
-      ]),
-      data: Type.Union([
-        Type.Omit(TypeUserOperationRequest_v6, ["signature"]),
-        Type.Omit(TypeUserOperationRequest_v7, ["signature"]),
-      ]),
-      chainId: TypeHex(),
-      signatureRequest: TypeSignatureRequest,
-    }),
-  },
-  {
-    description:
-      "This method is used to prepare a user operation for submission. It will return a built user operation and a signature request which needs to be signed by the user before submitting to wallet_sendPreparedCalls",
-  },
-);
-
-export const wallet_requestAccount = Type.Object(
-  {
-    Request: Type.Object({
-      method: Type.Literal("wallet_requestAccount"),
-      params: Type.Tuple([
-        Type.Union([
-          Type.Object({
-            signerAddress: TypeAddress,
-            id: Type.Optional(TypeUuid),
-            creationHint: TypeCreationOptions,
-            includeCounterfactualInfo: Type.Optional(
-              Type.Boolean({ default: false }),
-            ),
-          }),
-          Type.Object({
-            accountAddress: TypeAddress,
-            includeCounterfactualInfo: Type.Optional(
-              Type.Boolean({ default: false }),
-            ),
-          }),
-        ]),
-      ]),
-    }),
-    ReturnType: Type.Object({
-      accountAddress: TypeAddress,
-      id: TypeUuid,
-      counterfactualInfo: Type.Optional(TypeSerializedInitcode),
-    }),
-  },
-  {
-    description: `This method is used to get the smart account address and relevant info for a given signer. If an account does not already exist for a given signer, this method will create one before returning the counterfactual address.`,
-  },
-);
-
-export const wallet_createAccount = Type.Object(
-  {
-    Request: Type.Object({
-      method: Type.Literal("wallet_createAccount"),
-      params: Type.Tuple([
-        Type.Object({
-          signerAddress: TypeAddress,
-          id: Type.Optional(TypeUuid),
-          creationOptions: TypeCreationOptions,
-        }),
-      ]),
-    }),
-    ReturnType: Type.Object({
-      accountAddress: TypeAddress,
-      id: TypeUuid,
-    }),
-  },
-  {
-    description: `This method is used to create a smart account for a given signer. This method is primarly used to import existing accounts. For most cases, you should use wallet_requestAccount instead.`,
-  },
-);
-
-export const wallet_listAccounts = Type.Object(
-  {
-    Request: Type.Object({
-      method: Type.Literal("wallet_listAccounts"),
-      params: Type.Tuple([
-        Type.Object({
-          signerAddress: TypeAddress,
-          limit: Type.Optional(
-            Type.Number({ minimum: 1, maximum: 100, default: 100 }),
-          ),
-          after: Type.Optional(TypeBase64UrlEncodedString),
-        }),
-      ]),
-    }),
-    ReturnType: Type.Object({
-      accounts: Type.Array(
-        Type.Object({
-          accountAddress: TypeAddress,
-          id: TypeUuid,
-        }),
-      ),
-      meta: Type.Object({
-        totalCount: Type.Number(),
-        after: Type.Union([TypeBase64UrlEncodedString, Type.Null()]),
-      }),
-    }),
-  },
-  {
-    description:
-      "This method is used to list all smart accounts for a given signer.",
-  },
-);
-
-export const wallet_createSession = Type.Object(
-  {
-    Request: Type.Object({
-      method: Type.Literal("wallet_createSession"),
-      params: Type.Tuple([
-        Type.Intersect([
-          PermissionsData,
-          Type.Object({ account: TypeAddress }),
-        ]),
-      ]),
-    }),
-    ReturnType: Type.Object({
-      sessionId: TypeHex(),
-      signatureRequest: TypeSignatureRequest,
-    }),
-  },
-  {
-    description:
-      "This method is used to create a session for a given address with specified permissions.",
-  },
-);
-
-export const wallet_getCallsStatus = Type.Object(
-  {
-    Request: Type.Object({
-      method: Type.Literal("wallet_getCallsStatus"),
-      params: Type.Tuple([
-        TypeHex({
-          description: "The call ID returned from wallet_sendPreparedCalls",
-        }),
-      ]),
-    }),
-    ReturnType: Type.Object({
-      id: TypeHex(),
-      chainId: TypeHex(),
-      atomic: Type.Boolean(),
-      status: Type.Union([
-        Type.Literal(100, {
-          description:
-            "Batch has been received by the wallet but has not completed execution onchain",
-        }),
-        Type.Literal(200, {
-          description:
-            "Batch has been included onchain without reverts, receipts array contains info of all calls",
-        }),
-        Type.Literal(400, {
-          description:
-            "Batch has not been included onchain and wallet will not retry",
-        }),
-        Type.Literal(500, {
-          description:
-            "Batch reverted *completely* and only changes related to gas charge may have been included onchain",
-        }),
-        Type.Literal(600, {
-          description:
-            "Batch reverted *partially* and some changes related to batch calls may have been included onchain",
-        }),
-      ]),
-      receipts: Type.Optional(
-        Type.Array(
-          Type.Object({
-            logs: Type.Array(
-              Type.Object({
-                address: TypeAddress,
-                data: TypeHex(),
-                topics: Type.Array(TypeHex()),
-              }),
-            ),
-            status: TypeHex({
-              description: "0x1 for success, 0x0 for failure",
-            }),
-            blockHash: TypeHex(),
-            blockNumber: TypeHex(),
-            gasUsed: TypeHex(),
-            transactionHash: TypeHex(),
-          }),
-        ),
-      ),
-    }),
-  },
-  {
-    description:
-      "This method is used to get the status of calls IDs returned from wallet_sendPreparedCalls.",
-  },
-);

package/src/rpc/schema.ts

@@ -1,40 +0,0 @@
-import { type Static, type StaticDecode } from "@sinclair/typebox";
-import { RpcSchema } from "ox";
-import * as Requests from "./request.js";
-
-export const WalletServerRpcSchema = RpcSchema.from<
-  | Static<typeof Requests.wallet_prepareCalls>
-  | StaticDecode<typeof Requests.wallet_sendPreparedCalls>
-  | Static<typeof Requests.wallet_createAccount>
-  | Static<typeof Requests.wallet_requestAccount>
-  | Static<typeof Requests.wallet_listAccounts>
-  | Static<typeof Requests.wallet_createSession>
-  | Static<typeof Requests.wallet_getCallsStatus>
->();
-
-export type WalletServerRpcSchemaType = typeof WalletServerRpcSchema;
-
-type MethodToViemRpcSchema = {
-  [K in WalletServerRpcSchemaType["Request"]["method"]]: {
-    Method: K;
-    Parameters: Extract<
-      WalletServerRpcSchemaType["Request"],
-      { method: K }
-    >["params"];
-    ReturnType: Extract<
-      WalletServerRpcSchemaType,
-      { Request: { method: K } }
-    >["ReturnType"];
-  };
-};
-
-// TODO: figure out how we can do this without manually listing all the methods
-export type WalletServerViemRpcSchema = [
-  MethodToViemRpcSchema["wallet_createAccount"],
-  MethodToViemRpcSchema["wallet_requestAccount"],
-  MethodToViemRpcSchema["wallet_listAccounts"],
-  MethodToViemRpcSchema["wallet_prepareCalls"],
-  MethodToViemRpcSchema["wallet_sendPreparedCalls"],
-  MethodToViemRpcSchema["wallet_getCallsStatus"],
-  MethodToViemRpcSchema["wallet_createSession"],
-];