Add transaction representation

Author: AnotherRegularDude

app/entity/block.rb

@@ -4,12 +4,11 @@ class Entity::Block < Entity::Base
   attribute :index, Types::Integer
   attribute :previous_hash, Types::String
   attribute :timestamp, Types::Integer
-
-  attribute :data, Types::Array
-
   attribute :nonce, Types::Integer.default(0)
   attribute :block_hash, Types::String.optional.default(nil)
 
+  attribute :data, Types::Array
+
   def self.build_genesis(difficulty)
     new(index: 0, previous_hash: "0" * 64, timestamp: Time.now.utc.to_i, data: ["Initial block"]).mine!(difficulty)
   end

app/entity/transaction.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Entity::Transaction < Entity::Base
+  attribute :id, Types::String.optional.default(nil)
+  attribute :inputs, Types::Array.of(Types.Instance(Value::Transaction::Input)).constrained(min_size: 1)
+  attribute :outputs, Types::Array.of(Types.Instance(Value::Transaction::Output)).constrained(min_size: 1)
+
+  def self.build(inputs, outputs)
+    new(inputs:, outputs:).calculate_id!
+  end
+
+  def calculate_id!
+    self.id ||= Digest::SHA256.hexdigest([inputs, outputs].flatten.join("|"))
+    self
+  end
+
+  alias to_s id
+end

app/value/base.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Value::Base < Dry::Struct
+  transform_keys(&:to_sym)
+end

app/value/transaction/input.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Value::Transaction::Input < Value::Base
+  attribute :transaction_id, Types::String
+  attribute :output_index, Types::Integer
+
+  def to_s
+    "#{transaction_id}:#{output_index}"
+  end
+end

app/value/transaction/output.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Value::Transaction::Output < Value::Base
+  attribute :address, Types::String
+  attribute :amount, Types::Decimal.constrained(gteq: BigDecimal("0"))
+
+  def to_s
+    "#{address}:#{amount}"
+  end
+end

config.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 # Standard libraries
+require "bigdecimal"
 require "digest"
 require "time"
 

spec/entity/transaction_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+describe Entity::Transaction do
+  subject(:transaction) { described_class.build(inputs, outputs) }
+
+  let(:inputs) { [input] }
+  let(:input) { Value::Transaction::Input.new(transaction_id: "0" * 64, output_index: 0) }
+  let(:outputs) { [output] }
+  let(:output) { Value::Transaction::Output.new(address: "some_wallet_address", amount: BigDecimal("0.1")) }
+
+  context "when new transaction are built" do
+    let(:expected_transaction_id) { "809d7b433611e9614857f6647132b04db9478810840416ba5c9ac5db91628b00" }
+
+    it "creates a new transaction with the correct id, inputs and outputs" do
+      expect(transaction.id).to eq(expected_transaction_id)
+
+      expect(transaction.inputs.size).to eq(1)
+      expect(transaction.inputs.first).to be_a(Value::Transaction::Input)
+      expect(transaction.inputs.first.transaction_id).to eq("0" * 64)
+      expect(transaction.inputs.first.output_index).to eq(0)
+
+      expect(transaction.outputs.size).to eq(1)
+      expect(transaction.outputs.first).to be_a(Value::Transaction::Output)
+      expect(transaction.outputs.first.address).to eq("some_wallet_address")
+      expect(transaction.outputs.first.amount).to eq(BigDecimal("0.1"))
+    end
+  end
+
+  context "with multiple inputs and outputs" do
+    let(:expected_transaction_id) { "e4fa40425e82357e636f0e74937c7338fade9adade22a65d92d68f2eb37787b7" }
+
+    let(:inputs) do
+      [
+        Value::Transaction::Input.new(transaction_id: "0" * 64, output_index: 0),
+        Value::Transaction::Input.new(transaction_id: "1" * 64, output_index: 1),
+      ]
+    end
+    let(:outputs) do
+      [
+        Value::Transaction::Output.new(address: "address1", amount: BigDecimal("0.5")),
+        Value::Transaction::Output.new(address: "address2", amount: BigDecimal("0.3")),
+      ]
+    end
+
+    it "creates transaction with multiple inputs and outputs" do
+      expect(transaction.id).to eq(expected_transaction_id)
+
+      expect(transaction.inputs.size).to eq(2)
+      expect(transaction.outputs.size).to eq(2)
+      expect(transaction.inputs.map(&:transaction_id)).to eq(["0" * 64, "1" * 64])
+      expect(transaction.outputs.map(&:address)).to eq(%w[address1 address2])
+    end
+  end
+
+  context "with empty inputs" do
+    let(:inputs) { [] }
+    let(:part_of_error_message) { "has invalid type for :inputs violates constraints" }
+
+    it "raises an error" do
+      expect { transaction }.to raise_error(Dry::Struct::Error, a_string_including(part_of_error_message))
+    end
+  end
+
+  context "with empty outputs" do
+    let(:outputs) { [] }
+    let(:part_of_error_message) { "has invalid type for :outputs violates constraints" }
+
+    it "raises an error" do
+      expect { transaction }.to raise_error(Dry::Struct::Error, a_string_including(part_of_error_message))
+    end
+  end
+
+  context "with invalid input type" do
+    let(:inputs) { ["invalid"] }
+
+    it "raises a type error" do
+      expect { transaction }.to raise_error(Dry::Struct::Error)
+    end
+  end
+
+  context "with invalid output type" do
+    let(:outputs) { ["invalid"] }
+
+    it "raises a type error" do
+      expect { transaction }.to raise_error(Dry::Struct::Error)
+    end
+  end
+
+  context "with negative amount" do
+    let(:output) { Value::Transaction::Output.new(address: "address", amount: BigDecimal("-0.1")) }
+
+    it "raises an error for negative amount" do
+      expect { transaction }.to raise_error(Dry::Struct::Error)
+    end
+  end
+end