ethereum 0.4.42 → 0.4.45

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3986c000b0d2fc54c468722b662b9cbdb605c6a8
-  data.tar.gz: 3d651b3bfbb3026c64ff72adee2dbc370509b752
+  metadata.gz: ce81f0ccd33fa2df00f5fba597d86078e2741ad9
+  data.tar.gz: 172e0bc070a39588a23e2eca4297f50bebc49cfc
 SHA512:
-  metadata.gz: 8de795387db248cb204a2be8159e9fe7ef7528870babeed5fd5815dd3a321449d1a59c507d7ddeb205be37e92f5359bc16424dd7a2fa1689d3f62590341f0752
-  data.tar.gz: d41a91a0139ab397228ea0bc16027ea8062a9e2fd4816b96686259f158c08529c3c003f7bbdf2dd405722dbbffc18f4af7b4bb716a486f4b48ffbb2d5c7a8b19
+  metadata.gz: 63056e204033d1a0606a685ea5097200527fddb3529c592626e2cd2bf70c050d1cc4619c7cf55988783d8fe50d7dea97ff2b55d329eb6ea47c1f50decf6726f4
+  data.tar.gz: 77646073740221587848ba6ea950bb651c1a6c0f847bf3901a26e2548813e323a97093b7e2862403f27c21a00535c754177cbfde129c19c91f7ee6ecbd4dc35c

data/contracts/AccountingLib.sol

@@ -0,0 +1,112 @@
+// Accounting v0.1
+
+/// @title Accounting Lib - Accounting utilities
+/// @author Piper Merriam - <pipermerriam@gmail.com>
+library AccountingLib {
+        struct Bank {
+            mapping (address => uint) accountBalances;
+        }
+
+        /// @dev Low level method for adding funds to an account.  Protects against overflow.
+        /// @param self The Bank instance to operate on.
+        /// @param accountAddress The address of the account the funds should be added to.
+        /// @param value The amount that should be added to the account.
+        function addFunds(Bank storage self, address accountAddress, uint value) public {
+                /*
+                 *  Helper function that should be used for any addition of
+                 *  account funds.  It has error checking to prevent
+                 *  overflowing the account balance.
+                 */
+                if (self.accountBalances[accountAddress] + value < self.accountBalances[accountAddress]) {
+                        // Prevent Overflow.
+                        throw;
+                }
+                self.accountBalances[accountAddress] += value;
+        }
+
+        event _Deposit(address indexed _from, address indexed accountAddress, uint value);
+
+        /// @dev Function wrapper around the _Deposit event so that it can be used by contracts.  Can be used to log a deposit to an account.
+        /// @param _from The address that deposited the funds.
+        /// @param accountAddress The address of the account the funds were added to.
+        /// @param value The amount that was added to the account.
+        function Deposit(address _from, address accountAddress, uint value) public {
+            _Deposit(_from, accountAddress, value);
+        }
+
+        /// @dev Safe function for depositing funds.  Returns boolean for whether the deposit was successful
+        /// @param self The Bank instance to operate on.
+        /// @param accountAddress The address of the account the funds should be added to.
+        /// @param value The amount that should be added to the account.
+        function deposit(Bank storage self, address accountAddress, uint value) public returns (bool) {
+                /*
+                 *  Public API for depositing funds in a specified account.
+                 */
+                if (self.accountBalances[accountAddress] + value < self.accountBalances[accountAddress]) {
+                        return false;
+                }
+                addFunds(self, accountAddress, value);
+                return true;
+        }
+
+        event _Withdrawal(address indexed accountAddress, uint value);
+
+        /// @dev Function wrapper around the _Withdrawal event so that it can be used by contracts.  Can be used to log a withdrawl from an account.
+        /// @param accountAddress The address of the account the funds were withdrawn from.
+        /// @param value The amount that was withdrawn to the account.
+        function Withdrawal(address accountAddress, uint value) public {
+            _Withdrawal(accountAddress, value);
+        }
+
+        event _InsufficientFunds(address indexed accountAddress, uint value, uint balance);
+
+        /// @dev Function wrapper around the _InsufficientFunds event so that it can be used by contracts.  Can be used to log a failed withdrawl from an account.
+        /// @param accountAddress The address of the account the funds were to be withdrawn from.
+        /// @param value The amount that was attempted to be withdrawn from the account.
+        /// @param balance The current balance of the account.
+        function InsufficientFunds(address accountAddress, uint value, uint balance) public {
+            _InsufficientFunds(accountAddress, value, balance);
+        }
+
+        /// @dev Low level method for removing funds from an account.  Protects against underflow.
+        /// @param self The Bank instance to operate on.
+        /// @param accountAddress The address of the account the funds should be deducted from.
+        /// @param value The amount that should be deducted from the account.
+        function deductFunds(Bank storage self, address accountAddress, uint value) public {
+                /*
+                 *  Helper function that should be used for any reduction of
+                 *  account funds.  It has error checking to prevent
+                 *  underflowing the account balance which would be REALLY bad.
+                 */
+                if (value > self.accountBalances[accountAddress]) {
+                        // Prevent Underflow.
+                        throw;
+                }
+                self.accountBalances[accountAddress] -= value;
+        }
+
+        /// @dev Safe function for withdrawing funds.  Returns boolean for whether the deposit was successful as well as sending the amount in ether to the account address.
+        /// @param self The Bank instance to operate on.
+        /// @param accountAddress The address of the account the funds should be withdrawn from.
+        /// @param value The amount that should be withdrawn from the account.
+        function withdraw(Bank storage self, address accountAddress, uint value) public returns (bool) {
+                /*
+                 *  Public API for withdrawing funds.
+                 */
+                if (self.accountBalances[accountAddress] >= value) {
+                        deductFunds(self, accountAddress, value);
+                        if (!accountAddress.send(value)) {
+                                // Potentially sending money to a contract that
+                                // has a fallback function.  So instead, try
+                                // tranferring the funds with the call api.
+                                if (!accountAddress.call.value(value)()) {
+                                        // Revert the entire transaction.  No
+                                        // need to destroy the funds.
+                                        //throw;
+                                }
+                        }
+                        return true;
+                }
+                return false;
+        }
+}

data/contracts/Testing.sol

@@ -0,0 +1,59 @@
+import "contracts/AccountingLib.sol";
+
+contract TestAccounting {
+        AccountingLib.Bank bank;
+        /*
+         *  Account Management API
+         */
+        function getAccountBalance(address accountAddress) constant public returns (uint) {
+                return bank.accountBalances[accountAddress];
+        }
+
+        function deposit() public {
+                deposit(msg.sender);
+        }
+
+        function deposit(address accountAddress) public {
+                /*
+                 *  Public API for depositing funds in a specified account.
+                 */
+                AccountingLib.deposit(bank, accountAddress, msg.value);
+                AccountingLib.Deposit(msg.sender, accountAddress, msg.value);
+        }
+
+        function addFunds(uint value) public {
+                addFunds(msg.sender, value);
+        }
+
+        function addFunds(address accountAddress, uint value) public {
+                AccountingLib.addFunds(bank, accountAddress, value);
+        }
+
+        function withdraw(uint value) public {
+                /*
+                 *  Public API for withdrawing funds.
+                 */
+                if (AccountingLib.withdraw(bank, msg.sender, value)) {
+                        AccountingLib.Withdrawal(msg.sender, value);
+                }
+                else {
+                        AccountingLib.InsufficientFunds(msg.sender, value, bank.accountBalances[msg.sender]);
+                }
+        }
+
+        function deductFunds(uint value) public {
+                deductFunds(msg.sender, value);
+        }
+
+        function deductFunds(address accountAddress, uint value) public {
+                AccountingLib.deductFunds(bank, accountAddress, value);
+        }
+
+        function setAccountBalance(uint value) public {
+                setAccountBalance(msg.sender, value);
+        }
+
+        function setAccountBalance(address accountAddress, uint value) public {
+                bank.accountBalances[accountAddress] = value;
+        }
+}

data/lib/ethereum.rb

@@ -16,4 +16,6 @@ module Ethereum
   require 'ethereum/formatter'
   require 'ethereum/transaction'
   require 'ethereum/deployment'
+  require 'ethereum/project_initializer'
+  require 'ethereum/contract_initializer'
 end

data/lib/ethereum/contract.rb

@@ -30,11 +30,13 @@ module Ethereum
         end
 
         define_method :deploy do |*params|
-          raise "Missing constructor parameter" and return if params.length != constructor_inputs.length
           formatter = Ethereum::Formatter.new
-          constructor_inputs.each_index do |i|
-            args = [constructor_inputs[i]["type"], params[i]]
-            code << formatter.to_payload(args)
+          if constructor_inputs.present?
+            raise "Missing constructor parameter" and return if params.length != constructor_inputs.length
+            constructor_inputs.each_index do |i|
+              args = [constructor_inputs[i]["type"], params[i]]
+              code << formatter.to_payload(args)
+            end
           end
           deploytx = connection.send_transaction({from: self.sender, gas: 2000000, gasPrice: 60000000000, data: code})["result"]
           self.instance_variable_set("@deployment", Ethereum::Deployment.new(deploytx, connection))

data/lib/ethereum/contract_initializer.rb

@@ -0,0 +1,39 @@
+module Ethereum
+
+  class ContractInitializer
+
+    attr_accessor :abi, :binary, :name, :libraries, :needs_linking
+
+    def initialize(contract_name, contract)
+      @abi = JSON.parse(contract["abi"]) unless contract.nil?
+      @binary = contract["bin"] unless contract.nil?
+      @name = contract_name
+      matchdata = /_+[a-zA-Z]+_+/.match(@binary)
+      @needs_linking = matchdata.present?
+      if @needs_linking
+        @libraries = matchdata.to_a.collect do |libname|
+          {name: libname.gsub(/_+/,''), sigil: libname}
+        end
+      end
+    end
+
+    def link_libraries
+      if @needs_linking
+        @libraries.each do |library|
+          ENV['ETHEREUM_DEPLOYER_WAIT_TIME'] ||= "120"
+          wait_time = ENV['ETHEREUM_DEPLOYER_WAIT_TIME'].to_i
+          library_instance = library[:name].constantize.new
+          library_instance.deploy_and_wait(wait_time)
+          @binary.gsub!(library[:sigil], library_instance.address.gsub(/^0x/,''))
+        end
+      end
+    end
+
+    def build(connection)
+      contract = Ethereum::Contract.new(@name, @binary, @abi) 
+      contract.build(connection)
+    end
+
+  end
+
+end

data/lib/ethereum/project_initializer.rb

@@ -0,0 +1,22 @@
+module Ethereum
+
+  class ProjectInitializer
+
+    attr_accessor :contract_names, :combined_output, :contracts
+
+    def initialize(location)
+      ENV['ETHEREUM_SOLIDITY_BINARY'] ||= "/usr/local/bin/solc"
+      solidity = ENV['ETHEREUM_SOLIDITY_BINARY']
+      contract_dir = location
+      compile_command = "#{solidity} --combined-json abi,bin #{contract_dir}"
+      raw_data = `#{compile_command}`
+      data = JSON.parse(raw_data)
+      @contract_names = data["contracts"].keys
+      @contracts = @contract_names.collect do |contract_name|
+        ContractInitializer.new(contract_name, data["contracts"][contract_name])
+      end
+    end
+
+  end
+
+end

data/lib/ethereum/version.rb

@@ -1,3 +1,3 @@
 module Ethereum
-  VERSION = "0.4.42"
+  VERSION = "0.4.45"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ethereum
 version: !ruby/object:Gem::Version
-  version: 0.4.42
+  version: 0.4.45
 platform: ruby
 authors:
 - DigixGlobal Pte Ltd (https://dgx.io)
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-21 00:00:00.000000000 Z
+date: 2015-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -114,11 +114,14 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- contracts/AccountingLib.sol
+- contracts/Testing.sol
 - ethereum.gemspec
 - lib/ethereum.rb
 - lib/ethereum/client.rb
 - lib/ethereum/contract.rb
 - lib/ethereum/contract_event.rb
+- lib/ethereum/contract_initializer.rb
 - lib/ethereum/deployment.rb
 - lib/ethereum/formatter.rb
 - lib/ethereum/function.rb
@@ -127,6 +130,7 @@ files:
 - lib/ethereum/http_client.rb
 - lib/ethereum/initializer.rb
 - lib/ethereum/ipc_client.rb
+- lib/ethereum/project_initializer.rb
 - lib/ethereum/transaction.rb
 - lib/ethereum/version.rb
 homepage: https://github.com/DigixGlobal/ethereum-ruby