EVM Backend Demo for Ethscriptions

.gitignore

@@ -31,3 +31,5 @@
 
 # Ignore master key for decrypting credentials and more.
 /config/master.key
+
+.DS_Store

.gitmodules

@@ -0,0 +1,12 @@
+[submodule "contracts/lib/forge-std"]
+	path = contracts/lib/forge-std
+	url = https://github.com/foundry-rs/forge-std
+[submodule "contracts/lib/openzeppelin-contracts"]
+	path = contracts/lib/openzeppelin-contracts
+	url = https://github.com/OpenZeppelin/openzeppelin-contracts
+[submodule "contracts/lib/solady"]
+	path = contracts/lib/solady
+	url = https://github.com/vectorized/solady
+[submodule "contracts/lib/openzeppelin-contracts-upgradeable"]
+	path = contracts/lib/openzeppelin-contracts-upgradeable
+	url = https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable

Gemfile

@@ -6,7 +6,7 @@ ruby "3.2.2"
 gem "rails", "~> 7.1.2"
 
 # Use postgresql as the database for Active Record
-gem "pg", "~> 1.1"
+gem "pg", "1.6.2"
 
 # Use the Puma web server [https://github.com/puma/puma]
 gem "puma", ">= 5.0"
@@ -48,6 +48,9 @@ gem "dotenv-rails", "~> 2.8", groups: [:development, :test]
 
 gem "httpparty", "~> 0.2.0"
 
+# For Ethscription content compression
+gem "fastlz", "~> 0.1.0"
+
 gem "clockwork", "~> 3.0"
 
 gem "dalli", "~> 3.2"

Gemfile.lock

@@ -128,6 +128,7 @@ GEM
       openssl (>= 2.2, < 4.0)
       rbsecp256k1 (~> 6.0)
       scrypt (~> 3.0)
+    fastlz (0.1.0)
     ffi (1.16.3)
     ffi-compiler (1.0.1)
       ffi (>= 1.0.0)
@@ -202,7 +203,9 @@ GEM
     parser (3.2.2.4)
       ast (~> 2.4.1)
       racc
-    pg (1.5.4)
+    pg (1.6.2-aarch64-linux)
+    pg (1.6.2-arm64-darwin)
+    pg (1.6.2-x86_64-linux)
     pkg-config (1.5.6)
     pry (0.14.2)
       coderay (~> 1.1)
@@ -332,12 +335,13 @@ DEPENDENCIES
   dotenv-rails (~> 2.8)
   eth (~> 0.5.11)
   facet_rails_common!
+  fastlz (~> 0.1.0)
   httparty (~> 0.21.0)
   httpparty (~> 0.2.0)
   kaminari (~> 1.2)
   memoist (~> 0.16.2)
   order_query (~> 0.5.3)
-  pg (~> 1.1)
+  pg (= 1.6.2)
   pry
   puma (>= 5.0)
   rack-cors (~> 2.0)

app/models/concerns/evm_ethscription_processor.rb

@@ -0,0 +1,185 @@
+# Module to handle EVM-based ethscription processing
+# Replaces direct database writes with contract calls
+module EvmEthscriptionProcessor
+  extend ActiveSupport::Concern
+
+  # Create ethscription from input via EVM
+  def create_ethscription_from_input!
+    # Protocol signal detection - both conditions must be met for a valid creation attempt:
+    # 1. Valid data URI format (user is using the protocol)
+    # 2. Has a recipient (required for ethscription creation)
+    return unless DataUri.valid?(utf8_input) && to_address.present?
+
+    # Check if this is a token operation
+    token_op = detect_token_operation(utf8_input)
+
+    # Build parameters - just translate what the user provided
+    params = if token_op
+      EthscriptionsParamMapper.build_create_params_from_input(self, token_op)
+    else
+      EthscriptionsParamMapper.build_create_params_from_input(self)
+    end
+
+    # Skip if params are malformed (shouldn't happen with valid data URI)
+    return unless EthscriptionsParamMapper.params_well_formed?(params, :createEthscription)
+
+    # Send to contract
+    send_to_ethscriptions_contract(:createEthscription, params, from_address: from_address)
+  end
+
+  # Create ethscription from events via EVM
+  def create_ethscription_from_events!
+    ethscription_creation_events.each do |creation_event|
+      next if creation_event['topics'].length != 2
+
+      begin
+        initial_owner = Eth::Abi.decode(['address'], creation_event['topics'].second).first
+        content_uri_data = Eth::Abi.decode(['string'], creation_event['data']).first
+        content_uri = HexDataProcessor.clean_utf8(content_uri_data)
+      rescue Eth::Abi::DecodingError
+        # Can't decode the event - skip it
+        next
+      end
+
+      # Build parameters - just translate what's in the event
+      params = EthscriptionsParamMapper.build_create_params(
+        self,
+        creator: creation_event['address'],
+        initial_owner: initial_owner,
+        content_uri: content_uri
+      )
+
+      # Skip if params are malformed
+      next unless EthscriptionsParamMapper.params_well_formed?(params, :createEthscription)
+
+      # Send to contract
+      send_to_ethscriptions_contract(:createEthscription, params, from_address: creation_event['address'])
+    end
+  end
+
+  # Create transfers from input via EVM
+  def create_ethscription_transfers_from_input!
+    return unless transfers_ethscription_via_input?
+
+    concatenated_hashes = input_no_prefix.scan(/.{64}/).map { |hash| "0x#{hash}" }
+
+    # Process each transfer individually to allow partial success
+    # (some transfers may fail while others succeed)
+    concatenated_hashes.each do |ethscription_tx_hash|
+      params = EthscriptionsParamMapper.build_transfer_params(
+        ethscription_tx_hash: ethscription_tx_hash,
+        to_address: to_address
+      )
+
+      # Skip if params are malformed
+      next unless EthscriptionsParamMapper.params_well_formed?(params, :transferEthscription)
+
+      # Send individual transfer to contract
+      send_to_ethscriptions_contract(:transferEthscription, params, from_address: from_address)
+    end
+  end
+
+  # Create transfers from events via EVM
+  def create_ethscription_transfers_from_events!
+    ethscription_transfer_events.each do |log|
+      topics = log['topics']
+      event_type = topics.first
+
+      ethscription_tx_hash = nil
+      to_address = nil
+      from_address = log['address']
+
+      if event_type == Esip1EventSig
+        next if topics.length != 3
+
+        begin
+          to_address = Eth::Abi.decode(['address'], topics.second).first
+          ethscription_tx_hash = Eth::Util.bin_to_prefixed_hex(
+            Eth::Abi.decode(['bytes32'], topics.third).first
+          )
+        rescue Eth::Abi::DecodingError
+          next
+        end
+      elsif event_type == Esip2EventSig
+        next if topics.length != 4
+
+        begin
+          event_previous_owner = Eth::Abi.decode(['address'], topics.second).first
+          to_address = Eth::Abi.decode(['address'], topics.third).first
+          ethscription_tx_hash = Eth::Util.bin_to_prefixed_hex(
+            Eth::Abi.decode(['bytes32'], topics.fourth).first
+          )
+        rescue Eth::Abi::DecodingError
+          next
+        end
+
+        # ESIP-2: Transfer for previous owner - use different contract method
+        params = EthscriptionsParamMapper.build_transfer_for_previous_owner_params(
+          ethscription_tx_hash: ethscription_tx_hash,
+          to_address: to_address,
+          previous_owner: event_previous_owner
+        )
+
+        # Skip if params are malformed
+        next unless EthscriptionsParamMapper.params_well_formed?(params, :transferEthscriptionForPreviousOwner)
+
+        # Send to contract
+        send_to_ethscriptions_contract(:transferEthscriptionForPreviousOwner, params, from_address: from_address)
+        next
+      end
+
+      next unless ethscription_tx_hash && to_address
+
+      # ESIP-1: Regular transfer
+      params = EthscriptionsParamMapper.build_transfer_params(
+        ethscription_tx_hash: ethscription_tx_hash,
+        to_address: to_address
+      )
+
+      # Skip if params are malformed
+      next unless EthscriptionsParamMapper.params_well_formed?(params, :transferEthscription)
+
+      # Send to contract
+      send_to_ethscriptions_contract(:transferEthscription, params, from_address: from_address)
+    end
+  end
+
+  private
+
+  # Detect if this is a token operation (deploy or mint)
+  def detect_token_operation(content_uri)
+    return nil unless content_uri.start_with?('data:,')
+
+    begin
+      json_str = content_uri.sub('data:,', '')
+      json = JSON.parse(json_str)
+
+      # Check if it's a token operation
+      return nil unless json['p'].present? && (json['op'] == 'deploy' || json['op'] == 'mint')
+
+      {
+        protocol: json['p'],
+        operation: json['op'],
+        tick: json['tick'],
+        max: json['max']&.to_i,
+        lim: json['lim']&.to_i,
+        id: json['id']&.to_i,
+        amt: json['amt']&.to_i
+      }
+    rescue JSON::ParserError
+      nil
+    end
+  end
+
+  # Simplified contract call - in production this would use the engine API
+  def send_to_ethscriptions_contract(method, params, from_address:)
+    Rails.logger.info({
+      event: "evm_call",
+      method: method,
+      params: params,
+      from_address: from_address,
+      block_number: block_number,
+      transaction_hash: transaction_hash
+    }.to_json)
+  end
+end