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

package/src/isomorphic/utils/7702.ts

@@ -1,143 +0,0 @@
-import type { SmartAccountClient, SmartContractAccount } from "@aa-sdk/core";
-import {
-  concatHex,
-  numberToHex,
-  type Address,
-  type Chain,
-  type Transport,
-  isAddress,
-  hexToNumber,
-} from "viem";
-import type { WalletServerViemRpcSchema } from "../../rpc/schema.js";
-import { PreparedCall_Authorization } from "../../schemas.js";
-import type { Eip7702AuthCapability } from "../../capabilities/eip7702Auth.ts";
-import type { Static } from "@sinclair/typebox";
-import { InvalidRequestError } from "ox/RpcResponse";
-import { hashAuthorization } from "viem/utils";
-
-/** Checks if an address is actively delegated on-chain. */
-export const isDelegated = async (
-  client: SmartAccountClient<
-    Transport,
-    Chain,
-    SmartContractAccount | undefined,
-    Record<string, unknown>,
-    WalletServerViemRpcSchema
-  >,
-  params: { address: Address; delegation: Address },
-): Promise<boolean> => {
-  const expectedCode = concatHex(["0xef0100", params.delegation]);
-  const code = (await client.getCode({ address: params.address })) ?? "0x";
-  return code.toLowerCase() === expectedCode.toLowerCase();
-};
-
-export const createAuthorizationRequest = async (
-  client: SmartAccountClient<
-    Transport,
-    Chain,
-    SmartContractAccount | undefined,
-    Record<string, unknown>,
-    WalletServerViemRpcSchema
-  >,
-  params: { address: Address; delegation: Address },
-): Promise<Static<typeof PreparedCall_Authorization>> => {
-  const data = {
-    address: params.delegation,
-    nonce: numberToHex(
-      await client.getTransactionCount({
-        address: params.address,
-      }),
-    ),
-  };
-  return {
-    type: "authorization" as const,
-    data,
-    chainId: numberToHex(client.chain.id),
-    signatureRequest: {
-      type: "eip7702Auth" as const,
-      rawPayload: hashAuthorization({
-        chainId: client.chain.id,
-        nonce: hexToNumber(data.nonce),
-        address: params.delegation,
-      }),
-    },
-  };
-};
-
-export const EIP_7702_ACCOUNT_TYPE = ["ModularAccountV2"] as const;
-
-type Supported7702AccountType = (typeof EIP_7702_ACCOUNT_TYPE)[number];
-
-const Eip7702AccountTypeToDelegationAddress = {
-  ModularAccountV2: "0x69007702764179f14F51cdce752f4f775d74E139",
-} as const satisfies Record<Supported7702AccountType, Address>;
-
-const DelegationAddressToAccountType: Record<
-  Address,
-  Supported7702AccountType
-> = Object.fromEntries(
-  Object.entries(Eip7702AccountTypeToDelegationAddress).map(([key, value]) => [
-    value,
-    key,
-  ]),
-) as Record<Address, Supported7702AccountType>;
-
-export const SUPPORTED_DELEGATION_ADDRESSES = Object.values(
-  Eip7702AccountTypeToDelegationAddress,
-);
-
-export const isSupportedDelegationAddress7702 = (address: Address): boolean => {
-  return (SUPPORTED_DELEGATION_ADDRESSES as Address[]).includes(address);
-};
-
-export const getAccountTypeForDelegationAddress7702 = (
-  address: Address,
-): Supported7702AccountType | undefined => {
-  return DelegationAddressToAccountType[address];
-};
-
-const getDelegationAddressForAccountType7702 = (
-  accountType: Supported7702AccountType,
-): (typeof SUPPORTED_DELEGATION_ADDRESSES)[number] => {
-  return Eip7702AccountTypeToDelegationAddress[accountType];
-};
-
-const DEFAULT_7702_DELEGATION_ADDR =
-  Eip7702AccountTypeToDelegationAddress["ModularAccountV2"];
-
-export const parseDelegation = (
-  eip7702AuthCapability: Static<typeof Eip7702AuthCapability>,
-) => {
-  return eip7702AuthCapability === true
-    ? DEFAULT_7702_DELEGATION_ADDR
-    : isAddress(eip7702AuthCapability.delegation)
-      ? eip7702AuthCapability.delegation
-      : getDelegationAddressForAccountType7702(
-          eip7702AuthCapability.delegation,
-        );
-};
-
-export const assertValid7702AccountAddress = (
-  fromAddress: Address,
-  eip7702AuthCapability: Static<typeof Eip7702AuthCapability> | undefined,
-) => {
-  if (eip7702AuthCapability) {
-    if (
-      typeof eip7702AuthCapability === "object" &&
-      "account" in eip7702AuthCapability &&
-      eip7702AuthCapability?.account !== fromAddress
-    ) {
-      throw new InvalidRequestError({
-        message: `EIP-7702 delegation account ${eip7702AuthCapability.account} must match 'from' address ${fromAddress}.`,
-      });
-    }
-
-    const delegation = parseDelegation(eip7702AuthCapability);
-
-    if (!isSupportedDelegationAddress7702(delegation)) {
-      throw new InvalidRequestError({
-        message: `Unsupported 7702 delegation address: ${delegation}`,
-      });
-    }
-  }
-};

package/src/isomorphic/utils/createAccount.ts

@@ -1,170 +0,0 @@
-import type { SmartAccountSigner, SmartContractAccount } from "@aa-sdk/core";
-import {
-  createLightAccount,
-  createModularAccountV2,
-  createMultiOwnerLightAccount,
-  createMultiOwnerModularAccount,
-  type ModularAccountV2,
-} from "@account-kit/smart-contracts";
-import type { StaticDecode } from "@sinclair/typebox";
-import type { Address, Chain, Transport } from "viem";
-import { concatHex, hexToBigInt, hexToNumber, zeroAddress } from "viem";
-import type { TypeSerializedInitcode } from "../../schemas.js";
-import { parsePermissionsContext } from "./parsePermissionsContext.js";
-import { assertNever } from "../../utils.js";
-import { getAccountTypeForDelegationAddress7702 } from "./7702.js";
-import { PermissionsCapability } from "../../capabilities/permissions/index.js";
-import { InternalError, InvalidRequestError } from "ox/RpcResponse";
-
-type CreateAccountParams = {
-  chain: Chain;
-  transport: Transport;
-  signer: SmartAccountSigner;
-  accountAddress: Address;
-  counterfactualInfo?: StaticDecode<typeof TypeSerializedInitcode>; // undefined for 7702 accounts
-  permissions?: StaticDecode<typeof PermissionsCapability>;
-  delegation?: Address;
-};
-
-/**
- * Creates a smart account instance from the given parameters.
- * @param params - The parameters for creating a smart account.
- * @returns A promise that resolves to the created smart account.
- */
-export async function createAccount(
-  params: CreateAccountParams,
-): Promise<SmartContractAccount> {
-  const { counterfactualInfo: ci, ...accountParams } = params;
-
-  // This throws if we pass a permission context and the account is not MA-v2
-  // TODO: test that this edge case is handled correctly
-  const parsedContext = parsePermissionsContext(
-    params.permissions,
-    ci,
-    params.delegation,
-  );
-
-  const signerEntity =
-    parsedContext?.contextVersion === "NON_DEFERRED_ACTION"
-      ? {
-          entityId: hexToNumber(parsedContext.entityId),
-          isGlobalValidation: parsedContext.isGlobalValidation,
-        }
-      : undefined;
-
-  const mode = params.delegation ? "7702" : "default";
-
-  if (mode === "7702") {
-    const accountType = getAccountTypeForDelegationAddress7702(
-      params.delegation!,
-    );
-    if (accountType !== "ModularAccountV2") {
-      throw new Error("7702 mode currently only supports ModularAccountV2");
-    }
-    return createModularAccountV2({
-      ...accountParams,
-      signerEntity,
-      deferredAction: parsedContext?.deferredAction,
-      mode,
-    });
-  }
-
-  if (mode !== "default") {
-    return assertNever(mode, "Unexpected mode in createAccount");
-  }
-
-  // At this point, we are guaranteed to be in default mode, where ci
-  // (counterfactualInfo) must be defined
-
-  if (!ci) {
-    throw new InternalError({
-      message: "Counterfactual info not found",
-    });
-  }
-
-  const factoryType = ci.factoryType;
-  const commonParams = {
-    ...accountParams,
-    initCode: concatHex([ci.factoryAddress, ci.factoryData]),
-  };
-
-  // Return the account created based on the factory type
-  switch (factoryType) {
-    case "MAv2.0.0-sma-b":
-      return createModularAccountV2({
-        ...commonParams,
-        signerEntity,
-        deferredAction: parsedContext?.deferredAction,
-        mode,
-      });
-    case "LightAccountV2.0.0":
-      return createLightAccount({
-        ...commonParams,
-        version: "v2.0.0",
-      });
-    case "LightAccountV1.0.1":
-      return createLightAccount({
-        ...commonParams,
-        version: "v1.0.1",
-      });
-    case "LightAccountV1.0.2":
-      return createLightAccount({
-        ...commonParams,
-        version: "v1.0.2",
-      });
-    case "LightAccountV1.1.0":
-      return createLightAccount({
-        ...commonParams,
-        version: "v1.1.0",
-      });
-    case "MAv1.0.0-MultiOwner":
-      return createMultiOwnerModularAccount({
-        ...commonParams,
-      });
-    case "LightAccountV2.0.0-MultiOwner":
-      return createMultiOwnerLightAccount({
-        ...commonParams,
-        version: "v2.0.0",
-      });
-    case "MAv1.0.0-MultiSig":
-    case "MAv2.0.0-ma-ssv":
-    case "MAv2.0.0-ma-webauthn":
-    case "unknown":
-    case undefined:
-      throw new InvalidRequestError({
-        message: `Account type currently unsupported: ${factoryType}`,
-      });
-    default:
-      return assertNever(factoryType, "Unsupported factory type");
-  }
-}
-
-export function isModularAccountV2(
-  account: SmartContractAccount,
-): account is ModularAccountV2 {
-  return account.source === "ModularAccountV2";
-}
-
-// Performs basic checks on the initialOwners array and returns a new array with the signer address added if not present.
-// Pulled from MAv1 support in Account Kit.
-export function prepareInitialOwners(
-  initialOwners: Address[],
-  signerAddress: Address,
-): Address[] {
-  const preparedOwners = Array.from(
-    new Set([...initialOwners, signerAddress]),
-  ).sort((a, b) => {
-    const bigintA = hexToBigInt(a);
-    const bigintB = hexToBigInt(b);
-
-    return bigintA < bigintB ? -1 : bigintA > bigintB ? 1 : 0;
-  });
-
-  if (preparedOwners.some((x) => x === zeroAddress)) {
-    throw new InvalidRequestError({
-      message: "Initial owners cannot contain the zero address",
-    });
-  }
-
-  return preparedOwners;
-}

package/src/isomorphic/utils/createDummySigner.ts

@@ -1,27 +0,0 @@
-import { type SmartAccountSigner } from "@aa-sdk/core";
-import type { TypedData } from "abitype";
-import {
-  BaseError,
-  type Address,
-  type Hex,
-  type SignableMessage,
-  type TypedDataDefinition,
-} from "viem";
-
-export const createDummySigner = (address: Address): SmartAccountSigner => ({
-  signerType: "",
-  inner: undefined,
-  getAddress: async function (): Promise<`0x${string}`> {
-    return address;
-  },
-  // Not supported on the server
-  signMessage: function (_message: SignableMessage): Promise<Hex> {
-    throw new BaseError("signMessage not implemented by dummy signer.");
-  },
-  signTypedData: function <
-    const TTypedData extends TypedData | Record<string, unknown>,
-    TPrimaryType extends keyof TTypedData | "EIP712Domain" = keyof TTypedData,
-  >(_params: TypedDataDefinition<TTypedData, TPrimaryType>): Promise<Hex> {
-    throw new BaseError("signTypedData not implemented by dummy signer.");
-  },
-});

package/src/isomorphic/utils/decodeSignature.ts

@@ -1,18 +0,0 @@
-import { Value } from "@sinclair/typebox/value";
-import type { Static, StaticDecode } from "@sinclair/typebox";
-import { TypeEcdsaSig } from "../../schemas.js";
-import { assertNever } from "../../utils.js";
-
-export const decodeSignature = (
-  signature: Static<typeof TypeEcdsaSig>["signature"],
-): StaticDecode<typeof TypeEcdsaSig>["signature"] => {
-  switch (signature.type) {
-    case "ecdsa":
-    case "secp256k1":
-      return Value.Decode(TypeEcdsaSig, { signature } satisfies Static<
-        typeof TypeEcdsaSig
-      >).signature;
-    default:
-      return assertNever(signature, "Unexpected signature type");
-  }
-};

package/src/isomorphic/utils/parsePermissionsContext.ts

@@ -1,49 +0,0 @@
-import type { StaticDecode } from "@sinclair/typebox";
-import { InvalidRequestError } from "ox/RpcResponse";
-import { decodePermissionsContext } from "../../capabilities/permissions/mav2.js";
-import type { TypeSerializedInitcode } from "../../schemas.js";
-import type { Address } from "viem";
-import { getAccountTypeForDelegationAddress7702 } from "./7702.js";
-import { PermissionsCapability } from "../../capabilities/permissions/index.js";
-
-export function parsePermissionsContext(
-  permissions?: StaticDecode<typeof PermissionsCapability>,
-  parsedCi?: StaticDecode<typeof TypeSerializedInitcode> | undefined,
-  delegation7702?: Address,
-) {
-  if (!permissions) {
-    return undefined;
-  }
-
-  if ("sessionId" in permissions) {
-    throw new InvalidRequestError({
-      message: "Remote permissions are not supported in isomorphic client",
-    });
-  }
-
-  if (!("context" in permissions)) {
-    return undefined;
-  }
-
-  const isMAV2 =
-    (parsedCi && parsedCi.factoryType === "MAv2.0.0-sma-b") ||
-    (delegation7702 &&
-      getAccountTypeForDelegationAddress7702(delegation7702) ===
-        "ModularAccountV2");
-
-  if (!isMAV2) {
-    throw new InvalidRequestError({
-      message: "Permissions are currently only supported by MAv2 accounts",
-    });
-  }
-
-  const context = decodePermissionsContext(permissions);
-
-  if (context?.contextVersion === "REMOTE_MODE_DEFERRED_ACTION") {
-    throw new InvalidRequestError({
-      message: "Remote mode deferred action not supported in isomorphic client",
-    });
-  }
-
-  return context;
-}

package/src/isomorphic/utils/supportsFeature.ts

@@ -1,34 +0,0 @@
-import type { StaticDecode } from "@sinclair/typebox";
-import type { TypeSerializedInitcode } from "../../schemas.ts";
-
-export type Feature = "permissions";
-
-type FactoryType = StaticDecode<typeof TypeSerializedInitcode>["factoryType"];
-
-const supportedFeatures: Record<FactoryType, Feature[]> = {
-  "LightAccountV1.0.1": [],
-  "LightAccountV1.0.2": [],
-  "LightAccountV1.1.0": [],
-  "LightAccountV2.0.0": [],
-  "LightAccountV2.0.0-MultiOwner": [],
-  "MAv1.0.0-MultiOwner": [],
-  "MAv1.0.0-MultiSig": [],
-  "MAv2.0.0-sma-b": ["permissions"],
-  "MAv2.0.0-ma-ssv": ["permissions"],
-  "MAv2.0.0-ma-webauthn": [],
-  unknown: [],
-};
-
-export function supportsFeature(
-  counterfactualInfo: StaticDecode<typeof TypeSerializedInitcode>,
-  feature: Feature,
-): boolean {
-  const factorySupportedFeatures =
-    supportedFeatures[counterfactualInfo.factoryType];
-  if (factorySupportedFeatures === undefined) {
-    throw new Error(
-      "Unsupported FactoryType: " + counterfactualInfo.factoryType,
-    );
-  }
-  return factorySupportedFeatures.includes(feature);
-}

package/src/local/client.ts

@@ -1,136 +0,0 @@
-import { split } from "@aa-sdk/core";
-import { buildDeferredActionDigest } from "@account-kit/smart-contracts/experimental";
-import { createClient, custom, type Address } from "viem";
-import {
-  encodePermissionsContext,
-  prefixSignatureKeyType,
-} from "../capabilities/permissions/mav2.js";
-import { signSignatureRequest } from "../client/actions/signSignatureRequest.js";
-import { internalStateDecorator } from "../internal/decorator.js";
-import type { PrepareCallsParams } from "../isomorphic/actions/prepareCalls.ts";
-import {
-  createIsomorphicClient,
-  type IsomorphicClient,
-} from "../isomorphic/client.js";
-import type {
-  CreateInnerClientParams,
-  InnerClientActions,
-  InnerWalletApiClient,
-} from "../types.ts";
-import { assertNever } from "../utils.js";
-
-const localMethods = [
-  "wallet_prepareCalls",
-  "wallet_sendPreparedCalls",
-  "wallet_getCallsStatus",
-  "wallet_createSession",
-] as const satisfies string[];
-type LocalMethod = (typeof localMethods)[number];
-
-export function createLocalClient<
-  TAccount extends Address | undefined = Address | undefined,
->(params: CreateInnerClientParams<TAccount>): InnerWalletApiClient;
-
-export function createLocalClient(
-  params: CreateInnerClientParams,
-): InnerWalletApiClient {
-  const { chain, transport, policyId, account } = params;
-  const isomorphicClient = createIsomorphicClient({
-    transport,
-    chain,
-    policyId,
-    useErc7677middleware: false,
-  });
-
-  const clientMap: Record<string, ReturnType<typeof createIsomorphicClient>> = {
-    [policyId ?? "default"]: isomorphicClient,
-  };
-
-  const innerTransport = split({
-    overrides: [
-      {
-        methods: localMethods,
-        transport: custom(
-          {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            async request(args: { method: LocalMethod; params: any }) {
-              switch (args.method) {
-                case "wallet_prepareCalls": {
-                  const params = args.params[0] as PrepareCallsParams;
-                  const capabilityPolicyId =
-                    params.capabilities?.paymasterService?.policyId;
-
-                  if (
-                    capabilityPolicyId != null &&
-                    policyId !== capabilityPolicyId &&
-                    !clientMap[capabilityPolicyId]
-                  ) {
-                    clientMap[capabilityPolicyId] = createIsomorphicClient({
-                      transport,
-                      chain,
-                      policyId: capabilityPolicyId,
-                    });
-                  }
-
-                  const client =
-                    clientMap[capabilityPolicyId ?? policyId ?? "default"];
-                  return client.prepareCalls(params);
-                }
-                case "wallet_sendPreparedCalls":
-                  return isomorphicClient.sendPreparedCalls(args.params[0]);
-                case "wallet_getCallsStatus":
-                  return isomorphicClient.getCallsStatus(args.params[0]);
-                case "wallet_createSession": {
-                  return isomorphicClient.createSession(args.params[0]);
-                }
-                default:
-                  return assertNever(
-                    args.method,
-                    `Unexpected method: ${args.method}`,
-                  );
-              }
-            },
-          },
-          {
-            retryCount: 0,
-          },
-        ),
-      },
-    ],
-    fallback: transport,
-  });
-
-  return createClient({
-    transport: innerTransport,
-    chain,
-    account,
-  })
-    .extend(() => ({
-      policyId,
-      ...innerClientActions(isomorphicClient),
-    }))
-    .extend(() => ({
-      internal: internalStateDecorator(),
-    }));
-}
-
-const innerClientActions = (
-  isomorphicClient: IsomorphicClient,
-): InnerClientActions => {
-  return {
-    grantPermissions: async (signer, params) => {
-      const { signatureRequest, fullPreSignatureDeferredActionDigest } =
-        await isomorphicClient.createSession(params);
-      const signature = await signSignatureRequest(signer, signatureRequest);
-      return {
-        context: encodePermissionsContext({
-          contextVersion: "LOCAL_MODE_DEFERRED_ACTION",
-          deferredAction: buildDeferredActionDigest({
-            fullPreSignatureDeferredActionDigest,
-            sig: prefixSignatureKeyType(signature.data, signature.type),
-          }),
-        }),
-      };
-    },
-  };
-};

package/src/remote/client.ts

@@ -1,67 +0,0 @@
-import { Provider } from "ox";
-import { createClient, custom, type Address } from "viem";
-import { encodePermissionsContext } from "../capabilities/permissions/mav2.js";
-import { signSignatureRequest } from "../client/actions/signSignatureRequest.js";
-import { internalStateDecorator } from "../internal/decorator.js";
-import { WalletServerRpcSchema } from "../rpc/schema.js";
-import type {
-  CreateInnerClientParams,
-  InnerClientActions,
-  InnerWalletApiClient,
-  InnerWalletApiClientBase,
-} from "../types.ts";
-
-/**
- * This is a low-level client just used to make RPC requests in remote mode
- * This should be wrapped by a higher-level smart account client that provides actions
- * that uses this client under the hood
- * @returns
- */
-export function createRemoteClient<
-  TAccount extends Address | undefined = Address | undefined,
->(params: CreateInnerClientParams<TAccount>): InnerWalletApiClient;
-
-export function createRemoteClient(
-  params: CreateInnerClientParams,
-): InnerWalletApiClient {
-  const { transport, chain, account } = params;
-
-  const client = createClient({
-    transport: (opts) =>
-      custom(Provider.from(transport(opts), { schema: WalletServerRpcSchema }))(
-        opts,
-      ),
-    chain,
-    account,
-  })
-    .extend((_client) => ({
-      policyId: params.policyId,
-      ...innerClientActions(_client),
-    }))
-    .extend(() => ({
-      internal: internalStateDecorator(),
-    }));
-
-  return client;
-}
-
-const innerClientActions = (
-  apiClient: InnerWalletApiClientBase,
-): InnerClientActions => {
-  return {
-    grantPermissions: async (signer, params) => {
-      const { sessionId, signatureRequest } = await apiClient.request({
-        method: "wallet_createSession",
-        params: [params],
-      });
-      const signature = await signSignatureRequest(signer, signatureRequest);
-      return {
-        context: encodePermissionsContext({
-          contextVersion: "REMOTE_MODE_DEFERRED_ACTION",
-          sessionId,
-          signature: signature.data,
-        }),
-      };
-    },
-  };
-};