pangea 0.0.42 → 0.0.45

data/lib/pangea/resources/aws_managedblockchain_member/types.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require 'dry-struct'
+require 'pangea/resources/types'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+      # Type-safe attributes for AWS Managed Blockchain Member resources
+      class ManagedBlockchainMemberAttributes < Dry::Struct
+        transform_keys(&:to_sym)
+
+        # Network ID (required)
+        attribute :network_id, Resources::Types::String
+
+        # Member configuration (required)
+        attribute :member_configuration, Resources::Types::Hash.schema(
+          name: Resources::Types::String,
+          description?: Resources::Types::String.optional,
+          framework_configuration: Resources::Types::Hash.schema(
+            member_fabric_configuration?: Resources::Types::Hash.schema(
+              admin_username: Resources::Types::String,
+              admin_password: Resources::Types::String
+            ).optional
+          ),
+          log_publishing_configuration?: Resources::Types::Hash.schema(
+            fabric?: Resources::Types::Hash.schema(
+              ca_logs?: Resources::Types::Hash.schema(
+                cloudwatch?: Resources::Types::Hash.schema(
+                  enabled?: Resources::Types::Bool.optional
+                ).optional
+              ).optional
+            ).optional
+          ).optional,
+          tags?: Resources::Types::Hash.schema(
+            Resources::Types::String => Resources::Types::String
+          ).optional
+        )
+
+        # Invitation ID (required for joining existing networks)
+        attribute? :invitation_id, Resources::Types::String.optional
+
+        # Tags (optional)
+        attribute? :tags, Resources::Types::Hash.schema(
+          Resources::Types::String => Resources::Types::String
+        ).optional
+
+        # Custom validation
+        def self.new(attributes = {})
+          attrs = super(attributes)
+
+          # Validate network ID format
+          unless attrs.network_id.match?(/\An-[A-Z0-9]{26}\z/)
+            raise Dry::Struct::Error, "network_id must be in format 'n-XXXXXXXXXXXXXXXXXXXXXXXXXXXX'"
+          end
+
+          # Validate invitation ID format if provided
+          if attrs.invitation_id && !attrs.invitation_id.match?(/\Ai-[A-Z0-9]{26}\z/)
+            raise Dry::Struct::Error, "invitation_id must be in format 'i-XXXXXXXXXXXXXXXXXXXXXXXXXXXX'"
+          end
+
+          # Validate member name
+          member_name = attrs.member_configuration[:name]
+          unless member_name.match?(/\A[a-zA-Z][a-zA-Z0-9]*\z/)
+            raise Dry::Struct::Error, "member name must start with a letter and contain only alphanumeric characters"
+          end
+
+          if member_name.length < 1 || member_name.length > 64
+            raise Dry::Struct::Error, "member name must be between 1 and 64 characters"
+          end
+
+          # Validate Fabric configuration if provided
+          if attrs.member_configuration[:framework_configuration][:member_fabric_configuration]
+            validate_fabric_configuration(attrs.member_configuration[:framework_configuration][:member_fabric_configuration])
+          end
+
+          attrs
+        end
+
+        def self.validate_fabric_configuration(fabric_config)
+          # Validate admin username
+          admin_username = fabric_config[:admin_username]
+          unless admin_username.match?(/\A[a-zA-Z0-9]+\z/)
+            raise Dry::Struct::Error, "admin_username must contain only alphanumeric characters"
+          end
+
+          if admin_username.length < 1 || admin_username.length > 16
+            raise Dry::Struct::Error, "admin_username must be between 1 and 16 characters"
+          end
+
+          # Validate admin password
+          admin_password = fabric_config[:admin_password]
+          if admin_password.length < 8 || admin_password.length > 32
+            raise Dry::Struct::Error, "admin_password must be between 8 and 32 characters"
+          end
+
+          # Check password complexity
+          unless admin_password.match?(/[A-Z]/) && admin_password.match?(/[a-z]/) && 
+                 admin_password.match?(/[0-9]/) && admin_password.match?(/[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]/)
+            raise Dry::Struct::Error, "admin_password must contain uppercase, lowercase, number, and special character"
+          end
+        end
+
+        # Helper methods
+        def member_name
+          member_configuration[:name]
+        end
+
+        def member_description
+          member_configuration[:description]
+        end
+
+        def is_fabric_member?
+          member_configuration[:framework_configuration][:member_fabric_configuration].present?
+        end
+
+        def admin_username
+          member_configuration.dig(:framework_configuration, :member_fabric_configuration, :admin_username)
+        end
+
+        def ca_logging_enabled?
+          member_configuration.dig(:log_publishing_configuration, :fabric, :ca_logs, :cloudwatch, :enabled) || false
+        end
+
+        def is_joining_existing_network?
+          !invitation_id.nil?
+        end
+
+        def is_founding_member?
+          invitation_id.nil?
+        end
+
+        def member_type
+          if is_founding_member?
+            :founding_member
+          else
+            :invited_member
+          end
+        end
+
+        def estimated_monthly_cost
+          # Base member cost (varies by network type)
+          base_cost = if is_fabric_member?
+            0.10 # $0.10/hour for Fabric member
+          else
+            0.00 # Ethereum members don't have member-specific costs
+          end
+
+          # Add CA logging cost if enabled
+          if ca_logging_enabled?
+            base_cost += 0.01 # Approximate logging cost
+          end
+
+          # Convert to monthly (730 hours)
+          base_cost * 730
+        end
+
+        def member_capabilities
+          capabilities = []
+          
+          if is_fabric_member?
+            capabilities << :certificate_authority
+            capabilities << :peer_node_creation
+            capabilities << :chaincode_deployment
+            capabilities << :channel_creation
+          end
+
+          if ca_logging_enabled?
+            capabilities << :ca_audit_logging
+          end
+
+          capabilities
+        end
+
+        def security_features
+          features = []
+
+          if is_fabric_member?
+            features << :x509_certificates
+            features << :msp_identity_management
+            features << :tls_encryption
+          end
+
+          if admin_username
+            features << :admin_credentials
+          end
+
+          features
+        end
+
+        def compliance_features
+          features = []
+
+          if ca_logging_enabled?
+            features << :audit_trail
+            features << :cloudwatch_integration
+          end
+
+          if member_configuration[:tags]
+            features << :resource_tagging
+          end
+
+          features
+        end
+      end
+    end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_managedblockchain_network/CLAUDE.md

@@ -0,0 +1,487 @@
+# AWS Managed Blockchain Network - Architecture and Implementation
+
+## Overview
+
+The `aws_managedblockchain_network` resource creates and manages blockchain networks using AWS Managed Blockchain, a fully managed service that makes it easy to create and manage scalable blockchain networks using Hyperledger Fabric or Ethereum frameworks. This resource handles the complexities of blockchain infrastructure, consensus mechanisms, and network governance.
+
+## Blockchain Framework Architectures
+
+### Hyperledger Fabric Architecture
+
+Hyperledger Fabric is a permissioned blockchain framework designed for enterprise use cases:
+
+1. **Components**:
+   - **Ordering Service**: RAFT consensus for transaction ordering
+   - **Peer Nodes**: Execute chaincode and maintain ledger state
+   - **Certificate Authority (CA)**: Issues identities for network participants
+   - **Channels**: Private communication between specific network members
+
+2. **Transaction Flow**:
+   ```
+   Client → Endorsing Peers → Ordering Service → Committing Peers → Ledger
+   ```
+
+3. **Key Features**:
+   - Private data collections
+   - Chaincode (smart contracts) in multiple languages
+   - Pluggable consensus mechanisms
+   - Fine-grained access control
+
+### Ethereum Architecture
+
+Ethereum on AWS Managed Blockchain provides access to public Ethereum networks:
+
+1. **Network Types**:
+   - **Mainnet**: Production Ethereum network (Proof of Stake)
+   - **Testnets**: Goerli, Sepolia for development/testing
+
+2. **Components**:
+   - **Ethereum Nodes**: Full nodes that sync with the network
+   - **JSON-RPC Interface**: API for interacting with Ethereum
+   - **Web3 Provider**: Connection endpoint for DApps
+
+3. **Key Features**:
+   - Smart contracts in Solidity
+   - EVM compatibility
+   - Public blockchain access
+   - Gas fee management
+
+## Implementation Patterns
+
+### Enterprise Consortium Pattern
+
+```ruby
+# Multi-organization supply chain network
+def create_supply_chain_consortium
+  # Create the network with governance rules
+  network = aws_managedblockchain_network(:supply_chain, {
+    name: "GlobalSupplyChain",
+    framework: "HYPERLEDGER_FABRIC",
+    framework_version: "2.5",
+    framework_configuration: {
+      network_fabric_configuration: {
+        edition: "STANDARD"  # Higher TPS for enterprise
+      }
+    },
+    voting_policy: {
+      approval_threshold_policy: {
+        threshold_percentage: 51,  # Simple majority
+        proposal_duration_in_hours: 48,
+        threshold_comparator: "GREATER_THAN"
+      }
+    },
+    member_configuration: create_member_config("Manufacturer")
+  })
+
+  # Create private channels for bilateral agreements
+  channels = {
+    manufacturer_supplier: create_channel("ManufacturerSupplier"),
+    manufacturer_distributor: create_channel("ManufacturerDistributor"),
+    all_parties: create_channel("AllParties")
+  }
+
+  { network: network, channels: channels }
+end
+```
+
+### DeFi Integration Pattern
+
+```ruby
+# Ethereum network for DeFi protocols
+def setup_defi_infrastructure
+  # Create Ethereum node access
+  eth_network = aws_managedblockchain_network(:defi_node, {
+    name: "DeFiNode",
+    framework: "ETHEREUM",
+    framework_version: "ETHEREUM_MAINNET",
+    framework_configuration: {
+      network_ethereum_configuration: {
+        chain_id: "1"  # Mainnet
+      }
+    },
+    member_configuration: {
+      name: "DeFiProtocol",
+      framework_configuration: {}
+    }
+  })
+
+  # Configure Web3 endpoint
+  web3_endpoint = configure_web3_endpoint(eth_network)
+  
+  # Set up monitoring for gas prices
+  gas_monitor = setup_gas_monitoring(web3_endpoint)
+
+  { network: eth_network, web3: web3_endpoint, monitoring: gas_monitor }
+end
+```
+
+## Network Design Considerations
+
+### Scalability Patterns
+
+1. **Hyperledger Fabric Scaling**:
+   ```ruby
+   # Horizontal scaling with multiple peers
+   def scale_fabric_network(network, member_count)
+     editions = {
+       small: "STARTER",      # Up to 2 members, 1000 TPS
+       medium: "STANDARD",    # Up to 14 members, 3000 TPS
+       large: "STANDARD"      # With additional peer nodes
+     }
+     
+     edition = case member_count
+               when 1..2 then editions[:small]
+               when 3..14 then editions[:medium]
+               else editions[:large]
+               end
+     
+     { edition: edition, peer_nodes: calculate_peer_nodes(member_count) }
+   end
+   ```
+
+2. **Ethereum Node Optimization**:
+   ```ruby
+   # Optimize node configuration for DApp requirements
+   def optimize_ethereum_node(dapp_type)
+     case dapp_type
+     when :high_frequency_trading
+       {
+         instance_type: "bc.m5.2xlarge",
+         storage: "1000GB",
+         api_rate_limit: "10000/min"
+       }
+     when :nft_marketplace
+       {
+         instance_type: "bc.m5.xlarge",
+         storage: "500GB",
+         api_rate_limit: "5000/min"
+       }
+     when :defi_protocol
+       {
+         instance_type: "bc.m5.xlarge",
+         storage: "750GB",
+         api_rate_limit: "7500/min"
+       }
+     end
+   end
+   ```
+
+### Security Architecture
+
+1. **Identity and Access Management**:
+   ```ruby
+   # Fabric CA integration
+   def configure_fabric_identity(network, organization)
+     {
+       ca_endpoint: "#{network.vpc_endpoint_service_name}/ca",
+       enrollment_id: "admin@#{organization}.com",
+       affiliation: organization,
+       attributes: {
+         role: "admin",
+         organization: organization,
+         department: "blockchain"
+       }
+     }
+   end
+   ```
+
+2. **Network Isolation**:
+   ```ruby
+   # VPC endpoint configuration for private access
+   def configure_private_access(network)
+     vpc_endpoint = aws_vpc_endpoint(:blockchain_endpoint, {
+       vpc_id: vpc.id,
+       service_name: network.vpc_endpoint_service_name,
+       vpc_endpoint_type: "Interface",
+       subnet_ids: private_subnets.map(&:id),
+       security_group_ids: [blockchain_sg.id]
+     })
+     
+     # DNS configuration for endpoint
+     route53_record = aws_route53_record(:blockchain_dns, {
+       zone_id: private_zone.id,
+       name: "blockchain.internal",
+       type: "CNAME",
+       records: [vpc_endpoint.dns_entry[0].dns_name]
+     })
+   end
+   ```
+
+## Governance Models
+
+### Voting Policy Implementation
+
+```ruby
+# Dynamic voting policy based on consortium size
+def calculate_voting_policy(member_count, decision_type)
+  base_threshold = case decision_type
+  when :add_member
+    75  # 3/4 majority for adding members
+  when :remove_member
+    90  # 90% for removing members
+  when :network_upgrade
+    66  # 2/3 for upgrades
+  when :standard_proposal
+    51  # Simple majority
+  end
+  
+  # Adjust for small consortiums
+  if member_count <= 3
+    base_threshold = [base_threshold, 100 / member_count].max
+  end
+  
+  {
+    threshold_percentage: base_threshold,
+    proposal_duration_in_hours: calculate_duration(decision_type),
+    threshold_comparator: "GREATER_THAN_OR_EQUAL_TO"
+  }
+end
+
+def calculate_duration(decision_type)
+  case decision_type
+  when :emergency then 6
+  when :standard_proposal then 24
+  when :add_member, :remove_member then 72
+  when :network_upgrade then 168  # 1 week
+  end
+end
+```
+
+### Chaincode Governance
+
+```ruby
+# Chaincode deployment governance
+def chaincode_endorsement_policy(chaincode_type)
+  case chaincode_type
+  when :financial_settlement
+    # Requires all parties to endorse
+    "AND('Org1MSP.peer', 'Org2MSP.peer', 'Org3MSP.peer')"
+  when :data_sharing
+    # Requires majority
+    "OR(AND('Org1MSP.peer', 'Org2MSP.peer'), AND('Org1MSP.peer', 'Org3MSP.peer'), AND('Org2MSP.peer', 'Org3MSP.peer'))"
+  when :public_registry
+    # Any member can endorse
+    "OR('Org1MSP.peer', 'Org2MSP.peer', 'Org3MSP.peer')"
+  end
+end
+```
+
+## Integration Patterns
+
+### Event Streaming Integration
+
+```ruby
+# Stream blockchain events to Kinesis
+def setup_blockchain_event_streaming(network)
+  # Create Kinesis stream for events
+  event_stream = aws_kinesis_stream(:blockchain_events, {
+    name: "#{network.name}-events",
+    shard_count: 10,
+    retention_period_hours: 168
+  })
+  
+  # Lambda function to process events
+  event_processor = aws_lambda_function(:event_processor, {
+    function_name: "#{network.name}-event-processor",
+    runtime: "nodejs18.x",
+    handler: "index.handler",
+    environment: {
+      variables: {
+        NETWORK_ID: network.id,
+        STREAM_NAME: event_stream.name
+      }
+    }
+  })
+  
+  # EventBridge rule for blockchain events
+  event_rule = aws_eventbridge_rule(:blockchain_rule, {
+    name: "#{network.name}-events",
+    event_pattern: JSON.generate({
+      source: ["aws.managedblockchain"],
+      "detail-type": ["Blockchain Network Event"],
+      detail: {
+        networkId: [network.id]
+      }
+    })
+  })
+end
+```
+
+### Analytics Pipeline
+
+```ruby
+# Blockchain analytics with Athena
+def setup_blockchain_analytics(network)
+  # S3 bucket for blockchain data
+  data_lake = aws_s3_bucket(:blockchain_data, {
+    bucket: "blockchain-analytics-#{network.name}",
+    versioning: { enabled: true }
+  })
+  
+  # Glue crawler for schema discovery
+  crawler = aws_glue_crawler(:blockchain_crawler, {
+    name: "#{network.name}-crawler",
+    database_name: "blockchain_analytics",
+    s3_target: {
+      path: "s3://#{data_lake.bucket}/transactions/"
+    }
+  })
+  
+  # Athena workgroup for queries
+  workgroup = aws_athena_workgroup(:blockchain_queries, {
+    name: "#{network.name}-analytics",
+    configuration: {
+      result_configuration: {
+        output_location: "s3://#{data_lake.bucket}/query-results/"
+      }
+    }
+  })
+end
+```
+
+## Performance Optimization
+
+### Transaction Throughput Optimization
+
+```ruby
+# Optimize Fabric for high throughput
+def optimize_fabric_throughput(expected_tps)
+  config = {
+    block_size: calculate_block_size(expected_tps),
+    block_timeout: calculate_block_timeout(expected_tps),
+    preferred_max_bytes: calculate_max_bytes(expected_tps),
+    batching: {
+      max_message_count: 500,
+      absolute_max_bytes: 10 * 1024 * 1024,  # 10 MB
+      preferred_max_bytes: 2 * 1024 * 1024   # 2 MB
+    }
+  }
+  
+  if expected_tps > 1000
+    config[:edition] = "STANDARD"
+    config[:peer_nodes] = calculate_peer_count(expected_tps)
+  end
+  
+  config
+end
+```
+
+### Caching Strategy
+
+```ruby
+# Implement caching for blockchain queries
+def setup_query_cache(network)
+  # ElastiCache for frequent queries
+  cache = aws_elasticache_cluster(:blockchain_cache, {
+    cluster_id: "#{network.name}-cache",
+    engine: "redis",
+    node_type: "cache.r6g.large",
+    num_cache_nodes: 3,
+    automatic_failover_enabled: true
+  })
+  
+  # Lambda@Edge for API caching
+  edge_function = aws_lambda_function(:cache_handler, {
+    function_name: "#{network.name}-edge-cache",
+    runtime: "nodejs18.x",
+    publish: true,
+    environment: {
+      variables: {
+        CACHE_ENDPOINT: cache.cache_nodes[0].address,
+        CACHE_TTL: "300"
+      }
+    }
+  })
+end
+```
+
+## Cost Management
+
+### Cost Optimization Strategies
+
+```ruby
+# Dynamic network sizing based on usage
+def optimize_network_costs(network, usage_metrics)
+  recommendations = []
+  
+  # Analyze Fabric edition usage
+  if network.is_hyperledger_fabric?
+    if usage_metrics[:active_members] <= 2 && usage_metrics[:daily_transactions] < 50000
+      recommendations << {
+        action: "downgrade_edition",
+        from: "STANDARD",
+        to: "STARTER",
+        monthly_savings: 600
+      }
+    end
+  end
+  
+  # Analyze Ethereum node usage
+  if network.is_ethereum?
+    if usage_metrics[:api_calls_per_day] < 10000
+      recommendations << {
+        action: "implement_caching",
+        estimated_reduction: "70%",
+        monthly_savings: calculate_api_savings(usage_metrics)
+      }
+    end
+  end
+  
+  recommendations
+end
+```
+
+## Disaster Recovery
+
+### Backup and Recovery Strategy
+
+```ruby
+# Automated blockchain backup
+def setup_blockchain_backup(network)
+  # S3 bucket for backups
+  backup_bucket = aws_s3_bucket(:blockchain_backup, {
+    bucket: "#{network.name}-backups",
+    lifecycle_rule: [{
+      id: "archive-old-backups",
+      status: "Enabled",
+      transition: [{
+        days: 30,
+        storage_class: "GLACIER"
+      }]
+    }]
+  })
+  
+  # Backup automation
+  backup_state_machine = aws_sfn_state_machine(:backup_automation, {
+    name: "#{network.name}-backup",
+    definition: create_backup_workflow(network, backup_bucket)
+  })
+  
+  # Schedule daily backups
+  aws_eventbridge_rule(:backup_schedule, {
+    name: "#{network.name}-daily-backup",
+    schedule_expression: "rate(1 day)",
+    targets: [{
+      arn: backup_state_machine.arn,
+      role_arn: backup_role.arn
+    }]
+  })
+end
+```
+
+## Future Considerations
+
+### Cross-Chain Interoperability
+- Bridge implementations between Fabric and Ethereum
+- Atomic swaps and cross-chain transactions
+- Standardized interoperability protocols
+
+### Quantum-Resistant Cryptography
+- Migration paths to post-quantum algorithms
+- Hybrid cryptographic schemes
+- Quantum-safe consensus mechanisms
+
+### Decentralized Identity Integration
+- Self-sovereign identity on blockchain
+- Verifiable credentials
+- Zero-knowledge proof implementations