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

package/src/isomorphic/utils/7702.ts

@@ -1,135 +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 "@alchemy/wallet-api-types/rpc";
-import {
-  Eip7702AccountTypeToDelegationAddress,
-  SUPPORTED_DELEGATION_ADDRESSES,
-  type Supported7702AccountType,
-  type Eip7702AuthCapability,
-} from "@alchemy/wallet-api-types/capabilities";
-import type { PreparedCall_Authorization } from "@alchemy/wallet-api-types";
-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<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 DelegationAddressToAccountType: Record<
-  Address,
-  Supported7702AccountType
-> = Object.fromEntries(
-  Object.entries(Eip7702AccountTypeToDelegationAddress).map(([key, value]) => [
-    value,
-    key,
-  ]),
-) as Record<Address, Supported7702AccountType>;
-
-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: Eip7702AuthCapability,
-) => {
-  return eip7702AuthCapability === true
-    ? DEFAULT_7702_DELEGATION_ADDR
-    : isAddress(eip7702AuthCapability.delegation)
-      ? eip7702AuthCapability.delegation
-      : getDelegationAddressForAccountType7702(
-          eip7702AuthCapability.delegation,
-        );
-};
-
-export const assertValid7702AccountAddress = (
-  fromAddress: Address,
-  eip7702AuthCapability: 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/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,21 +0,0 @@
-import { Value } from "@sinclair/typebox/value";
-import type { StaticDecode } from "@sinclair/typebox";
-import {
-  TypeEcdsaSig,
-  type TypeEcdsaSig as TypeEcdsaSigType,
-} from "@alchemy/wallet-api-types";
-import { assertNever } from "../../utils.js";
-
-export const decodeSignature = (
-  signature: TypeEcdsaSigType["signature"],
-): StaticDecode<typeof TypeEcdsaSig>["signature"] => {
-  switch (signature.type) {
-    case "ecdsa":
-    case "secp256k1":
-      return Value.Decode(TypeEcdsaSig, {
-        signature,
-      } satisfies TypeEcdsaSigType).signature;
-    default:
-      return assertNever(signature, "Unexpected signature type");
-  }
-};

package/src/isomorphic/utils/parsePermissionsContext.ts

@@ -1,51 +0,0 @@
-import type { StaticDecode } from "@sinclair/typebox";
-import { InvalidRequestError } from "ox/RpcResponse";
-import type { Address } from "viem";
-import { getAccountTypeForDelegationAddress7702 } from "./7702.js";
-import {
-  decodePermissionsContext,
-  PermissionsCapability,
-} from "@alchemy/wallet-api-types/capabilities";
-import { TypeSerializedInitcode } from "@alchemy/wallet-api-types";
-
-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 "@alchemy/wallet-api-types";
-
-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 "@alchemy/wallet-api-types/capabilities";
-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 "@alchemy/wallet-api-types/capabilities";
-import { WalletServerRpcSchema } from "@alchemy/wallet-api-types/rpc";
-import { signSignatureRequest } from "../client/actions/signSignatureRequest.js";
-import { internalStateDecorator } from "../internal/decorator.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,
-        }),
-      };
-    },
-  };
-};