@openzeppelin/ui-builder-adapter-evm 1.2.0 → 1.4.0

package/src/transaction/sender.ts

@@ -1,185 +0,0 @@
-import type { GetAccountReturnType } from '@wagmi/core';
-import type { TransactionReceipt, WalletClient } from 'viem';
-
-import type { ExecutionConfig } from '@openzeppelin/ui-types';
-import { logger } from '@openzeppelin/ui-utils';
-
-import type { WriteContractParameters } from '../types';
-import type { WagmiWalletImplementation } from '../wallet/implementation/wagmi-implementation';
-
-const SYSTEM_LOG_TAG = 'adapter-evm-sender';
-
-// --- Helper Functions ---
-
-async function _ensureCorrectNetworkOrSwitch(
-  walletImplementation: WagmiWalletImplementation,
-  targetChainId: number
-): Promise<GetAccountReturnType> {
-  const initialAccountStatus = walletImplementation.getWalletConnectionStatus();
-  if (!initialAccountStatus.isConnected || !initialAccountStatus.chainId) {
-    logger.error(
-      SYSTEM_LOG_TAG,
-      'Wallet not connected or chainId unavailable before network check.'
-    );
-    throw new Error('Wallet not connected or chain ID is unavailable.');
-  }
-
-  if (initialAccountStatus.chainId !== targetChainId) {
-    logger.info(
-      SYSTEM_LOG_TAG,
-      `Wallet on chain ${initialAccountStatus.chainId}, target ${targetChainId}. Switching...`
-    );
-    try {
-      await walletImplementation.switchNetwork(targetChainId);
-      const postSwitchAccountStatus = walletImplementation.getWalletConnectionStatus();
-      if (postSwitchAccountStatus.chainId !== targetChainId) {
-        logger.error(
-          SYSTEM_LOG_TAG,
-          `Failed to switch to target chain ${targetChainId}. Current: ${postSwitchAccountStatus.chainId}`
-        );
-        throw new Error(`Failed to switch to the required network (target: ${targetChainId}).`);
-      }
-      logger.info(SYSTEM_LOG_TAG, `Successfully switched to target chain ${targetChainId}.`);
-      return postSwitchAccountStatus;
-    } catch (error) {
-      logger.error(SYSTEM_LOG_TAG, 'Network switch failed:', error);
-      throw error;
-    }
-  }
-  logger.info(SYSTEM_LOG_TAG, 'Wallet already on target chain.');
-  return initialAccountStatus;
-}
-
-async function _getAuthenticatedWalletClient(
-  walletImplementation: WagmiWalletImplementation
-): Promise<{
-  walletClient: WalletClient;
-  accountStatus: GetAccountReturnType;
-}> {
-  const walletClient = await walletImplementation.getWalletClient();
-  if (!walletClient) {
-    logger.error(SYSTEM_LOG_TAG, 'Wallet client not available. Is wallet connected?');
-    throw new Error('Wallet is not connected or client is unavailable.');
-  }
-
-  const accountStatus = walletImplementation.getWalletConnectionStatus();
-  if (!accountStatus.isConnected || !accountStatus.address) {
-    logger.error(SYSTEM_LOG_TAG, 'Account not available. Is wallet connected?');
-    throw new Error('Wallet is not connected or account address is unavailable.');
-  }
-  return { walletClient, accountStatus };
-}
-
-async function _executeEoaTransaction(
-  transactionData: WriteContractParameters,
-  walletClient: WalletClient,
-  accountStatus: GetAccountReturnType
-): Promise<{ txHash: string }> {
-  logger.info(SYSTEM_LOG_TAG, 'Using EOA execution strategy.');
-  try {
-    logger.debug(SYSTEM_LOG_TAG, 'Calling walletClient.writeContract with:', {
-      account: accountStatus.address,
-      address: transactionData.address,
-      abi: transactionData.abi,
-      functionName: transactionData.functionName,
-      args: transactionData.args,
-      value: transactionData.value,
-      chain: walletClient.chain,
-    });
-    const hash = await walletClient.writeContract({
-      account: accountStatus.address!,
-      address: transactionData.address,
-      abi: transactionData.abi,
-      functionName: transactionData.functionName,
-      args: transactionData.args,
-      value: transactionData.value,
-      chain: walletClient.chain,
-    });
-    logger.info(SYSTEM_LOG_TAG, 'EOA Transaction initiated. Hash:', hash);
-    return { txHash: hash };
-  } catch (error: unknown) {
-    logger.error(SYSTEM_LOG_TAG, 'Error during EOA writeContract call:', error);
-    const errorMessage = error instanceof Error ? error.message : 'Unknown EOA transaction error';
-    throw new Error(`Transaction failed (EOA): ${errorMessage}`);
-  }
-}
-
-// --- Main Exported Function ---
-
-export async function signAndBroadcastEvmTransaction(
-  transactionData: WriteContractParameters,
-  walletImplementation: WagmiWalletImplementation,
-  targetChainId: number,
-  executionConfig?: ExecutionConfig
-): Promise<{ txHash: string }> {
-  logger.info(SYSTEM_LOG_TAG, 'Sign & Broadcast EVM Tx:', {
-    data: transactionData,
-    targetChainId,
-    execConfig: executionConfig,
-  });
-
-  const currentMethod = executionConfig?.method || 'eoa';
-
-  await _ensureCorrectNetworkOrSwitch(walletImplementation, targetChainId);
-  const { walletClient, accountStatus } = await _getAuthenticatedWalletClient(walletImplementation);
-
-  switch (currentMethod) {
-    case 'eoa':
-      return _executeEoaTransaction(transactionData, walletClient, accountStatus);
-
-    case 'relayer':
-      logger.warn(SYSTEM_LOG_TAG, 'Relayer execution method not yet implemented.');
-      throw new Error('Relayer execution method not yet implemented.');
-
-    case 'multisig':
-      logger.warn(SYSTEM_LOG_TAG, 'Multisig execution method not yet implemented.');
-      throw new Error('Multisig execution method not yet implemented.');
-
-    default:
-      const exhaustiveCheck: never = currentMethod;
-      logger.error(SYSTEM_LOG_TAG, `Unsupported execution method encountered: ${exhaustiveCheck}`);
-      throw new Error(`Unsupported execution method: ${exhaustiveCheck}`);
-  }
-}
-
-/**
- * Waits for a transaction to be confirmed on the blockchain.
- */
-export async function waitForEvmTransactionConfirmation(
-  txHash: string,
-  walletImplementation: WagmiWalletImplementation
-): Promise<{
-  status: 'success' | 'error';
-  receipt?: TransactionReceipt;
-  error?: Error;
-}> {
-  logger.info(SYSTEM_LOG_TAG, `Waiting for tx: ${txHash}`);
-  try {
-    // Get the public client
-    const resolvedPublicClient = await walletImplementation.getPublicClient();
-    if (!resolvedPublicClient) {
-      throw new Error('Public client not available to wait for transaction.');
-    }
-
-    // Wait for the transaction receipt
-    const receipt = await resolvedPublicClient.waitForTransactionReceipt({
-      hash: txHash as `0x${string}`,
-    });
-
-    logger.info(SYSTEM_LOG_TAG, 'Received receipt:', receipt);
-
-    // Check the status field in the receipt
-    if (receipt.status === 'success') {
-      return { status: 'success', receipt };
-    } else {
-      logger.error(SYSTEM_LOG_TAG, 'Transaction reverted:', receipt);
-      return { status: 'error', receipt, error: new Error('Transaction reverted.') };
-    }
-  } catch (error) {
-    logger.error(SYSTEM_LOG_TAG, 'Error waiting for transaction confirmation:', error);
-    return {
-      status: 'error',
-      error: error instanceof Error ? error : new Error(String(error)),
-    };
-  }
-}

package/src/transform/index.ts

@@ -1,3 +0,0 @@
-// Barrel file for transform module
-export * from './input-parser';
-export * from './output-formatter';

package/src/transform/input-parser.ts

@@ -1,177 +0,0 @@
-import { getAddress, isAddress } from 'viem';
-
-import type { FunctionParameter } from '@openzeppelin/ui-types';
-import { logger } from '@openzeppelin/ui-utils';
-
-/**
- * Recursively parses a raw input value based on its expected ABI type definition.
- *
- * @param param The ABI parameter definition ({ name, type, components?, ... })
- * @param rawValue The raw value obtained from the form input or hardcoded config.
- * @param isRecursive Internal flag to indicate if the call is nested.
- * @returns The parsed and typed value suitable for ABI encoding.
- * @throws {Error} If parsing or type validation fails.
- */
-export function parseEvmInput(
-  param: FunctionParameter,
-  rawValue: unknown,
-  isRecursive = false
-): unknown {
-  const { type, name } = param;
-  const baseType = type.replace(/\[\d*\]$/, ''); // Remove array indicators like `[]` or `[2]`
-  const isArray = type.endsWith(']');
-
-  try {
-    // --- Handle Arrays --- //
-    if (isArray) {
-      // Only expect string at the top level, recursive calls get arrays directly
-      let parsedArray: unknown[];
-      if (!isRecursive) {
-        if (typeof rawValue !== 'string') {
-          throw new Error('Array input must be a JSON string representation.');
-        }
-        try {
-          parsedArray = JSON.parse(rawValue);
-        } catch (e) {
-          throw new Error(`Invalid JSON for array: ${(e as Error).message}`);
-        }
-      } else {
-        // If recursive, rawValue should already be an array
-        if (!Array.isArray(rawValue)) {
-          throw new Error('Internal error: Expected array in recursive call.');
-        }
-        parsedArray = rawValue;
-      }
-
-      if (!Array.isArray(parsedArray)) {
-        // Double check after parsing/assignment
-        throw new Error('Parsed JSON is not an array.');
-      }
-
-      // Recursively parse each element
-      const itemAbiParam = { ...param, type: baseType }; // Create a dummy param for the base type
-      return parsedArray.map((item) => parseEvmInput(itemAbiParam, item, true)); // Pass isRecursive=true
-    }
-
-    // --- Handle Tuples --- //
-    if (baseType === 'tuple') {
-      if (!param.components) {
-        throw new Error(`ABI definition missing 'components' for tuple parameter '${name}'.`);
-      }
-      // Only expect string at the top level, recursive calls get objects directly
-      let parsedObject: Record<string, unknown>;
-      if (!isRecursive) {
-        if (typeof rawValue !== 'string') {
-          throw new Error('Tuple input must be a JSON string representation of an object.');
-        }
-        try {
-          parsedObject = JSON.parse(rawValue);
-        } catch (e) {
-          throw new Error(`Invalid JSON for tuple: ${(e as Error).message}`);
-        }
-      } else {
-        // If recursive, rawValue should already be an object
-        if (typeof rawValue !== 'object' || rawValue === null || Array.isArray(rawValue)) {
-          throw new Error('Internal error: Expected object in recursive tuple call.');
-        }
-        parsedObject = rawValue as Record<string, unknown>; // Cast needed
-      }
-
-      if (
-        typeof parsedObject !== 'object' ||
-        parsedObject === null ||
-        Array.isArray(parsedObject)
-      ) {
-        // Double check
-        throw new Error('Parsed JSON is not an object for tuple.');
-      }
-
-      // Recursively parse each component
-      const resultObject: Record<string, unknown> = {};
-      for (const component of param.components) {
-        if (!(component.name in parsedObject)) {
-          throw new Error(`Missing component '${component.name}' in tuple JSON.`);
-        }
-        resultObject[component.name] = parseEvmInput(
-          component,
-          parsedObject[component.name],
-          true // Pass isRecursive=true
-        );
-      }
-      // Check for extra, unexpected keys in the provided JSON object
-      if (Object.keys(parsedObject).length !== param.components.length) {
-        const expectedKeys = param.components.map((c) => c.name).join(', ');
-        const actualKeys = Object.keys(parsedObject).join(', ');
-        throw new Error(
-          `Tuple object has incorrect number of keys. Expected ${param.components.length} (${expectedKeys}), but got ${Object.keys(parsedObject).length} (${actualKeys}).`
-        );
-      }
-      return resultObject;
-    }
-
-    // --- Handle Bytes --- //
-    if (baseType.startsWith('bytes')) {
-      if (typeof rawValue !== 'string') {
-        throw new Error('Bytes input must be a string.');
-      }
-      if (!/^0x([0-9a-fA-F]{2})*$/.test(rawValue)) {
-        throw new Error(
-          `Invalid hex string format for ${type}: must start with 0x and contain only hex characters.`
-        );
-      }
-      // Check byte length for fixed-size bytes? (e.g., bytes32)
-      const fixedSizeMatch = baseType.match(/^bytes(\d+)$/);
-      if (fixedSizeMatch) {
-        const expectedBytes = parseInt(fixedSizeMatch[1], 10);
-        const actualBytes = (rawValue.length - 2) / 2;
-        if (actualBytes !== expectedBytes) {
-          throw new Error(
-            `Invalid length for ${type}: expected ${expectedBytes} bytes (${expectedBytes * 2} hex chars), got ${actualBytes} bytes.`
-          );
-        }
-      }
-      return rawValue as `0x${string}`; // Already validated, cast to viem type
-    }
-
-    // --- Handle Simple Types --- //
-    if (baseType.startsWith('uint') || baseType.startsWith('int')) {
-      if (rawValue === '' || rawValue === null || rawValue === undefined)
-        throw new Error('Numeric value cannot be empty.');
-      try {
-        // Use BigInt for all integer types
-        return BigInt(rawValue as string | number | bigint);
-      } catch {
-        throw new Error(`Invalid numeric value: '${rawValue}'.`);
-      }
-    } else if (baseType === 'address') {
-      if (typeof rawValue !== 'string' || !rawValue)
-        throw new Error('Address value must be a non-empty string.');
-      if (!isAddress(rawValue)) throw new Error(`Invalid address format: '${rawValue}'.`);
-      return getAddress(rawValue); // Return checksummed address
-    } else if (baseType === 'bool') {
-      if (typeof rawValue === 'boolean') return rawValue;
-      if (typeof rawValue === 'string') {
-        const lowerVal = rawValue.toLowerCase().trim();
-        if (lowerVal === 'true') return true;
-        if (lowerVal === 'false') return false;
-      }
-      // Try simple truthy/falsy conversion as fallback
-      return Boolean(rawValue);
-    } else if (baseType === 'string') {
-      // Ensure it's treated as a string
-      return String(rawValue);
-    }
-
-    // --- Fallback for unknown types --- //
-    logger.warn(
-      'parseEvmInput',
-      `Unknown EVM parameter type encountered: '${type}'. Using raw value.`
-    );
-    return rawValue;
-  } catch (error) {
-    // Add parameter context to the error message
-    throw new Error(
-      `Failed to parse value for parameter '${name || '(unnamed)'}' (type '${type}'): ${(error as Error).message}`
-    );
-  }
-}

package/src/transform/output-formatter.ts

@@ -1,64 +0,0 @@
-import type { ContractFunction } from '@openzeppelin/ui-types';
-import { logger } from '@openzeppelin/ui-utils';
-
-import { stringifyWithBigInt } from '../utils';
-
-/**
- * Formats the decoded result of an EVM view function call into a user-friendly string.
- *
- * @param decodedValue The decoded value (can be primitive, array, object, BigInt).
- * @param functionDetails The ABI details of the function called.
- * @returns A string representation suitable for display.
- */
-export function formatEvmFunctionResult(
-  decodedValue: unknown,
-  functionDetails: ContractFunction
-): string {
-  if (!functionDetails.outputs || !Array.isArray(functionDetails.outputs)) {
-    logger.warn(
-      'formatEvmFunctionResult',
-      `Output ABI definition missing or invalid for function ${functionDetails.name}.`
-    );
-    return '[Error: Output ABI definition missing]';
-  }
-
-  try {
-    let valueToFormat: unknown;
-    // Handle potential array wrapping for single returns from viem
-    if (Array.isArray(decodedValue)) {
-      if (decodedValue.length === 1) {
-        valueToFormat = decodedValue[0]; // Single output, format the inner value
-      } else {
-        // Multiple outputs, format the whole array as JSON
-        valueToFormat = decodedValue;
-      }
-    } else {
-      // Not an array, could be a single value (like from a struct return) or undefined
-      valueToFormat = decodedValue;
-    }
-
-    // Format based on type
-    if (typeof valueToFormat === 'bigint') {
-      return valueToFormat.toString();
-    } else if (
-      typeof valueToFormat === 'string' ||
-      typeof valueToFormat === 'number' ||
-      typeof valueToFormat === 'boolean'
-    ) {
-      return String(valueToFormat);
-    } else if (valueToFormat === null || valueToFormat === undefined) {
-      return '(null)'; // Represent null/undefined clearly
-    } else {
-      // Handles arrays with multiple elements or objects (structs) by stringifying
-      return stringifyWithBigInt(valueToFormat, 2); // Pretty print with 2 spaces
-    }
-  } catch (error) {
-    const errorMessage = `Error formatting result for ${functionDetails.name}: ${(error as Error).message}`;
-    logger.error('formatEvmFunctionResult', errorMessage, {
-      functionName: functionDetails.name,
-      decodedValue,
-      error,
-    });
-    return `[${errorMessage}]`;
-  }
-}

package/src/types/__tests__/artifacts.test.ts

@@ -1,105 +0,0 @@
-/**
- * Unit tests for EVM contract artifacts types and validation
- */
-import { describe, expect, it } from 'vitest';
-
-import { isEvmContractArtifacts, type EvmContractArtifacts } from '../artifacts';
-
-describe('EVM Contract Artifacts', () => {
-  describe('isEvmContractArtifacts', () => {
-    it('should return true for valid artifacts with only contractAddress', () => {
-      const artifacts = {
-        contractAddress: '0x1234567890123456789012345678901234567890',
-      };
-
-      const result = isEvmContractArtifacts(artifacts);
-
-      expect(result).toBe(true);
-    });
-
-    it('should return true for valid artifacts with all optional properties', () => {
-      const artifacts: EvmContractArtifacts = {
-        contractAddress: '0x1234567890123456789012345678901234567890',
-        contractDefinition: '[{"type":"function","name":"test"}]',
-        __proxyDetectionOptions: {
-          skipProxyDetection: true,
-        },
-      };
-
-      const result = isEvmContractArtifacts(artifacts);
-
-      expect(result).toBe(true);
-    });
-
-    it('should return false for null', () => {
-      const result = isEvmContractArtifacts(null);
-      expect(result).toBe(false);
-    });
-
-    it('should return false for undefined', () => {
-      const result = isEvmContractArtifacts(undefined);
-      expect(result).toBe(false);
-    });
-
-    it('should return false for non-object types', () => {
-      expect(isEvmContractArtifacts('string')).toBe(false);
-      expect(isEvmContractArtifacts(123)).toBe(false);
-      expect(isEvmContractArtifacts(true)).toBe(false);
-      expect(isEvmContractArtifacts([])).toBe(false);
-    });
-
-    it('should return false for object without contractAddress', () => {
-      const artifacts = {
-        contractDefinition: '[{"type":"function","name":"test"}]',
-      };
-
-      const result = isEvmContractArtifacts(artifacts);
-
-      expect(result).toBe(false);
-    });
-
-    it('should return false for object with non-string contractAddress', () => {
-      const artifacts = {
-        contractAddress: 123,
-      };
-
-      const result = isEvmContractArtifacts(artifacts);
-
-      expect(result).toBe(false);
-    });
-
-    it('should return true even with extra properties', () => {
-      const artifacts = {
-        contractAddress: '0x1234567890123456789012345678901234567890',
-        extraProperty: 'should be ignored',
-      };
-
-      const result = isEvmContractArtifacts(artifacts);
-
-      expect(result).toBe(true);
-    });
-
-    it('should handle empty contractAddress string', () => {
-      const artifacts = {
-        contractAddress: '',
-      };
-
-      const result = isEvmContractArtifacts(artifacts);
-
-      expect(result).toBe(true); // Type guard only checks type, not validity
-    });
-
-    it('should handle proxy detection options correctly', () => {
-      const artifacts = {
-        contractAddress: '0x1234567890123456789012345678901234567890',
-        __proxyDetectionOptions: {
-          skipProxyDetection: false,
-        },
-      };
-
-      const result = isEvmContractArtifacts(artifacts);
-
-      expect(result).toBe(true);
-    });
-  });
-});

package/src/types.ts

@@ -1,92 +0,0 @@
-import type { Abi, Chain } from 'viem';
-
-import type { EvmNetworkConfig } from '@openzeppelin/ui-types';
-
-/**
- * EVM-specific type definitions
- */
-
-/**
- * EVM-specific network configuration with properly typed viem chain
- * This extends the base EvmNetworkConfig with the correct Chain type from viem
- */
-export interface TypedEvmNetworkConfig extends EvmNetworkConfig {
-  /**
-   * Viem Chain object for this EVM network.
-   * If provided, this will be used directly by Viem clients.
-   * If not provided, a fallback chain object will be created.
-   */
-  viemChain?: Chain;
-}
-
-/**
- * Represents an item in an Ethereum ABI
- */
-export type AbiItem = {
-  type: string;
-  name?: string;
-  inputs?: Array<{
-    name: string;
-    type: string;
-    internalType?: string;
-    indexed?: boolean;
-    components?: Array<{
-      name: string;
-      type: string;
-      internalType?: string;
-      indexed?: boolean;
-    }>;
-  }>;
-  stateMutability?: string;
-  anonymous?: boolean;
-  outputs?: Array<{
-    name: string;
-    type: string;
-    internalType?: string;
-    components?: Array<{
-      name: string;
-      type: string;
-      internalType?: string;
-    }>;
-  }>;
-};
-
-/**
- * EVM-specific parameter types
- */
-export enum EVMParameterType {
-  ADDRESS = 'address',
-  UINT256 = 'uint256',
-  UINT8 = 'uint8',
-  BOOL = 'bool',
-  BYTES = 'bytes',
-  BYTES32 = 'bytes32',
-  STRING = 'string',
-}
-
-/**
- * EVM-specific chain types
- */
-export enum EVMChainType {
-  ETHEREUM = 'ethereum',
-  POLYGON = 'polygon',
-  ARBITRUM = 'arbitrum',
-  OPTIMISM = 'optimism',
-  BSC = 'bsc',
-  AVALANCHE = 'avalanche',
-}
-// Import Viem's Abi type
-
-/**
- * Defines the structure for parameters required to execute a contract write operation via viem.
- */
-export interface WriteContractParameters {
-  address: `0x${string}`; // Ensure address is a valid hex string type
-  abi: Abi;
-  functionName: string;
-  args: unknown[];
-  value?: bigint;
-  // Add other potential viem parameters if needed (e.g., gas)
-}
-
-// Add other adapter-specific internal types here if necessary