pangea 0.0.45 → 0.0.46

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

@@ -1,249 +0,0 @@
-# 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 Accessor resources
-      class ManagedBlockchainAccessorAttributes < Dry::Struct
-        transform_keys(&:to_sym)
-
-        # Accessor type (required)
-        attribute :accessor_type, Resources::Types::String.enum(
-          'BILLING_TOKEN'  # Current supported type for Ethereum
-        )
-
-        # Network type (optional)
-        attribute? :network_type, Resources::Types::String.enum(
-          'ETHEREUM_MAINNET',
-          'ETHEREUM_GOERLI_TESTNET',
-          'ETHEREUM_RINKEBY_TESTNET',
-          'POLYGON_MAINNET', 
-          'POLYGON_MUMBAI_TESTNET'
-        ).optional
-
-        # Billing token (optional)
-        attribute? :billing_token, 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 billing token requirement for BILLING_TOKEN accessor type
-          if attrs.accessor_type == 'BILLING_TOKEN'
-            unless attrs.billing_token
-              raise Dry::Struct::Error, "billing_token is required for BILLING_TOKEN accessor type"
-            end
-            
-            unless attrs.billing_token.match?(/\A[a-zA-Z0-9\-_]{1,64}\z/)
-              raise Dry::Struct::Error, "billing_token must be 1-64 characters long and contain only alphanumeric characters, hyphens, and underscores"
-            end
-          end
-
-          # Validate network type consistency
-          if attrs.network_type
-            case attrs.network_type
-            when 'ETHEREUM_MAINNET', 'ETHEREUM_GOERLI_TESTNET', 'ETHEREUM_RINKEBY_TESTNET'
-              # Ethereum networks are supported
-            when 'POLYGON_MAINNET', 'POLYGON_MUMBAI_TESTNET'
-              # Polygon networks are supported
-            else
-              raise Dry::Struct::Error, "Unsupported network type: #{attrs.network_type}"
-            end
-          end
-
-          attrs
-        end
-
-        # Helper methods
-        def is_ethereum_accessor?
-          return true unless network_type
-          network_type.include?('ETHEREUM')
-        end
-
-        def is_hyperledger_accessor?
-          # Currently, accessors are primarily for Ethereum
-          # This method is future-proofed for Hyperledger support
-          false
-        end
-
-        def supports_mainnet?
-          return true unless network_type
-          network_type.include?('MAINNET')
-        end
-
-        def supports_testnet?
-          return true unless network_type
-          network_type.include?('TESTNET') || network_type.include?('GOERLI') || network_type.include?('MUMBAI')
-        end
-
-        def has_billing_token?
-          !billing_token.nil?
-        end
-
-        def estimated_monthly_cost
-          # Base cost for blockchain access (rough estimates in USD)
-          base_cost = case network_type
-          when 'ETHEREUM_MAINNET'
-            500.0  # Higher cost for mainnet access
-          when 'ETHEREUM_GOERLI_TESTNET', 'ETHEREUM_RINKEBY_TESTNET'
-            50.0   # Lower cost for testnet access
-          when 'POLYGON_MAINNET'
-            200.0  # Moderate cost for Polygon mainnet
-          when 'POLYGON_MUMBAI_TESTNET'
-            20.0   # Low cost for Polygon testnet
-          else
-            100.0  # Default cost
-          end
-
-          # Add billing token premium if applicable
-          billing_premium = has_billing_token? ? 50.0 : 0.0
-          
-          base_cost + billing_premium
-        end
-
-        def access_type
-          case accessor_type
-          when 'BILLING_TOKEN'
-            'token_based'
-          else
-            'unknown'
-          end
-        end
-
-        def blockchain_framework
-          return 'unknown' unless network_type
-          
-          case network_type
-          when /ETHEREUM/
-            'ethereum'
-          when /POLYGON/
-            'polygon'
-          else
-            'unknown'
-          end
-        end
-
-        def network_environment
-          return 'unknown' unless network_type
-          
-          if supports_mainnet?
-            'production'
-          elsif supports_testnet?
-            'testing'
-          else
-            'unknown'
-          end
-        end
-
-        def is_production_network?
-          network_environment == 'production'
-        end
-
-        def is_test_network?
-          network_environment == 'testing'
-        end
-
-        # Get the specific testnet name if applicable
-        def testnet_name
-          return nil unless supports_testnet?
-          
-          case network_type
-          when 'ETHEREUM_GOERLI_TESTNET'
-            'goerli'
-          when 'ETHEREUM_RINKEBY_TESTNET'
-            'rinkeby'
-          when 'POLYGON_MUMBAI_TESTNET'
-            'mumbai'
-          else
-            'unknown'
-          end
-        end
-
-        # Check if accessor supports smart contracts
-        def supports_smart_contracts?
-          # All Ethereum and Polygon networks support smart contracts
-          ['ethereum', 'polygon'].include?(blockchain_framework)
-        end
-
-        # Get the native token for the network
-        def native_token
-          case blockchain_framework
-          when 'ethereum'
-            'ETH'
-          when 'polygon'
-            'MATIC'
-          else
-            'UNKNOWN'
-          end
-        end
-
-        # Estimate transaction throughput (TPS)
-        def estimated_tps
-          case blockchain_framework
-          when 'ethereum'
-            15  # Ethereum mainnet ~15 TPS
-          when 'polygon'
-            7000  # Polygon can handle ~7000 TPS
-          else
-            100
-          end
-        end
-
-        # Get block confirmation time in seconds
-        def block_confirmation_time_seconds
-          case blockchain_framework
-          when 'ethereum'
-            12  # Ethereum block time ~12 seconds
-          when 'polygon'
-            2   # Polygon block time ~2 seconds
-          else
-            15
-          end
-        end
-
-        # Calculate security score based on network
-        def security_score
-          score = 100
-          
-          # Production networks are more secure
-          score += 20 if is_production_network?
-          score -= 10 if is_test_network?
-          
-          # Ethereum has higher security due to larger validator set
-          score += 15 if blockchain_framework == 'ethereum'
-          score += 10 if blockchain_framework == 'polygon'
-          
-          # Billing token adds security
-          score += 5 if has_billing_token?
-          
-          [score, 0].max
-        end
-      end
-    end
-      end
-    end
-  end
-end

data/lib/pangea/resources/aws_managedblockchain_ethereum_node/resource.rb

@@ -1,97 +0,0 @@
-# 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 'pangea/resources/base'
-require 'pangea/resources/reference'
-require 'pangea/resources/aws_managedblockchain_ethereum_node/types'
-require 'pangea/resource_registry'
-
-module Pangea
-  module Resources
-    module AWS
-      # Create an AWS Managed Blockchain Ethereum Node
-      #
-      # @param name [Symbol] The resource name
-      # @param attributes [Hash] Ethereum node attributes
-      # @return [ResourceReference] Reference object with outputs and computed properties
-      def aws_managedblockchain_ethereum_node(name, attributes = {})
-        # Validate attributes using dry-struct
-        node_attrs = Types::ManagedBlockchainEthereumNodeAttributes.new(attributes)
-        
-        # Generate terraform resource block via terraform-synthesizer
-        resource(:aws_managedblockchain_ethereum_node, name) do
-          # Set network ID
-          network_id node_attrs.network_id
-          
-          # Set node configuration
-          node_configuration do
-            instance_type node_attrs.node_configuration[:instance_type]
-            
-            if node_attrs.node_configuration[:availability_zone]
-              availability_zone node_attrs.node_configuration[:availability_zone]
-            end
-            
-            if node_attrs.node_configuration[:subnet_id]
-              subnet_id node_attrs.node_configuration[:subnet_id]
-            end
-          end
-          
-          # Set client request token if provided
-          if node_attrs.client_request_token
-            client_request_token node_attrs.client_request_token
-          end
-          
-          # Set tags
-          if node_attrs.tags && !node_attrs.tags.empty?
-            tags node_attrs.tags
-          end
-        end
-        
-        # Return resource reference with available outputs
-        ResourceReference.new(
-          type: 'aws_managedblockchain_ethereum_node',
-          name: name,
-          resource_attributes: node_attrs.to_h,
-          outputs: {
-            arn: "${aws_managedblockchain_ethereum_node.#{name}.arn}",
-            id: "${aws_managedblockchain_ethereum_node.#{name}.id}",
-            node_id: "${aws_managedblockchain_ethereum_node.#{name}.node_id}",
-            network_id: "${aws_managedblockchain_ethereum_node.#{name}.network_id}",
-            status: "${aws_managedblockchain_ethereum_node.#{name}.status}",
-            creation_date: "${aws_managedblockchain_ethereum_node.#{name}.creation_date}",
-            endpoint: "${aws_managedblockchain_ethereum_node.#{name}.endpoint}",
-            instance_type: "${aws_managedblockchain_ethereum_node.#{name}.instance_type}"
-          },
-          computed: {
-            is_mainnet_node: node_attrs.is_mainnet_node?,
-            is_testnet_node: node_attrs.is_testnet_node?,
-            instance_family: node_attrs.instance_family,
-            instance_size: node_attrs.instance_size,
-            estimated_monthly_cost: node_attrs.estimated_monthly_cost,
-            storage_capacity_gb: node_attrs.storage_capacity_gb,
-            network_throughput_mbps: node_attrs.network_throughput_mbps,
-            supports_archival_data: node_attrs.supports_archival_data?,
-            is_high_availability: node_attrs.is_high_availability?,
-            blockchain_protocol: node_attrs.blockchain_protocol
-          }
-        )
-      end
-    end
-  end
-end
-
-# Auto-register this module when it's loaded
-Pangea::ResourceRegistry.register(:aws, Pangea::Resources::AWS)

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

@@ -1,349 +0,0 @@
-# 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 Ethereum Node resources
-      class ManagedBlockchainEthereumNodeAttributes < Dry::Struct
-        transform_keys(&:to_sym)
-
-        # Network ID (required)
-        attribute :network_id, Resources::Types::String.enum(
-          'n-ethereum-mainnet',
-          'n-ethereum-goerli',
-          'n-ethereum-rinkeby'
-        )
-
-        # Node configuration (required)
-        attribute :node_configuration, Resources::Types::Hash.schema(
-          instance_type: Resources::Types::String.enum(
-            'bc.t3.small',
-            'bc.t3.medium',
-            'bc.t3.large',
-            'bc.t3.xlarge',
-            'bc.m5.large',
-            'bc.m5.xlarge',
-            'bc.m5.2xlarge',
-            'bc.m5.4xlarge',
-            'bc.c5.large',
-            'bc.c5.xlarge',
-            'bc.c5.2xlarge',
-            'bc.c5.4xlarge',
-            'bc.r5.large',
-            'bc.r5.xlarge',
-            'bc.r5.2xlarge',
-            'bc.r5.4xlarge'
-          ),
-          availability_zone?: Resources::Types::String.optional,
-          subnet_id?: Resources::Types::String.optional
-        )
-
-        # Client request token (optional)
-        attribute? :client_request_token, 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 availability zone format if provided
-          if attrs.node_configuration[:availability_zone]
-            az = attrs.node_configuration[:availability_zone]
-            unless az.match?(/\A[a-z0-9\-]+[a-z]\z/)
-              raise Dry::Struct::Error, "availability_zone must be a valid AWS availability zone format"
-            end
-          end
-
-          # Validate subnet ID format if provided
-          if attrs.node_configuration[:subnet_id]
-            subnet_id = attrs.node_configuration[:subnet_id]
-            unless subnet_id.match?(/\Asubnet-[a-f0-9]{8,17}\z/)
-              raise Dry::Struct::Error, "subnet_id must be a valid AWS subnet ID format"
-            end
-          end
-
-          # Validate client request token format if provided
-          if attrs.client_request_token
-            unless attrs.client_request_token.match?(/\A[a-zA-Z0-9\-_]{1,64}\z/)
-              raise Dry::Struct::Error, "client_request_token must be 1-64 characters long and contain only alphanumeric characters, hyphens, and underscores"
-            end
-          end
-
-          # Validate instance type suitability for network
-          instance_type = attrs.node_configuration[:instance_type]
-          if attrs.network_id == 'n-ethereum-mainnet'
-            # Mainnet requires more robust instances
-            if instance_type.start_with?('bc.t3.small', 'bc.t3.medium')
-              raise Dry::Struct::Error, "Ethereum mainnet requires at least bc.t3.large instance type"
-            end
-          end
-
-          attrs
-        end
-
-        # Helper methods
-        def is_mainnet_node?
-          network_id == 'n-ethereum-mainnet'
-        end
-
-        def is_testnet_node?
-          network_id != 'n-ethereum-mainnet'
-        end
-
-        def instance_family
-          # Extract family from instance type: bc.t3.large -> t3
-          instance_type = node_configuration[:instance_type]
-          parts = instance_type.split('.')
-          return 'unknown' if parts.length < 2
-          parts[1]
-        end
-
-        def instance_size
-          # Extract size from instance type: bc.t3.large -> large
-          instance_type = node_configuration[:instance_type]
-          parts = instance_type.split('.')
-          return 'unknown' if parts.length < 3
-          parts[2]
-        end
-
-        def estimated_monthly_cost
-          # Rough cost estimates per instance type (USD per month)
-          instance_costs = {
-            'bc.t3.small' => 29.20,
-            'bc.t3.medium' => 58.40,
-            'bc.t3.large' => 116.80,
-            'bc.t3.xlarge' => 233.60,
-            'bc.m5.large' => 182.50,
-            'bc.m5.xlarge' => 365.00,
-            'bc.m5.2xlarge' => 730.00,
-            'bc.m5.4xlarge' => 1460.00,
-            'bc.c5.large' => 163.84,
-            'bc.c5.xlarge' => 327.68,
-            'bc.c5.2xlarge' => 655.36,
-            'bc.c5.4xlarge' => 1310.72,
-            'bc.r5.large' => 240.44,
-            'bc.r5.xlarge' => 480.88,
-            'bc.r5.2xlarge' => 961.76,
-            'bc.r5.4xlarge' => 1923.52
-          }
-
-          base_cost = instance_costs[node_configuration[:instance_type]] || 200.0
-
-          # Add premium for mainnet
-          mainnet_multiplier = is_mainnet_node? ? 1.5 : 1.0
-
-          base_cost * mainnet_multiplier
-        end
-
-        def storage_capacity_gb
-          # Estimated storage capacity based on instance type
-          case instance_family
-          when 't3'
-            case instance_size
-            when 'small'
-              250
-            when 'medium'
-              500
-            when 'large', 'xlarge'
-              1000
-            else
-              500
-            end
-          when 'm5'
-            case instance_size
-            when 'large'
-              1000
-            when 'xlarge'
-              2000
-            when '2xlarge'
-              4000
-            when '4xlarge'
-              8000
-            else
-              2000
-            end
-          when 'c5'
-            case instance_size
-            when 'large'
-              750
-            when 'xlarge'
-              1500
-            when '2xlarge'
-              3000
-            when '4xlarge'
-              6000
-            else
-              1500
-            end
-          when 'r5'
-            case instance_size
-            when 'large'
-              1500
-            when 'xlarge'
-              3000
-            when '2xlarge'
-              6000
-            when '4xlarge'
-              12000
-            else
-              3000
-            end
-          else
-            1000
-          end
-        end
-
-        def network_throughput_mbps
-          # Network performance based on instance family
-          case instance_family
-          when 't3'
-            case instance_size
-            when 'small'
-              100
-            when 'medium'
-              250
-            when 'large'
-              500
-            when 'xlarge'
-              1000
-            else
-              250
-            end
-          when 'm5', 'c5', 'r5'
-            case instance_size
-            when 'large'
-              750
-            when 'xlarge'
-              1250
-            when '2xlarge'
-              2500
-            when '4xlarge'
-              5000
-            else
-              1250
-            end
-          else
-            500
-          end
-        end
-
-        def supports_archival_data?
-          # Larger instances support archival data
-          storage_capacity_gb >= 2000
-        end
-
-        def is_high_availability?
-          # Subnet ID indicates VPC deployment for HA
-          !node_configuration[:subnet_id].nil?
-        end
-
-        def blockchain_protocol
-          'ethereum'
-        end
-
-        def network_name
-          case network_id
-          when 'n-ethereum-mainnet'
-            'mainnet'
-          when 'n-ethereum-goerli'
-            'goerli'
-          when 'n-ethereum-rinkeby'
-            'rinkeby'
-          else
-            'unknown'
-          end
-        end
-
-        def is_burstable_instance?
-          instance_family == 't3'
-        end
-
-        def is_compute_optimized?
-          instance_family == 'c5'
-        end
-
-        def is_memory_optimized?
-          instance_family == 'r5'
-        end
-
-        def is_general_purpose?
-          ['m5', 't3'].include?(instance_family)
-        end
-
-        # Get synchronization mode
-        def sync_mode
-          if is_mainnet_node? && storage_capacity_gb >= 4000
-            'full' # Full node with complete blockchain data
-          elsif storage_capacity_gb >= 1000
-            'fast' # Fast sync mode
-          else
-            'light' # Light client mode
-          end
-        end
-
-        # Calculate performance score
-        def performance_score
-          score = 0
-          
-          # Base score by instance family
-          case instance_family
-          when 't3'
-            score += 50 # Burstable, good for light workloads
-          when 'm5'
-            score += 80 # Balanced, good for general use
-          when 'c5'
-            score += 90 # Compute optimized, excellent for sync
-          when 'r5'
-            score += 85 # Memory optimized, good for large state
-          end
-          
-          # Size bonus
-          case instance_size
-          when 'small'
-            score += 0
-          when 'medium'
-            score += 10
-          when 'large'
-            score += 20
-          when 'xlarge'
-            score += 30
-          when '2xlarge'
-            score += 40
-          when '4xlarge'
-            score += 50
-          end
-          
-          # Network bonus
-          score += 10 if is_high_availability?
-          score += 5 if supports_archival_data?
-          
-          [score, 0].max
-        end
-      end
-    end
-      end
-    end
-  end
-end