alchemy 0.69.1 → 0.70.0

package/src/coinbase/evm-smart-account.ts

@@ -0,0 +1,339 @@
+import type { Context } from "../context.ts";
+import { Resource } from "../resource.ts";
+import { createCdpClient, type CoinbaseClientOptions } from "./client.ts";
+import type { EvmAccount } from "./evm-account.ts";
+import type {
+  Address,
+  FaucetConfig,
+  FaucetNetwork,
+  FaucetToken,
+} from "./types.ts";
+import { validateAccountName } from "./utils.ts";
+
+export interface EvmSmartAccountProps extends CoinbaseClientOptions {
+  /**
+   * Name for the smart account.
+   * If not provided, inherits the name from the owner account.
+   * This allows EOA and Smart Account to have matching names in CDP.
+   * Used for identification in CDP.
+   * Must contain only letters, numbers, and hyphens.
+   * @default Inherits from owner account name
+   */
+  name?: string;
+  /**
+   * The owner account that controls this smart account.
+   * Can be either an EvmAccount resource or an owner address.
+   */
+  owner: EvmAccount | Address;
+  /**
+   * Whether to adopt an existing smart account with the same name if it already exists.
+   * Without adoption, creation will fail if a smart account with the same name exists.
+   * With adoption, the existing smart account will be used.
+   * @default false
+   */
+  adopt?: boolean;
+  /**
+   * Faucet configuration for development funding.
+   * Declares which tokens this smart account should have.
+   * Used by external funding scripts - not processed by the resource.
+   *
+   * @example
+   * ```ts
+   * faucet: {
+   *   "base-sepolia": ["eth", "usdc"],
+   *   "ethereum-sepolia": ["eth"]
+   * }
+   * ```
+   */
+  faucet?: FaucetConfig;
+}
+
+export interface EvmSmartAccount
+  extends Resource<"coinbase::evm-smart-account"> {
+  /**
+   * The smart account name in CDP
+   */
+  name: string;
+  /**
+   * The smart account address (same across all EVM networks)
+   */
+  address: Address;
+  /**
+   * The owner account address
+   */
+  ownerAddress: Address;
+  /**
+   * Faucet configuration (passed through from props)
+   */
+  faucet?: FaucetConfig;
+}
+
+/**
+ * Manages ERC-4337 smart accounts on Coinbase Developer Platform.
+ * Smart accounts enable gasless transactions and advanced features like batch operations.
+ *
+ * @example
+ * ## Create a smart account with an EVM account owner
+ *
+ * ```ts
+ * const owner = await EvmAccount("owner", {
+ *   name: "owner-account"
+ * });
+ *
+ * const smartAccount = await EvmSmartAccount("my-smart-account", {
+ *   name: "my-smart-account",
+ *   owner: owner
+ * });
+ *
+ * console.log("Smart account address:", smartAccount.address);
+ * ```
+ *
+ * @example
+ * ## Create a smart account with existing owner
+ *
+ * ```ts
+ * const smartAccount = await EvmSmartAccount("my-smart-account", {
+ *   name: "my-smart-account",
+ *   owner: "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb" // Owner address
+ * });
+ * ```
+ *
+ * @example
+ * ## Smart account with inherited name
+ *
+ * When name is omitted, the smart account inherits the owner's name
+ *
+ * ```ts
+ * const owner = await EvmAccount("owner", {
+ *   name: "my-app-wallet"
+ * });
+ *
+ * // Smart account will also be named "my-app-wallet" in CDP
+ * const smartAccount = await EvmSmartAccount("smart", {
+ *   owner: owner
+ *   // name is omitted, inherits "my-app-wallet" from owner
+ * });
+ *
+ * console.log(smartAccount.name); // "my-app-wallet"
+ * ```
+ *
+ * @example
+ * ## Adopt an existing smart account
+ *
+ * ```ts
+ * const smartAccount = await EvmSmartAccount("my-smart-account", {
+ *   name: "existing-smart-account",
+ *   owner: ownerAccount, // or "0x..." address
+ *   adopt: true // Uses existing smart account if it exists
+ * });
+ * ```
+ */
+export const EvmSmartAccount = Resource(
+  "coinbase::evm-smart-account",
+  async function (
+    this: Context<EvmSmartAccount>,
+    _id: string,
+    props: EvmSmartAccountProps,
+  ): Promise<EvmSmartAccount> {
+    // Initialize CDP client with credentials from props or environment
+    const cdp = await createCdpClient({
+      apiKeyId: props.apiKeyId,
+      apiKeySecret: props.apiKeySecret,
+      walletSecret: props.walletSecret,
+    });
+
+    // Get owner address
+    const ownerAddress =
+      typeof props.owner === "string" ? props.owner : props.owner.address;
+
+    // Get owner account for CDP operations
+    // When owner is an address string, we use it to get the account
+    const ownerAccount =
+      typeof props.owner === "string"
+        ? await cdp.evm.getAccount({ address: props.owner })
+        : await cdp.evm.getAccount({ address: props.owner.address });
+
+    // If no name provided, inherit from owner
+    // this mean that if you pass only { owner } the created smartAccount will be same name as the EOA owner
+    // this to support https://github.com/base/account-sdk/blob/master/packages/account-sdk/src/interface/payment/charge.ts#L120
+    let accountName = props.name ? props.name : ownerAccount.name;
+    if (!accountName) {
+      throw new Error(
+        `Smart account requires a name. Either provide 'name' in props or ensure the owner account has a name. Owner address: ${ownerAddress}`,
+      );
+    }
+
+    // Validate account name format
+    validateAccountName(accountName);
+
+    // Handle update phase
+    if (this.phase === "update" && this.output) {
+      // Check if owner changed (which would require replacement)
+      if (ownerAddress !== this.output.ownerAddress) {
+        this.replace();
+      }
+      // Check if name changed
+      if (accountName !== this.output.name) {
+        await cdp.evm.updateSmartAccount({
+          address: this.output.address,
+          owner: ownerAccount,
+          update: {
+            name: accountName,
+          },
+        });
+
+        return {
+          ...this.output,
+          name: accountName,
+          // faucet: props.faucet, not sure we need this?
+        };
+      }
+      // Update faucet configuration if changed
+      if (JSON.stringify(props.faucet) !== JSON.stringify(this.output.faucet)) {
+        // Only fund NEW combinations that weren't in the previous config
+        try {
+          // Get all old combinations
+          const oldCombinations = new Set(
+            Object.entries(this.output.faucet ?? {}).flatMap(
+              ([network, tokens]) =>
+                tokens.map((token) => `${network}:${token}`),
+            ),
+          );
+
+          // Get all new combinations
+          const newCombinations = Object.entries(props.faucet ?? {}).flatMap(
+            ([network, tokens]) =>
+              tokens.map((token) => ({
+                network: network as FaucetNetwork,
+                token: token as FaucetToken,
+                key: `${network}:${token}`,
+              })),
+          );
+
+          // Filter to only combinations that are actually new
+          const toFund = newCombinations.filter(
+            ({ key }) => !oldCombinations.has(key),
+          );
+
+          if (toFund.length > 0) {
+            await Promise.all(
+              toFund.map(({ network, token }) =>
+                cdp.evm
+                  .requestFaucet({
+                    address: this.output.address,
+                    network,
+                    token,
+                  })
+                  .catch((err) => {
+                    console.warn(
+                      `⚠️ Failed to request ${token} on ${network} for smart account ${this.output.address}: ${err.message}`,
+                    );
+                    return null;
+                  }),
+              ),
+            );
+
+            console.log(
+              `💧 Requested ${toFund.length} new faucet fund${toFund.length === 1 ? "" : "s"} for smart account ${this.output.address}`,
+            );
+          }
+        } catch (error: any) {
+          console.warn(
+            `⚠️ Failed to request additional faucet funds for smart account ${this.output.address}: ${error.message}`,
+          );
+          // Continue - don't break the update
+        }
+
+        return {
+          ...this.output,
+          faucet: props.faucet,
+        };
+      }
+      return this.output;
+    }
+
+    // Handle delete phase
+    if (this.phase === "delete") {
+      // CDP SDK doesn't support deleting accounts
+      // Accounts remain in CDP but are no longer tracked by Alchemy
+      console.log(`🗑️ Untracking Smart Account: ${this.output?.address}`);
+      return this.destroy();
+    }
+
+    let smartAccount;
+
+    // Check for adoption or use getOrCreate pattern
+    const adopt = props.adopt ?? this.scope.adopt;
+    if (adopt) {
+      // With adoption, use getOrCreateSmartAccount which returns existing if it exists
+      smartAccount = await cdp.evm.getOrCreateSmartAccount({
+        name: accountName,
+        owner: ownerAccount,
+      });
+    } else {
+      // Without adoption, create a new smart account
+      try {
+        smartAccount = await cdp.evm.createSmartAccount({
+          name: accountName,
+          owner: ownerAccount,
+        });
+      } catch (error: any) {
+        // Provide helpful error message if smart account already exists
+        if (error.errorType === "already_exists") {
+          throw new Error(
+            `Smart account with name '${accountName}' already exists. Use adopt: true to use the existing smart account.`,
+          );
+        }
+        // Rethrow other errors unchanged
+        throw error;
+      }
+    }
+
+    // Fund the smart account if faucet configuration is provided
+    if (props.faucet) {
+      try {
+        const combinations = Object.entries(props.faucet).flatMap(
+          ([network, tokens]) =>
+            tokens.map((token) => ({
+              network: network as FaucetNetwork,
+              token: token as FaucetToken,
+            })),
+        );
+
+        await Promise.all(
+          combinations.map(({ network, token }) =>
+            cdp.evm
+              .requestFaucet({
+                address: smartAccount.address,
+                network,
+                token,
+              })
+              .catch((err) => {
+                console.warn(
+                  `⚠️ Failed to request ${token} on ${network} for smart account ${smartAccount.address}: ${err.message}`,
+                );
+                return null;
+              }),
+          ),
+        );
+
+        console.log(
+          `💧 Requested faucet funds for smart account ${smartAccount.address}`,
+        );
+      } catch (error: any) {
+        console.warn(
+          `⚠️ Failed to request faucet funds for smart account ${smartAccount.address}: ${error.message}`,
+        );
+        // Continue - don't break account creation
+      }
+    }
+
+    // Return smart account details
+    return {
+      name: accountName,
+      address: smartAccount.address,
+      ownerAddress,
+      faucet: props.faucet,
+    } as EvmSmartAccount;
+  },
+);

package/src/coinbase/faucet.ts

@@ -0,0 +1,173 @@
+#!/usr/bin/env bun
+/**
+ * Request testnet tokens from Coinbase faucet for accounts with faucet metadata
+ *
+ * Usage:
+ *   bun node_modules/alchemy/src/coinbase/faucet.ts              # Fund all accounts with faucet config
+ *   bun node_modules/alchemy/src/coinbase/faucet.ts dev          # Fund only accounts in dev scope
+ *   bun node_modules/alchemy/src/coinbase/faucet.ts backend/dev  # Fund specific scope
+ */
+
+import { readFile, access } from "node:fs/promises";
+import { join } from "node:path";
+import { glob } from "glob";
+import { createCdpClient } from "./client.ts";
+import type { EvmAccount } from "./evm-account.ts";
+import type { EvmSmartAccount } from "./evm-smart-account.ts";
+import type { FaucetNetwork, FaucetToken } from "./types.ts";
+
+// Track funded combinations to avoid duplicates within this run
+const funded = new Set<string>();
+
+// Get optional scope argument
+const scope = process.argv[2];
+
+// Initialize CDP client (uses CDP_* env vars automatically)
+const cdp = await createCdpClient();
+
+let stateFiles: string[];
+
+if (scope) {
+  // If scope provided, find matching directories
+  const scopePath = join(".alchemy", scope);
+
+  let scopeExists = false;
+  try {
+    await access(scopePath);
+    scopeExists = true;
+  } catch {
+    scopeExists = false;
+  }
+
+  if (scopeExists) {
+    // Exact match found
+    console.log(`Using scope: ${scope}`);
+    stateFiles = await glob("*.json", {
+      cwd: scopePath,
+      absolute: true,
+    });
+  } else {
+    // Try to find directories that end with the provided scope
+    // We need to find directories, so we'll look for JSON files and extract the directory paths
+    const allFiles = await glob(`**/${scope}/*.json`, {
+      cwd: ".alchemy",
+    });
+
+    // Extract unique directory paths
+    const possibleScopes = [
+      ...new Set(allFiles.map((f) => f.replace(/\/[^/]+\.json$/, ""))),
+    ];
+
+    if (possibleScopes.length === 0) {
+      console.error(`No scope found matching: ${scope}`);
+      process.exit(1);
+    } else if (possibleScopes.length === 1) {
+      // Found exactly one match
+      const foundScope = possibleScopes[0];
+      console.log(`Using scope: ${foundScope}`);
+      stateFiles = await glob("*.json", {
+        cwd: join(".alchemy", foundScope),
+        absolute: true,
+      });
+    } else {
+      // Multiple matches found - use all of them
+      console.log(`Found ${possibleScopes.length} scopes matching '${scope}':`);
+      for (const s of possibleScopes) {
+        console.log(`  - ${s}`);
+      }
+
+      // Collect state files from all matching scopes
+      stateFiles = [];
+      for (const foundScope of possibleScopes) {
+        const files = await glob("*.json", {
+          cwd: join(".alchemy", foundScope),
+          absolute: true,
+        });
+        stateFiles.push(...files);
+      }
+    }
+  }
+} else {
+  // No scope provided, search all .alchemy subdirectories
+  console.log("Searching all scopes for accounts with faucet configuration...");
+  stateFiles = await glob("**/*.json", {
+    cwd: ".alchemy",
+    absolute: true,
+  });
+}
+
+const allStates = (
+  await Promise.all(
+    stateFiles.map(async (file) => {
+      try {
+        const content = await readFile(file, "utf-8");
+        return JSON.parse(content);
+      } catch {
+        return null;
+      }
+    }),
+  )
+).filter(Boolean);
+
+const accounts = allStates
+  .filter(
+    (state) =>
+      state?.kind?.startsWith("coinbase::evm") &&
+      state.output &&
+      (state.output as EvmAccount | EvmSmartAccount).faucet,
+  )
+  .map((state) => {
+    const output = state.output as EvmAccount | EvmSmartAccount;
+    return {
+      address: output.address,
+      name: output.name,
+      faucet: output.faucet!,
+    };
+  });
+
+if (accounts.length === 0) {
+  console.log("No accounts with faucet configuration found");
+  process.exit(0);
+}
+
+console.log(`Found ${accounts.length} accounts with faucet configuration\n`);
+
+for (const account of accounts) {
+  console.log(`Account: ${account.name} (${account.address})`);
+
+  for (const [network, tokens] of Object.entries(account.faucet)) {
+    for (const token of tokens) {
+      const key = `${account.address}-${network}-${token}`;
+
+      // Skip if already processed in this run
+      if (funded.has(key)) {
+        console.log(`  ⏭️  Skipping ${token} on ${network} (already requested)`);
+        continue;
+      }
+
+      // Request tokens from faucet
+      try {
+        console.log(`  💧 Requesting ${token} on ${network}...`);
+
+        const response = await cdp.evm.requestFaucet({
+          address: account.address,
+          network: network as FaucetNetwork,
+          token: token as FaucetToken,
+        });
+
+        console.log(`  ✅ Funded: ${response.transactionHash}`);
+        funded.add(key);
+
+        // Small delay to avoid rate limits
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+      } catch (error: any) {
+        console.log(
+          `  ❌ Error funding ${token} on ${network}: ${error.message}`,
+        );
+      }
+    }
+  }
+  console.log();
+}
+
+console.log("✨ Funding complete!");

package/src/coinbase/index.ts

@@ -0,0 +1,3 @@
+export * from "./types.ts";
+export * from "./evm-account.ts";
+export * from "./evm-smart-account.ts";

package/src/coinbase/types.ts

@@ -0,0 +1,33 @@
+/**
+ * Common types for Coinbase CDP resources
+ */
+
+/**
+ * Ethereum address format (20 bytes, 40 hex chars)
+ */
+export type Address = `0x${string}`;
+
+/**
+ * Private key format (32 bytes, 64 hex chars)
+ */
+export type PrivateKey = `0x${string}`;
+
+/**
+ * Transaction hash format (32 bytes, 64 hex chars)
+ */
+export type TransactionHash = `0x${string}`;
+
+/**
+ * Supported testnet networks for faucet requests
+ */
+export type FaucetNetwork = "base-sepolia" | "ethereum-sepolia";
+
+/**
+ * Supported tokens for faucet requests
+ */
+export type FaucetToken = "eth" | "usdc" | "eurc" | "cbbtc";
+
+/**
+ * Faucet configuration for requesting testnet tokens
+ */
+export type FaucetConfig = Partial<Record<FaucetNetwork, FaucetToken[]>>;

package/src/coinbase/utils.ts

@@ -0,0 +1,19 @@
+/**
+ * Utility functions for Coinbase CDP resources
+ */
+
+/**
+ * Validates that a CDP account name follows the required format.
+ * CDP only allows letters, numbers, and hyphens in account names.
+ * Names cannot start or end with a hyphen.
+ *
+ * @param name - The account name to validate
+ * @throws Error if the name contains invalid characters or starts/ends with hyphen
+ */
+export function validateAccountName(name: string): void {
+  if (!/^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/.test(name)) {
+    throw new Error(
+      `Invalid account name '${name}'. CDP only allows letters, numbers, and hyphens. Names cannot start or end with a hyphen.`,
+    );
+  }
+}

package/src/neon/api/types.gen.ts

@@ -1899,6 +1899,7 @@ export type BillingAccountState =
 export type BillingSubscriptionType =
   | "UNKNOWN"
   | "direct_sales"
+  | "direct_sales_v3"
   | "aws_marketplace"
   | "free_v2"
   | "free_v3"
@@ -2527,6 +2528,11 @@ export type NeonAuthCreateIntegrationRequest = {
   role_name?: string;
 };
 
+export type EnableNeonAuthIntegrationRequest = {
+  auth_provider: NeonAuthSupportedAuthProvider;
+  database_name?: string;
+};
+
 export type NeonAuthCreateIntegrationResponse = {
   auth_provider: NeonAuthSupportedAuthProvider;
   auth_provider_project_id: string;
@@ -2677,7 +2683,12 @@ export type RoleOperations = RoleResponse & OperationsResponse;
 
 export type JwksCreationOperation = JwksResponse & OperationsResponse;
 
-export type SupportTicketSeverity = "low" | "normal" | "high" | "critical";
+export type SupportTicketSeverity =
+  | "low"
+  | "normal"
+  | "high"
+  | "critical"
+  | "urgent";
 
 export type AnnotationData = {
   object: AnnotationObjectData;
@@ -2758,6 +2769,7 @@ export type Snapshot = {
   source_branch_id?: string;
   created_at: string;
   expires_at?: string;
+  manual?: boolean;
 };
 
 export type SnapshotUpdateRequest = {

package/src/planetscale/api/types.gen.ts

@@ -514,6 +514,10 @@ export type PaginatedPostgresClusterResizeRequest = {
      * The SKU representing the branch cluster for display
      */
     cluster_display_name: string;
+    /**
+     * Whether or not this is a metal database
+     */
+    cluster_metal: boolean;
     /**
      * The total number of replicas
      */
@@ -532,6 +536,10 @@ export type PaginatedPostgresClusterResizeRequest = {
      * The previous SKU representing the branch cluster for display
      */
     previous_cluster_display_name: string;
+    /**
+     * Whether or not the previous SKU was a metal database
+     */
+    previous_cluster_metal: boolean;
     /**
      * The previous total number of replicas
      */
@@ -652,6 +660,10 @@ export type PostgresClusterResizeRequest = {
    * The SKU representing the branch cluster for display
    */
   cluster_display_name: string;
+  /**
+   * Whether or not this is a metal database
+   */
+  cluster_metal: boolean;
   /**
    * The total number of replicas
    */
@@ -670,6 +682,10 @@ export type PostgresClusterResizeRequest = {
    * The previous SKU representing the branch cluster for display
    */
   previous_cluster_display_name: string;
+  /**
+   * Whether or not the previous SKU was a metal database
+   */
+  previous_cluster_metal: boolean;
   /**
    * The previous total number of replicas
    */
@@ -1301,7 +1317,8 @@ export type PostgresClusterExtension = {
       | "milliseconds"
       | "seconds"
       | "select"
-      | "string";
+      | "string"
+      | "time";
     /**
      * The default value of the parameter
      */
@@ -1408,7 +1425,8 @@ export type PostgresClusterParameter = {
     | "milliseconds"
     | "seconds"
     | "select"
-    | "string";
+    | "string"
+    | "time";
   /**
    * The default value of the parameter
    */
@@ -6943,6 +6961,7 @@ export type PaginatedDatabaseWebhook = {
       | "branch.anomaly"
       | "branch.schema_recommendation"
       | "branch.sleeping"
+      | "branch.start_maintenance"
       | "cluster.storage"
       | "database.access_request"
       | "deploy_request.closed"
@@ -7004,6 +7023,7 @@ export type DatabaseWebhook = {
     | "branch.anomaly"
     | "branch.schema_recommendation"
     | "branch.sleeping"
+    | "branch.start_maintenance"
     | "cluster.storage"
     | "database.access_request"
     | "deploy_request.closed"

package/src/planetscale/api.ts

@@ -67,6 +67,7 @@ export function createPlanetScaleClient(
       headers: {
         Authorization: token, // PlanetScale does not use the Bearer prefix
       },
+      throwOnError: true,
     }),
   );
   client.interceptors.error.use((error, response, request) => {