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

package/dist/types/schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/schemas.ts"],"names":[],"mappings":"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"}

package/src/capabilities/eip7702Auth.ts

@@ -1,26 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import { TypeAddress } from "../schemas.js";
-import {
-  EIP_7702_ACCOUNT_TYPE,
-  SUPPORTED_DELEGATION_ADDRESSES,
-} from "../isomorphic/utils/7702.js";
-
-export const Eip7702AuthCapability = Type.Union([
-  Type.Object(
-    {
-      account: Type.Optional(TypeAddress),
-      // Wallet applications must maintain a strict shortlist of well-known accounts.
-      // https://github.com/ethereum/ERCs/pull/947/files#diff-dab085f963ca621595044bcbc0922705aa38b69f5bf8770dcb3d0496a633efcfR189
-      delegation: Type.Union([
-        ...SUPPORTED_DELEGATION_ADDRESSES.map((address) =>
-          Type.Literal(address),
-        ),
-        ...EIP_7702_ACCOUNT_TYPE.map((it) => Type.Literal(it)),
-      ]),
-    },
-    {
-      description: "Specify EIP-7702 delegation",
-    },
-  ),
-  Type.Literal(true, { description: "Default EIP-7702 delegation" }),
-]);

package/src/capabilities/index.ts

@@ -1,12 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import { GasParamsOverrideCapability } from "./overrides.js";
-import { PaymasterCapability } from "./paymaster.js";
-import { PermissionsCapability } from "./permissions/index.js";
-import { Eip7702AuthCapability } from "./eip7702Auth.js";
-
-export const Capabilities = Type.Object({
-  permissions: Type.Optional(PermissionsCapability),
-  paymasterService: Type.Optional(PaymasterCapability),
-  gasParamsOverride: Type.Optional(GasParamsOverrideCapability),
-  eip7702Auth: Type.Optional(Eip7702AuthCapability),
-});

package/src/capabilities/overrides.ts

@@ -1,35 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import { TypeHex } from "../schemas.js";
-
-export const Mutliplier = Type.Object(
-  { multiplier: Type.Number() },
-  { description: "Multiplier" },
-);
-
-// This is still being defined in https://github.com/ethereum/ERCs/pull/947/files#diff-dab085f963ca621595044bcbc0922705aa38b69f5bf8770dcb3d0496a633efcfR158
-export const GasParamsOverrideCapability = Type.Object(
-  {
-    preVerificationGas: Type.Optional(
-      Type.Union([TypeHex({ description: "Absolute" }), Mutliplier]),
-    ),
-    verificationGasLimit: Type.Optional(
-      Type.Union([TypeHex({ description: "Absolute" }), Mutliplier]),
-    ),
-    callGasLimit: Type.Optional(
-      Type.Union([TypeHex({ description: "Absolute" }), Mutliplier]),
-    ),
-    paymasterVerificationGasLimit: Type.Optional(
-      Type.Union([TypeHex({ description: "Absolute" }), Mutliplier]),
-    ),
-    paymasterPostOpGasLimit: Type.Optional(
-      Type.Union([TypeHex({ description: "Absolute" }), Mutliplier]),
-    ),
-    maxFeePerGas: Type.Optional(
-      Type.Union([TypeHex({ description: "Absolute" }), Mutliplier]),
-    ),
-    maxPriorityFeePerGas: Type.Optional(
-      Type.Union([TypeHex({ description: "Absolute" }), Mutliplier]),
-    ),
-  },
-  { minProperties: 1 },
-);

package/src/capabilities/paymaster.ts

@@ -1,5 +0,0 @@
-import { Type } from "@sinclair/typebox";
-
-export const PaymasterCapability = Type.Object({
-  policyId: Type.String(),
-});

package/src/capabilities/permissions/index.ts

@@ -1,163 +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, title: `${typeString}` },
-    ),
-  )
-    .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(),
-  },
-  {
-    description: "Permissions context",
-  },
-);
-
-export const RemotePermission = Type.Object(
-  {
-    sessionId: TypeHex(),
-    signature: TypeHex(),
-  },
-  {
-    description: "Remote permission",
-  },
-);
-
-export const PermissionsData = Type.Object({
-  chainId: TypeHex(),
-  expirySec: Type.Optional(
-    Type.Integer({
-      maximum: 9999999999, // This is valid until November 20, 2286.
-      description: "Unix timestamp in seconds (0 for no expiry)",
-    }),
-  ),
-  key: KeySigner,
-  permissions: PermissionsArray,
-});
-
-export const PermissionsCapability = Type.Union([
-  PermissionsContext,
-  RemotePermission,
-  // TODO: support permissions object here instead of only context-encoded permissions
-  // PermissionsData,
-]);

package/src/capabilities/permissions/mav2.ts

@@ -1,138 +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 { KeySigner } from "../../schemas.ts";
-import { assertNever } from "../../utils.js";
-import type { PermissionsCapability, PermissionsData } from "./index.ts";
-
-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 = (
-  capability: Static<typeof PermissionsCapability>,
-): DecodedPermissionsContext => {
-  if (!("context" in capability)) {
-    return {
-      contextVersion: "REMOTE_MODE_DEFERRED_ACTION",
-      sessionId: capability.sessionId,
-      signature: capability.signature,
-    };
-  }
-
-  const input = capability.context;
-
-  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 "ecdsa":
-    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/client/actions/createAccount.ts

@@ -1,53 +0,0 @@
-import type { SmartAccountSigner } from "@aa-sdk/core";
-import type { Static } from "@sinclair/typebox";
-import type { Address } from "abitype";
-import type { wallet_createAccount } from "../../rpc/request.ts";
-import type { InnerWalletApiClient } from "../../types.ts";
-
-export type CreateAccountParams = Omit<
-  Extract<
-    Static<typeof wallet_createAccount>["Request"]["params"][0],
-    { signerAddress: Address }
-  >,
-  "signerAddress"
->;
-
-export type CreateAccountResult = Static<
-  typeof wallet_createAccount
->["ReturnType"];
-
-/**
- * Creates a new account for the provided signer using the wallet API client.
- * This method is primarily used to import existing accounts.
- * For most cases, you should use requestAccount instead.
- * If the account already exists, an error will be thrown.
- *
- * @param {InnerWalletApiClient} client - The wallet API client to use for the request
- * @param {SmartAccountSigner} signer - The signer that will be associated with the account
- * @param {CreateAccountParams} params - Parameters for creating the account
- * @param {string} [params.id] - Optional UUID v4 identifier for the account
- * @param {object} params.creationOptions - Options for account creation
- * @param {string} [params.creationOptions.accountType] - Currently only "sma-b" (Modular Account v2) is supported
- * @param {string} [params.creationOptions.salt] - Optional hex string to use as salt for account creation
- * @returns {Promise<CreateAccountResult>} A Promise that resolves to the created account information
- *
- * @example
- * // Create a new account with a custom salt
- * const account = await client.createAccount({
- *   creationOptions: {
- *     accountType: "sma-b",
- *     salt: "0x04"
- *   }
- * });
- * console.log(`Created account at address: ${account.accountAddress}`);
- */
-export async function createAccount(
-  client: InnerWalletApiClient,
-  signer: SmartAccountSigner,
-  params: CreateAccountParams,
-): Promise<CreateAccountResult> {
-  return client.request({
-    method: "wallet_createAccount",
-    params: [{ signerAddress: await signer.getAddress(), ...params }],
-  });
-}