@0xsequence/catapult 1.4.0 → 1.5.0

package/src/lib/types/values.ts

@@ -1,221 +0,0 @@
-/**
- * Represents a reference to another value in the scope, e.g., "{{var.name}}".
- * The parser will be responsible for resolving this string into a concrete value.
- */
-export type Reference = string;
-
-// --- Value Resolver Types ---
-// These are declarative objects that describe how to compute a value at runtime.
-
-export interface AbiEncodeValue {
-  type: 'abi-encode';
-  arguments: {
-    signature: Value<string>;
-    values: Value<any>[];
-  };
-}
-
-export interface AbiPackValue {
-  type: 'abi-pack';
-  arguments: {
-    types: Value<string>[];
-    values: Value<any>[];
-  };
-}
-
-export interface ConstructorEncodeValue {
-  type: 'constructor-encode';
-  arguments: {
-    creationCode?: Value<string>;
-    types: Value<string>[];
-    values: Value<any>[];
-  };
-}
-
-export interface ComputeCreateValue {
-  type: 'compute-create';
-  arguments: {
-    deployerAddress: AddressValue;
-    nonce: Uint256Value;
-  };
-}
-
-export interface ComputeCreate2Value {
-  type: 'compute-create2';
-  arguments: {
-    deployerAddress: AddressValue;
-    salt: BytesValue;
-    initCode: BytesValue;
-  };
-}
-
-export interface ReadBalanceValue {
-  type: 'read-balance';
-  arguments: {
-    address: AddressValue;
-  };
-}
-
-export interface GetStorageAtValue {
-  type: 'get-storage-at';
-  arguments: {
-    address: AddressValue;
-    slot: Value<string | number>;
-  };
-}
-
-/**
- * Computes EVM storage slots for common Solidity storage layouts.
- *
- * The result is always returned as a 32-byte, 0x-prefixed lowercase hex string,
- * so it can be fed directly into `get-storage-at` or nested as the `slot` of
- * another `compute-slot` (e.g. for nested mappings).
- */
-export type ComputeSlotArguments =
-  | {
-      /** Value at `mapping[key]`: keccak256(h(key) . slot). */
-      kind: 'mapping';
-      /** Declaration slot of the mapping. */
-      slot: Value<string | number>;
-      /** The mapping key. */
-      key: Value<string | number | boolean>;
-      /**
-       * Solidity type of the key, used to encode it (default: "uint256").
-       * Value types (address, uint*, int*, bytes32, bool, ...) are ABI-encoded
-       * and left-padded; dynamic types ("string", "bytes") are packed.
-       */
-      keyType?: Value<string>;
-    }
-  | {
-      /** Element of a dynamic array: keccak256(slot) + index * elementSize. */
-      kind: 'dynamic-array';
-      /** Declaration slot of the array (also where its length lives). */
-      slot: Value<string | number>;
-      /** Element index (default: 0). */
-      index?: Value<string | number>;
-      /** Number of slots each element occupies (default: 1). */
-      elementSize?: Value<string | number>;
-    }
-  | {
-      /** Field of a struct or fixed-size array element: slot + offset. */
-      kind: 'struct-field';
-      /** Base slot of the struct / array element. */
-      slot: Value<string | number>;
-      /** Field offset in slots from the base. */
-      offset: Value<string | number>;
-    }
-  | {
-      /**
-       * ERC-7201 namespaced storage root:
-       * keccak256(abi.encode(uint256(keccak256(id)) - 1)) & ~bytes32(uint256(0xff)).
-       */
-      kind: 'erc7201';
-      /** The namespace id, e.g. "openzeppelin.storage.Ownable". */
-      id: Value<string>;
-    }
-  | {
-      /** Well-known EIP-1967 proxy slot: keccak256("eip1967.proxy.<name>") - 1. */
-      kind: 'eip1967';
-      /** Which proxy slot to compute. */
-      name: Value<'implementation' | 'admin' | 'beacon'>;
-    };
-
-export interface ComputeSlotValue {
-  type: 'compute-slot';
-  arguments: ComputeSlotArguments;
-}
-
-export interface BasicArithmeticValue {
-  type: 'basic-arithmetic';
-  arguments: {
-    operation: 'add' | 'sub' | 'mul' | 'div' | 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte';
-    values: Value<any>[];
-  };
-}
-
-export interface CallValue {
-    type: 'call';
-    arguments: {
-        to?: AddressValue; // Optional, can be inferred from context by the parser
-        signature: Value<string>;
-        values: Value<any>[];
-    };
-}
-
-export interface ContractExistsValue {
-    type: 'contract-exists';
-    arguments: {
-        address: AddressValue;
-    };
-}
-
-export interface JobCompletedValue {
-    type: 'job-completed';
-    arguments: {
-        job: Value<string>;
-    };
-}
-
-export interface ReadJsonValue {
-    type: 'read-json';
-    arguments: {
-        json: Value<any>; // The JSON object to read from
-        path: Value<string | number>; // The path to the value (e.g., "txs.data", 1, or "user.profile.name")
-    };
-}
-
-export interface ResolveJsonValue {
-  type: 'resolve-json';
-  arguments: Value<any>;
-}
-
-export interface ValueEmptyValue {
-  type: 'value-empty';
-  arguments: {
-    value: Value<any>;
-  };
-}
-
-export interface SliceBytesValue {
-  type: 'slice-bytes';
-  arguments: {
-    value: BytesValue;
-    start?: Value<number | string>;
-    end?: Value<number | string>;
-    range?: Value<string>;
-  };
-}
-
-/**
- * A union of all possible value-resolver objects.
- */
-export type ValueResolver =
-  | AbiEncodeValue
-  | AbiPackValue
-  | ConstructorEncodeValue
-  | ComputeCreateValue
-  | ComputeCreate2Value
-  | ReadBalanceValue
-  | GetStorageAtValue
-  | ComputeSlotValue
-  | BasicArithmeticValue
-  | CallValue
-  | ContractExistsValue
-  | JobCompletedValue
-  | ReadJsonValue
-  | ResolveJsonValue
-  | ValueEmptyValue
-  | SliceBytesValue;
-
-/**
- * A generic value type that can be a primitive literal (string, number, boolean),
- * a reference to another value, or a value-resolver object.
- * This accurately models the flexibility of your YAML arguments.
- */
-export type Value<T = string | number | boolean> = T | Reference | ValueResolver;
-
-// --- Specific Value Types for clarity and type-safety ---
-export type BytesValue = Value<string>;
-export type AddressValue = Value<string>;
-export type Uint256Value = Value<string | number>;
-export type BooleanValue = Value<boolean>;

package/src/lib/utils/assertion.ts

@@ -1,24 +0,0 @@
-import { ethers } from "ethers";
-
-export function isAddress(value: unknown): value is string {
-  return ethers.isAddress(value)
-}
-
-export function isBytesLike(value: unknown): value is string {
-  return ethers.isBytesLike(value)
-}
-
-export function isBigNumberish(value: unknown): value is string | number | bigint {
-  try {
-    switch (typeof(value)) {
-      case "bigint":
-      case "number":
-      case "string":
-        ethers.toBigInt(value)
-        return true
-    }
-  } catch (error) {
-    // Fail out
-  }
-  return false
-}

package/src/lib/utils/validation.ts

@@ -1,116 +0,0 @@
-/**
- * Validation utilities for type checking and conversion of resolved values.
- * These functions provide runtime type safety for values resolved from YAML configurations.
- */
-
-/**
- * Validates and converts a value to a valid Ethereum address.
- */
-export function validateAddress(value: unknown, actionName: string): string {
-  if (typeof value !== 'string') {
-    throw new Error(`Invalid 'to' address for action "${actionName}": expected string, got ${typeof value}`)
-  }
-  
-  // Basic Ethereum address validation (0x followed by 40 hex characters)
-  if (!/^0x[a-fA-F0-9]{40}$/.test(value)) {
-    throw new Error(`Invalid 'to' address format for action "${actionName}": ${value}`)
-  }
-  
-  return value
-}
-
-/**
- * Validates and converts a value to hex data string.
- */
-export function validateHexData(value: unknown, actionName: string, fieldName: string): string {
-  if (value === null || value === undefined) {
-    return '0x'
-  }
-  
-  if (typeof value !== 'string') {
-    throw new Error(`Invalid '${fieldName}' for action "${actionName}": expected string, got ${typeof value}`)
-  }
-  
-  // Ensure it starts with 0x
-  if (!value.startsWith('0x')) {
-    throw new Error(`Invalid '${fieldName}' format for action "${actionName}": must start with '0x', got ${value}`)
-  }
-  
-  // Validate hex characters (allow empty data as '0x')
-  if (value.length > 2 && !/^0x[a-fA-F0-9]*$/.test(value)) {
-    throw new Error(`Invalid '${fieldName}' format for action "${actionName}": contains non-hex characters: ${value}`)
-  }
-  
-  return value
-}
-
-/**
- * Validates and converts a value to a BigNumberish (number, string, or BigInt).
- */
-export function validateBigNumberish(value: unknown, actionName: string, fieldName: string): string | number | bigint {
-  if (value === null || value === undefined) {
-    return 0
-  }
-  
-  // Handle different input types
-  if (typeof value === 'number') {
-    if (!Number.isInteger(value) || value < 0) {
-      throw new Error(`Invalid '${fieldName}' for action "${actionName}": must be a non-negative integer, got ${value}`)
-    }
-    return value
-  }
-  
-  if (typeof value === 'string') {
-    // Handle hex strings
-    if (value.startsWith('0x')) {
-      if (!/^0x[a-fA-F0-9]+$/.test(value)) {
-        throw new Error(`Invalid '${fieldName}' hex format for action "${actionName}": ${value}`)
-      }
-      return value
-    }
-    
-    // Handle decimal strings
-    if (!/^\d+$/.test(value)) {
-      throw new Error(`Invalid '${fieldName}' format for action "${actionName}": must be a number or hex string, got ${value}`)
-    }
-    return value
-  }
-  
-  if (typeof value === 'bigint') {
-    if (value < 0n) {
-      throw new Error(`Invalid '${fieldName}' for action "${actionName}": must be non-negative, got ${value}`)
-    }
-    return value
-  }
-  
-  throw new Error(`Invalid '${fieldName}' type for action "${actionName}": expected number, string, or bigint, got ${typeof value}`)
-}
-
-/**
- * Validates that a value is a valid raw transaction string.
- */
-export function validateRawTransaction(value: unknown, actionName: string): string {
-  if (typeof value !== 'string') {
-    throw new Error(`Invalid raw transaction for action "${actionName}": expected string, got ${typeof value}`)
-  }
-
-  // Normalize: trim whitespace and allow with or without 0x prefix
-  const trimmed = value.trim()
-  const withoutPrefix = trimmed.startsWith('0x') ? trimmed.slice(2) : trimmed
-
-  if (withoutPrefix.length === 0) {
-    // Empty data is allowed as '0x'
-    return '0x'
-  }
-
-  // Validate hex characters only
-  if (!/^[a-fA-F0-9]+$/.test(withoutPrefix)) {
-    // Pinpoint first invalid character for easier debugging
-    const idx = withoutPrefix.search(/[^a-fA-F0-9]/)
-    const marker = idx >= 0 ? ` at index ${idx} ('${withoutPrefix[idx]}')` : ''
-    throw new Error(`Invalid raw transaction format for action "${actionName}": contains non-hex characters${marker}: ${value}`)
-  }
-
-  // Ensure canonical 0x-prefixed output
-  return '0x' + withoutPrefix
-}

package/src/lib/validation/contract-references.ts

@@ -1,210 +0,0 @@
-import { ProjectLoader } from '../core/loader'
-import { Action, Template, Job, JobAction, Value } from '../types'
-
-export interface MissingContractReference {
-  reference: string
-  location: string
-}
-
-export interface UsedContractReference {
-  reference: string
-  location: string
-}
-
-/**
- * Extracts all Contract() references actually used in the project
- */
-export async function extractUsedContractReferences(loader: ProjectLoader): Promise<UsedContractReference[]> {
-  const usedRefs: UsedContractReference[] = []
-  
-  // Extract from jobs
-  for (const [jobName, job] of loader.jobs.entries()) {
-    extractJobActionsContractReferences(job.actions, `job '${jobName}'`, job._path, usedRefs)
-  }
-  
-  // Extract from templates
-  for (const [templateName, template] of loader.templates.entries()) {
-    extractActionsContractReferences(template.actions, `template '${templateName}'`, template._path, usedRefs)
-    
-    // Extract from template setup actions if they exist
-    if (template.setup?.actions) {
-      extractActionsContractReferences(template.setup.actions, `template '${templateName}' setup`, template._path, usedRefs)
-    }
-    
-    // Extract from template outputs
-    if (template.outputs) {
-      extractValueContractReferences(template.outputs, `template '${templateName}' outputs`, template._path, usedRefs)
-    }
-  }
-  
-  return usedRefs
-}
-
-/**
- * Validates that all Contract() references in the project point to existing contracts
- */
-export async function validateContractReferences(loader: ProjectLoader): Promise<MissingContractReference[]> {
-  const missingRefs: MissingContractReference[] = []
-  
-  // Validate jobs
-  for (const [jobName, job] of loader.jobs.entries()) {
-    validateJobActionsForMissingContracts(job.actions, `job '${jobName}'`, job._path, loader, missingRefs)
-  }
-  
-  // Validate templates
-  for (const [templateName, template] of loader.templates.entries()) {
-    validateActionsForMissingContracts(template.actions, `template '${templateName}'`, template._path, loader, missingRefs)
-    
-    // Validate template setup actions if they exist
-    if (template.setup?.actions) {
-      validateActionsForMissingContracts(template.setup.actions, `template '${templateName}' setup`, template._path, loader, missingRefs)
-    }
-    
-    // Validate template outputs
-    if (template.outputs) {
-      validateValueForMissingContracts(template.outputs, `template '${templateName}' outputs`, template._path, loader, missingRefs)
-    }
-  }
-  
-  return missingRefs
-}
-
-/**
- * Extracts contract references from job actions
- */
-function extractJobActionsContractReferences(
-  actions: JobAction[], 
-  locationPrefix: string, 
-  contextPath: string | undefined,
-  usedRefs: UsedContractReference[]
-): void {
-  for (let i = 0; i < actions.length; i++) {
-    const action = actions[i]
-    const actionLocation = `${locationPrefix}, action ${i + 1}${action.name ? ` '${action.name}'` : ''}`
-    
-    extractValueContractReferences(action.arguments, actionLocation, contextPath, usedRefs)
-  }
-}
-
-/**
- * Extracts contract references from template actions
- */
-function extractActionsContractReferences(
-  actions: Action[], 
-  locationPrefix: string, 
-  contextPath: string | undefined,
-  usedRefs: UsedContractReference[]
-): void {
-  for (let i = 0; i < actions.length; i++) {
-    const action = actions[i]
-    const actionLocation = `${locationPrefix}, action ${i + 1}${action.name ? ` '${action.name}'` : ''}`
-    
-    extractValueContractReferences(action.arguments, actionLocation, contextPath, usedRefs)
-  }
-}
-
-/**
- * Recursively extracts contract references from a value (or nested object/array)
- */
-function extractValueContractReferences(
-  value: any, 
-  location: string, 
-  contextPath: string | undefined,
-  usedRefs: UsedContractReference[]
-): void {
-  if (typeof value === 'string') {
-    // Check for Contract() expressions
-    const contractMatch = value.match(/^{{Contract\((.*?)\)(?:\.\w+)?}}$/)
-    if (contractMatch) {
-      const reference = contractMatch[1].trim()
-      usedRefs.push({
-        reference,
-        location: `${location}, Contract(${reference})`
-      })
-    }
-  } else if (Array.isArray(value)) {
-    // Recursively check array elements
-    for (let i = 0; i < value.length; i++) {
-      extractValueContractReferences(value[i], `${location}[${i}]`, contextPath, usedRefs)
-    }
-  } else if (typeof value === 'object' && value !== null) {
-    // Recursively check object properties
-    for (const [key, val] of Object.entries(value)) {
-      extractValueContractReferences(val, `${location}.${key}`, contextPath, usedRefs)
-    }
-  }
-}
-
-/**
- * Validates a list of job actions for missing contract references
- */
-function validateJobActionsForMissingContracts(
-  actions: JobAction[], 
-  locationPrefix: string, 
-  contextPath: string | undefined,
-  loader: ProjectLoader, 
-  missingRefs: MissingContractReference[]
-): void {
-  for (let i = 0; i < actions.length; i++) {
-    const action = actions[i]
-    const actionLocation = `${locationPrefix}, action ${i + 1}${action.name ? ` '${action.name}'` : ''}`
-    
-    validateValueForMissingContracts(action.arguments, actionLocation, contextPath, loader, missingRefs)
-  }
-}
-
-/**
- * Validates a list of template actions for missing contract references
- */
-function validateActionsForMissingContracts(
-  actions: Action[], 
-  locationPrefix: string, 
-  contextPath: string | undefined,
-  loader: ProjectLoader, 
-  missingRefs: MissingContractReference[]
-): void {
-  for (let i = 0; i < actions.length; i++) {
-    const action = actions[i]
-    const actionLocation = `${locationPrefix}, action ${i + 1}${action.name ? ` '${action.name}'` : ''}`
-    
-    validateValueForMissingContracts(action.arguments, actionLocation, contextPath, loader, missingRefs)
-  }
-}
-
-/**
- * Recursively validates a value (or nested object/array) for missing contract references
- */
-function validateValueForMissingContracts(
-  value: any, 
-  location: string, 
-  contextPath: string | undefined,
-  loader: ProjectLoader, 
-  missingRefs: MissingContractReference[]
-): void {
-  if (typeof value === 'string') {
-    // Check for Contract() expressions
-    const contractMatch = value.match(/^{{Contract\((.*?)\)(?:\.\w+)?}}$/)
-    if (contractMatch) {
-      const reference = contractMatch[1].trim()
-      
-      // Try to lookup the contract
-      const contract = loader.contractRepository.lookup(reference, contextPath)
-      if (!contract) {
-        missingRefs.push({
-          reference,
-          location: `${location}, Contract(${reference})`
-        })
-      }
-    }
-  } else if (Array.isArray(value)) {
-    // Recursively check array elements
-    for (let i = 0; i < value.length; i++) {
-      validateValueForMissingContracts(value[i], `${location}[${i}]`, contextPath, loader, missingRefs)
-    }
-  } else if (typeof value === 'object' && value !== null) {
-    // Recursively check object properties
-    for (const [key, val] of Object.entries(value)) {
-      validateValueForMissingContracts(val, `${location}.${key}`, contextPath, loader, missingRefs)
-    }
-  }
-}

package/src/lib/validation/index.ts

@@ -1 +0,0 @@
-// No exports - validation logic is now integrated into ContractRepository