@aa-sdk/core 4.0.0-alpha.0

package/src/client/decorators/smartAccountClient.ts

@@ -0,0 +1,177 @@
+import {
+  type Address,
+  type Chain,
+  type Client,
+  type Hex,
+  type SendTransactionParameters,
+  type Transport,
+  type TypedData,
+} from "viem";
+import type {
+  GetAccountParameter,
+  GetEntryPointFromAccount,
+  SmartContractAccount,
+} from "../../account/smartContractAccount";
+import { buildUserOperation } from "../../actions/smartAccount/buildUserOperation.js";
+import { buildUserOperationFromTx } from "../../actions/smartAccount/buildUserOperationFromTx.js";
+import { buildUserOperationFromTxs } from "../../actions/smartAccount/buildUserOperationFromTxs.js";
+import { checkGasSponsorshipEligibility } from "../../actions/smartAccount/checkGasSponsorshipEligibility.js";
+import { dropAndReplaceUserOperation } from "../../actions/smartAccount/dropAndReplaceUserOperation.js";
+import { getAddress } from "../../actions/smartAccount/getAddress.js";
+import { sendTransaction } from "../../actions/smartAccount/sendTransaction.js";
+import { sendTransactions } from "../../actions/smartAccount/sendTransactions.js";
+import { sendUserOperation } from "../../actions/smartAccount/sendUserOperation.js";
+import {
+  signMessage,
+  type SignMessageParameters,
+} from "../../actions/smartAccount/signMessage.js";
+import { signMessageWith6492 } from "../../actions/smartAccount/signMessageWith6492.js";
+import {
+  signTypedData,
+  type SignTypedDataParameters,
+} from "../../actions/smartAccount/signTypedData.js";
+import { signTypedDataWith6492 } from "../../actions/smartAccount/signTypedDataWith6492.js";
+import { signUserOperation } from "../../actions/smartAccount/signUserOperation.js";
+import type {
+  BuildTransactionParameters,
+  BuildUserOperationFromTransactionsResult,
+  BuildUserOperationParameters,
+  DropAndReplaceUserOperationParameters,
+  SendTransactionsParameters,
+  SendUserOperationParameters,
+  SignUserOperationParameters,
+  UpgradeAccountParams,
+  UserOperationContext,
+  WaitForUserOperationTxParameters,
+} from "../../actions/smartAccount/types";
+import { upgradeAccount } from "../../actions/smartAccount/upgradeAccount.js";
+import { waitForUserOperationTransaction } from "../../actions/smartAccount/waitForUserOperationTransacation.js";
+import type {
+  UserOperationOverrides,
+  UserOperationRequest,
+  UserOperationStruct,
+} from "../../types";
+import type { IsUndefined } from "../../utils";
+import type { SendUserOperationResult } from "../types";
+
+//#region SmartAccountClientActions
+export type BaseSmartAccountClientActions<
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined,
+  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
+> = {
+  buildUserOperation: (
+    args: BuildUserOperationParameters<TAccount, TContext>
+  ) => Promise<UserOperationStruct<TEntryPointVersion>>;
+  buildUserOperationFromTx: (
+    args: SendTransactionParameters<TChain, TAccount>,
+    overrides?: UserOperationOverrides<TEntryPointVersion>,
+    context?: TContext
+  ) => Promise<UserOperationStruct<TEntryPointVersion>>;
+  buildUserOperationFromTxs: (
+    args: BuildTransactionParameters<TAccount, TContext>
+  ) => Promise<BuildUserOperationFromTransactionsResult<TEntryPointVersion>>;
+  checkGasSponsorshipEligibility: <
+    TContext extends UserOperationContext | undefined =
+      | UserOperationContext
+      | undefined
+  >(
+    args: SendUserOperationParameters<TAccount, TContext>
+  ) => Promise<boolean>;
+  signUserOperation: (
+    args: SignUserOperationParameters<TAccount, TEntryPointVersion, TContext>
+  ) => Promise<UserOperationRequest<TEntryPointVersion>>;
+  dropAndReplaceUserOperation: (
+    args: DropAndReplaceUserOperationParameters<TAccount, TContext>
+  ) => Promise<SendUserOperationResult<TEntryPointVersion>>;
+  // TODO: for v4 we should combine override and context into an `opts` parameter
+  // which wraps both of these properties so we can use GetContextParameter
+  sendTransaction: <TChainOverride extends Chain | undefined = undefined>(
+    args: SendTransactionParameters<TChain, TAccount, TChainOverride>,
+    overrides?: UserOperationOverrides<TEntryPointVersion>,
+    context?: TContext
+  ) => Promise<Hex>;
+  sendTransactions: (
+    args: SendTransactionsParameters<TAccount, TContext>
+  ) => Promise<Hex>;
+  sendUserOperation: (
+    args: SendUserOperationParameters<
+      TAccount,
+      TContext,
+      GetEntryPointFromAccount<TAccount>
+    >
+  ) => Promise<SendUserOperationResult<TEntryPointVersion>>;
+  waitForUserOperationTransaction: (
+    args: WaitForUserOperationTxParameters
+  ) => Promise<Hex>;
+  upgradeAccount: (
+    args: UpgradeAccountParams<TAccount, TContext>
+  ) => Promise<Hex>;
+  signMessage: (args: SignMessageParameters<TAccount>) => Promise<Hex>;
+  signTypedData: <
+    const TTypedData extends TypedData | { [key: string]: unknown },
+    TPrimaryType extends string = string
+  >(
+    args: SignTypedDataParameters<TTypedData, TPrimaryType, TAccount>
+  ) => Promise<Hex>;
+  signMessageWith6492: (args: SignMessageParameters<TAccount>) => Promise<Hex>;
+  signTypedDataWith6492: <
+    const TTypedData extends TypedData | { [key: string]: unknown },
+    TPrimaryType extends string = string
+  >(
+    args: SignTypedDataParameters<TTypedData, TPrimaryType, TAccount>
+  ) => Promise<Hex>;
+} & (IsUndefined<TAccount> extends false
+  ? { getAddress: () => Address }
+  : {
+      getAddress: (args: GetAccountParameter<TAccount>) => Address;
+    });
+// #endregion SmartAccountClientActions
+
+export const smartAccountClientActions: <
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>
+) => BaseSmartAccountClientActions<TChain, TAccount, TContext> = (client) => ({
+  buildUserOperation: (args) => buildUserOperation(client, args),
+  buildUserOperationFromTx: (args, overrides, context) =>
+    buildUserOperationFromTx(client, args, overrides, context),
+  buildUserOperationFromTxs: (args) => buildUserOperationFromTxs(client, args),
+  checkGasSponsorshipEligibility: (args) =>
+    checkGasSponsorshipEligibility(client, args),
+  signUserOperation: (args) => signUserOperation(client, args),
+  dropAndReplaceUserOperation: (args) =>
+    dropAndReplaceUserOperation(client, args),
+  sendTransaction: (args, overrides, context) =>
+    sendTransaction(client, args, overrides, context),
+  sendTransactions: (args) => sendTransactions(client, args),
+  sendUserOperation: (args) => sendUserOperation(client, args),
+  waitForUserOperationTransaction: (args) =>
+    waitForUserOperationTransaction.bind(client)(client, args),
+  upgradeAccount: (args) => upgradeAccount(client, args),
+  getAddress: (args) => getAddress(client, args),
+  signMessage: (args) => signMessage(client, args),
+  signTypedData: (args) => signTypedData(client, args),
+  signMessageWith6492: (args) => signMessageWith6492(client, args),
+  signTypedDataWith6492: (args) => signTypedDataWith6492(client, args),
+});
+
+export const smartAccountClientMethodKeys = Object.keys(
+  // @ts-expect-error we just want to get the keys
+  smartAccountClientActions(undefined)
+).reduce((accum, curr) => {
+  accum.add(curr);
+  return accum;
+}, new Set<string>());

package/src/client/isSmartAccountClient.ts

@@ -0,0 +1,53 @@
+import type { Chain, Client, Transport } from "viem";
+import type { SmartContractAccount } from "../account/smartContractAccount";
+import { smartAccountClientMethodKeys } from "./decorators/smartAccountClient.js";
+import type {
+  BaseSmartAccountClient,
+  SmartAccountClient,
+} from "./smartAccountClient";
+
+/**
+ * Use this method to assert that a client is a BaseSmartAccountClient.
+ * Useful for narrowing the type of the client down when used within the
+ * smart account client decorators
+ *
+ * @param client a viem client
+ * @returns true if the client is a SmartAccountClient
+ */
+export function isSmartAccountClient<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>
+): client is SmartAccountClient<TTransport, TChain, TAccount> {
+  for (const key of smartAccountClientMethodKeys) {
+    if (!(key in client)) {
+      return false;
+    }
+  }
+
+  return client && "middleware" in client;
+}
+
+/**
+ * Use this method to assert that a client is a BaseSmartAccountClient.
+ * Useful for narrowing the type of the client down when used within the
+ * smart account action decorators
+ *
+ * @param client a viem client
+ * @returns true if the account is a BaseSmartAccountClient
+ */
+export function isBaseSmartAccountClient<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>
+): client is BaseSmartAccountClient<TTransport, TChain, TAccount> {
+  return client && "middleware" in client;
+}

package/src/client/schema.ts

@@ -0,0 +1,92 @@
+import type { Transport } from "viem";
+import { z } from "zod";
+
+import { BigNumberishRangeSchema, MultiplierSchema } from "../utils/index.js";
+import type { BundlerClient } from "./bundlerClient.js";
+
+export const createPublicErc4337ClientSchema = <
+  TTransport extends Transport = Transport
+>() =>
+  z.custom<BundlerClient<TTransport>>((provider) => {
+    return (
+      provider != null &&
+      typeof provider === "object" &&
+      "request" in provider &&
+      "type" in provider &&
+      "key" in provider &&
+      "name" in provider
+    );
+  });
+
+// [!region ConnectionConfigSchema]
+export const ConnectionConfigSchema = z.union([
+  z.object({
+    rpcUrl: z.never().optional(),
+    apiKey: z.string(),
+    jwt: z.never().optional(),
+  }),
+  z.object({
+    rpcUrl: z.never().optional(),
+    apiKey: z.never().optional(),
+    jwt: z.string(),
+  }),
+  z.object({
+    rpcUrl: z.string(),
+    apiKey: z.never().optional(),
+    jwt: z.never().optional(),
+  }),
+  z.object({
+    rpcUrl: z.string(),
+    apiKey: z.never().optional(),
+    jwt: z.string(),
+  }),
+]);
+// [!endregion ConnectionConfigSchema]
+
+export const UserOperationFeeOptionsFieldSchema =
+  BigNumberishRangeSchema.merge(MultiplierSchema).partial();
+
+export const UserOperationFeeOptionsSchema_v6 = z
+  .object({
+    maxFeePerGas: UserOperationFeeOptionsFieldSchema,
+    maxPriorityFeePerGas: UserOperationFeeOptionsFieldSchema,
+    callGasLimit: UserOperationFeeOptionsFieldSchema,
+    verificationGasLimit: UserOperationFeeOptionsFieldSchema,
+    preVerificationGas: UserOperationFeeOptionsFieldSchema,
+  })
+  .partial()
+  .strict();
+
+export const UserOperationFeeOptionsSchema_v7 =
+  UserOperationFeeOptionsSchema_v6.extend({
+    paymasterVerificationGasLimit: UserOperationFeeOptionsFieldSchema,
+    paymasterPostOpGasLimit: UserOperationFeeOptionsFieldSchema,
+  })
+    .partial()
+    .strict();
+
+export const UserOperationFeeOptionsSchema = UserOperationFeeOptionsSchema_v7;
+
+export const SmartAccountClientOptsSchema = z
+  .object({
+    /**
+     * The maximum number of times to try fetching a transaction receipt before giving up (default: 5)
+     */
+    txMaxRetries: z.number().min(0).optional().default(5),
+
+    /**
+     * The interval in milliseconds to wait between retries while waiting for tx receipts (default: 2_000)
+     */
+    txRetryIntervalMs: z.number().min(0).optional().default(2_000),
+
+    /**
+     * The multiplier on interval length to wait between retries while waiting for tx receipts (default: 1.5)
+     */
+    txRetryMultiplier: z.number().min(0).optional().default(1.5),
+
+    /**
+     * Optional user operation fee options to be set globally at the provider level
+     */
+    feeOptions: UserOperationFeeOptionsSchema.optional(),
+  })
+  .strict();

package/src/client/smartAccountClient.ts

@@ -0,0 +1,276 @@
+import {
+  custom,
+  type Chain,
+  type Client,
+  type ClientConfig,
+  type CustomTransport,
+  type FormattedTransactionRequest,
+  type PublicActions,
+  type PublicRpcSchema,
+  type RpcSchema,
+  type Transport,
+} from "viem";
+import { z } from "zod";
+import type { SmartContractAccount } from "../account/smartContractAccount.js";
+import type { UserOperationContext } from "../actions/smartAccount/types.js";
+import { AccountNotFoundError } from "../errors/account.js";
+import { ChainNotFoundError } from "../errors/client.js";
+import { middlewareActions } from "../middleware/actions.js";
+import type { ClientMiddleware } from "../middleware/types.js";
+import type { Prettify } from "../utils/index.js";
+import { createBundlerClient, type BundlerClient } from "./bundlerClient.js";
+import {
+  type BundlerActions,
+  type BundlerRpcSchema,
+} from "./decorators/bundlerClient.js";
+import {
+  smartAccountClientActions,
+  type BaseSmartAccountClientActions,
+} from "./decorators/smartAccountClient.js";
+import { SmartAccountClientOptsSchema } from "./schema.js";
+import type { ClientMiddlewareConfig } from "./types.js";
+
+type SmartAccountClientOpts = z.output<typeof SmartAccountClientOptsSchema>;
+
+export type SmartAccountClientConfig<
+  transport extends Transport = Transport,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  context extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+> = Prettify<
+  Pick<
+    ClientConfig<transport, chain, account>,
+    | "cacheTime"
+    | "chain"
+    | "key"
+    | "name"
+    | "pollingInterval"
+    | "transport"
+    | "type"
+  > & {
+    account?: account;
+    opts?: z.input<typeof SmartAccountClientOptsSchema>;
+  } & ClientMiddlewareConfig<context>
+>;
+
+export type SmartAccountClientRpcSchema = [
+  ...BundlerRpcSchema,
+  ...PublicRpcSchema
+];
+
+//#region SmartAccountClientActions
+export type SmartAccountClientActions<
+  chain extends Chain | undefined = Chain | undefined,
+  account extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  context extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+> = BaseSmartAccountClientActions<chain, account, context> &
+  BundlerActions &
+  PublicActions;
+//#endregion SmartAccountClientActions
+
+//#region SmartAccountClient
+export type SmartAccountClient<
+  transport extends Transport = Transport,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  actions extends Record<string, unknown> = Record<string, unknown>,
+  rpcSchema extends RpcSchema = SmartAccountClientRpcSchema,
+  context extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+> = Prettify<
+  Client<
+    transport,
+    chain,
+    account,
+    rpcSchema,
+    actions & SmartAccountClientActions<chain, account, context>
+  >
+>;
+//#endregion SmartAccountClient
+
+export type BaseSmartAccountClient<
+  transport extends Transport = Transport,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  context extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+> = Prettify<
+  Client<
+    transport,
+    chain,
+    account,
+    [...BundlerRpcSchema, ...PublicRpcSchema],
+    {
+      middleware: ClientMiddleware<context>;
+    } & SmartAccountClientOpts &
+      BundlerActions &
+      PublicActions
+  >
+>;
+
+export function createSmartAccountClient<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+>(
+  config: SmartAccountClientConfig<TTransport, TChain, TAccount, TContext>
+): SmartAccountClient<TTransport, TChain, TAccount>;
+
+export function createSmartAccountClient(
+  config: SmartAccountClientConfig
+): SmartAccountClient {
+  const {
+    key = "account",
+    name = "account provider",
+    transport,
+    type = "SmartAccountClient",
+    ...params
+  } = config;
+
+  const client: SmartAccountClient = createBundlerClient({
+    ...params,
+    key,
+    name,
+    // we start out with this because the base methods for a SmartAccountClient
+    // require a smart account client, but once we have completed building everything
+    // we want to override this value with the one passed in by the extender
+    type: "SmartAccountClient",
+    // TODO: this needs to be tested
+    transport: (opts) => {
+      const rpcTransport = transport(opts);
+
+      return custom({
+        async request({ method, params }) {
+          switch (method) {
+            case "eth_sendTransaction":
+              if (!client.account) {
+                throw new AccountNotFoundError();
+              }
+              if (!client.chain) {
+                throw new ChainNotFoundError();
+              }
+              const [tx] = params as [FormattedTransactionRequest];
+              return client.sendTransaction({
+                ...tx,
+                account: client.account,
+                chain: client.chain,
+              });
+            case "eth_sign":
+              if (!client.account) {
+                throw new AccountNotFoundError();
+              }
+              const [address, data] = params!;
+              if (address !== client.account.address) {
+                throw new Error(
+                  "cannot sign for address that is not the current account"
+                );
+              }
+              return client.signMessage(data);
+            case "personal_sign": {
+              if (!client.account) {
+                throw new AccountNotFoundError();
+              }
+              const [data, address] = params!;
+              if (address !== client.account.address) {
+                throw new Error(
+                  "cannot sign for address that is not the current account"
+                );
+              }
+              return client.signMessage(data);
+            }
+            case "eth_signTypedData_v4": {
+              if (!client.account) {
+                throw new AccountNotFoundError();
+              }
+              const [address, dataParams] = params!;
+              if (address !== client.account.address) {
+                throw new Error(
+                  "cannot sign for address that is not the current account"
+                );
+              }
+              return client.signTypedData(dataParams);
+            }
+            case "eth_chainId":
+              if (!opts.chain) {
+                throw new ChainNotFoundError();
+              }
+
+              return opts.chain.id;
+            default:
+              // TODO: there's probably a number of methods we just don't support, will need to test most of them out
+              // first let's get something working though
+              return rpcTransport.request({ method, params });
+          }
+        },
+      })(opts);
+    },
+  })
+    .extend(() => ({
+      ...SmartAccountClientOptsSchema.parse(config.opts ?? {}),
+    }))
+    .extend(middlewareActions(config))
+    .extend(smartAccountClientActions);
+
+  return { ...client, type };
+}
+
+export function createSmartAccountClientFromExisting<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  TClient extends BundlerClient<TTransport> = BundlerClient<TTransport>,
+  TActions extends SmartAccountClientActions<
+    TChain,
+    TAccount,
+    TContext
+  > = SmartAccountClientActions<TChain, TAccount>,
+  TRpcSchema extends SmartAccountClientRpcSchema = SmartAccountClientRpcSchema,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+>(
+  config: Omit<
+    SmartAccountClientConfig<Transport, TChain, TAccount, TContext>,
+    "transport" | "chain"
+  > & { client: TClient }
+): SmartAccountClient<
+  CustomTransport,
+  TChain,
+  TAccount,
+  TActions,
+  TRpcSchema,
+  TContext
+>;
+
+export function createSmartAccountClientFromExisting(
+  config: Omit<SmartAccountClientConfig, "transport" | "chain"> & {
+    client: BundlerClient;
+  }
+): SmartAccountClient {
+  return createSmartAccountClient({
+    ...config,
+    chain: config.client.chain,
+    transport: custom(config.client),
+  });
+}

package/src/client/types.ts

@@ -0,0 +1,51 @@
+import type { Address } from "abitype";
+import type { Hash, Hex } from "viem";
+import type { z } from "zod";
+import type { UserOperationContext } from "../actions/smartAccount/types.js";
+import type { EntryPointVersion } from "../entrypoint/types.js";
+import type {
+  ClientMiddleware,
+  ClientMiddlewareFn,
+} from "../middleware/types.js";
+import type { UserOperationRequest } from "../types.js";
+import type { ConnectionConfigSchema } from "./schema.js";
+
+export type ConnectorData = {
+  chainId?: Hex;
+};
+
+export type ConnectionConfig = z.input<typeof ConnectionConfigSchema>;
+
+// [!region SendUserOperationResult]
+export type SendUserOperationResult<
+  TEntryPointVersion extends EntryPointVersion = EntryPointVersion
+> = {
+  hash: Hash;
+  request: UserOperationRequest<TEntryPointVersion>;
+};
+// [!endregion SendUserOperationResult]
+
+// [!region UpgradeToData]
+export type UpgradeToData = {
+  implAddress: Address;
+  initializationData: Hex;
+};
+// [!endregion UpgradeToData]
+
+// [!region ClientMiddlewareConfig]
+export type ClientMiddlewareConfig<
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+> = Omit<
+  Partial<ClientMiddleware<TContext>>,
+  "dummyPaymasterAndData" | "paymasterAndData"
+> & {
+  paymasterAndData?: {
+    dummyPaymasterAndData: () =>
+      | UserOperationRequest<"0.6.0">["paymasterAndData"]
+      | Pick<UserOperationRequest<"0.7.0">, "paymaster" | "paymasterData">;
+    paymasterAndData: ClientMiddlewareFn<TContext>;
+  };
+};
+// [!endregion ClientMiddlewareConfig]

package/src/ens/utils.ts

@@ -0,0 +1,37 @@
+import type { Chain } from "viem/chains";
+import * as chains from "viem/chains";
+import { mainnet } from "../chains/index.js";
+
+export const ChainsById: Map<number, chains.Chain> = new Map(
+  Object.values(chains).map((x) => [x.id, x])
+);
+
+export const convertChainIdToCoinType = (chainId: number): number => {
+  if (chainId === mainnet.id) {
+    // this comes from [ensip-9](https://docs.ens.domains/ens-improvement-proposals/ensip-9-multichain-address-resolution)
+    return 60;
+  }
+
+  // this is using [ENSIP-11](https://docs.ens.domains/ens-improvement-proposals/ensip-11-evmchain-address-resolution) and assumes this is how mappings are stored for non mainnet chains
+  return (0x80000000 | chainId) >>> 0;
+};
+
+export const convertCoinTypeToChainId = (coinType: number): number => {
+  if (coinType === 60) {
+    // this comes from [ensip-9](https://docs.ens.domains/ens-improvement-proposals/ensip-9-multichain-address-resolution)
+    return mainnet.id;
+  }
+
+  // this is using [ENSIP-11](https://docs.ens.domains/ens-improvement-proposals/ensip-11-evmchain-address-resolution) and assumes this is how mappings are stored for non mainnet chains
+  return (0x7fffffff & coinType) >> 0;
+};
+
+export const convertCoinTypeToChain = (coinType: number): Chain => {
+  const chainId = convertCoinTypeToChainId(coinType);
+  const chain = ChainsById.get(chainId);
+  if (!chain) {
+    throw new Error("CoinType does not map to a supported chain");
+  }
+
+  return chain;
+};