nanorpc 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0b7a934ccc76ee58cb1d9b215e908cd4c7dc4ccf
+  data.tar.gz: 927b083e41c50ef9f3ad62bcda79137e4e9bde16
+SHA512:
+  metadata.gz: 77372ba1890225c4cf9c12bbdd608f17a3921ed922a74a024b0b64167a4745888c9f8fa104a9f2c3501a816d73aeaed80c2067e0e6ac3ec62d4b77301e040fa4
+  data.tar.gz: ccca390ab6dede2c3f20e918fb4809358ee8d34a127083bb992fef9cd7a0a207a01e509c93956bdf9d36a217fa287b342bf1ca6f15450702c4a73a62230cffa9

data/lib/account.rb

@@ -0,0 +1,187 @@
+require_relative "configuration.rb"
+
+class ImmutableAccountError < StandardError
+    def initialize(msg="Account must be mutable to perform this action")
+        super
+    end
+end
+
+# A Nano account which has an address and a blockchain.
+class NanoAccount
+    attr_accessor :address, :public_key, :private_key
+
+    # Create a new +NanoAccount+ instance representing an existing account.
+    # +public_key+ and +private_key+ are optional, but without them the account is immutable.
+    # Params:
+    # +address+:: The address of the account.
+    # +public_key+:: (Optional) The public key of the account.
+    # +private_key+:: (Optional) The private key of the account.
+    # +representative+:: (Optional) This block's representative. Required only if the account must be opened.
+    def initialize(address, public_key=nil, private_key=nil, representative=nil)
+        @address = address
+        @public_key = public_key
+        @private_key = private_key
+        @representative = representative || address
+    end
+
+    # Generate a new Nano account and return a mutable +NanoAccount+ instance for it.
+    # Params:
+    # +representative+:: (Optional) This account's representative. Set to the account itself if not specified.
+    # Returns:
+    # A +NanoAccount+ instance for the new account.
+    def self.generate(representative=nil)
+        result = NanoConfiguration.client.key_create
+        NanoAccount.new(
+            result["account"],
+            result["public"],
+            result["private"],
+            representative
+        ) 
+    end
+
+    # A boolean indicating whether +public_key+ and +private_key+ are specified.
+    def mutable?
+        @private_key != nil && @public_key != nil
+    end
+
+    # The list of pending transactions for this account.
+    def pending_transactions
+        res = NanoConfiguration.client.accounts_pending(accounts: [ @address ])["blocks"][@address]
+        res = [] if res == nil
+
+        res
+    end
+
+    # The number of blocks on this account's chain.
+    def block_count
+        begin
+            NanoConfiguration.client.account_block_count(account: @address)["block_count"].to_i
+        rescue => error
+            # Unopened accounts appear to throw instead
+            raise if error.message != "Account not found"
+
+            return 0
+        end
+    end
+
+    # Scan for any pending transactions on this chain and generate 'receive' or 'open' blocks for them.
+    # Requires that this account is mutable.
+    # Returns:
+    # A boolean indicating whether any transactions were pocketed or not.
+    def pocket
+        raise ImmutableAccountError unless mutable?
+
+        # Get pending transactions
+        pending = pending_transactions
+
+        return false if pending.length == 0
+
+        # Determine whether the first processed transaction must be an 'open' block
+        block_type = (block_count == 0 ? "open" : "receive")
+        
+        pending.each do |pending_hash|
+            # NOTE: This is using implicit PoW
+            if block_type == "open"
+                # Work against the public key
+                work = NanoConfiguration.client.work_generate({
+                    hash: @public_key
+                })["work"]
+
+                # Create a block for this 'open' transaction
+                block = NanoConfiguration.client.block_create({
+                    type: block_type,
+                    key: @private_key,
+                    account: @address,
+                    representative: @representative,
+                    source: pending_hash,
+                    work: work
+                })["block"]
+
+                # Since this block was an 'open', ensure that the next one is a 'receive'
+                block_type = "receive"
+            else
+                # Get the frontier of this chain
+                frontier = NanoConfiguration.client.account_info({
+                    account: @address,
+                    count: 1
+                })["frontier"]
+
+                # Work against the frontier
+                work = NanoConfiguration.client.work_generate({
+                    hash: frontier
+                })["work"]
+
+                # Create a block for this 'receive' transaction 
+                block = NanoConfiguration.client.block_create({
+                    type: block_type,
+                    key: @private_key,
+                    account: @address,
+                    source: pending_hash,
+                    previous: frontier,
+                    work: work
+                })["block"]
+            end
+
+            print "Block is: "
+            p block
+
+            # Publish the new block
+            NanoConfiguration.client.process(block: block)
+        end
+
+        true
+    end
+
+    # Send an amount of Nano to another address.
+    # Params:
+    # +amount+:: The amount of raw Nano to send.
+    # +recipient+:: The recipient account of the Nano, as a string or +NanoAccount+.
+    def send(amount, recipient)
+        raise ImmutableAccountError unless mutable?
+
+        if recipient.is_a?(String)
+            recipient = NanoAccount.new(recipient)
+        end
+
+        # Get the frontier of this chain
+        frontier = NanoConfiguration.client.account_info({
+            account: @address,
+            count: 1
+        })["frontier"]
+
+        # Work against the frontier
+        work = NanoConfiguration.client.work_generate({
+            hash: frontier
+        })["work"]
+
+        # Create a 'send' block
+        block = NanoConfiguration.client.block_create({
+            type: "send",
+            key: @private_key,
+            account: @address,
+            destination: recipient.address,
+            previous: frontier,
+            work: work,
+            amount: amount.to_i.to_s,
+            balance: balance
+        })["block"]
+
+        # Publish the block
+        NanoConfiguration.client.process(block: block)
+    end
+
+    # The total balance of the account, including unpocketed balances.
+    def total_balance
+        balance + pending_balance
+    end
+
+    # The balance of the account, not including unpocketed transactions.
+    def balance
+        NanoConfiguration.client.account_balance(account: @address)["balance"]
+    end
+
+    # The unpocketed balance of the account.
+    def pending_balance
+        NanoConfiguration.client.account_balance(account: @address)["pending"]
+    end
+end

data/lib/clients.rb

@@ -0,0 +1,62 @@
+require "http"
+require "bigdecimal"
+
+class RpcError < StandardError
+end
+
+# A simple client for sending data to the RPC server.
+# This is a low-level API; use NanoAccount instead.
+class NanoRpcClient
+    # Create a new client.
+    # Params:
+    # +endpoint+:: The location of the RPC server.
+    def initialize(endpoint)
+        @dispatcher = HTTP 
+        @endpoint = endpoint
+    end
+
+    # Make a request to the endpoint.
+    # Params:
+    # +data+:: A +Hash+ to send to the RPC server.
+    # Returns:
+    # The object returned by the server as a +Hash+.
+    def req(data)
+        res = @dispatcher.post(@endpoint, :json => data).parse
+
+        raise RpcError, res["error"] if res["error"] != nil
+
+        res
+    end
+
+    # Missing methods will make requests to the RPC server using the method name as the action.
+    # The rest of the keyword arguments are passed as JSON data.
+    # Params:
+    # +action+:: The +action+ field of the RPC request.
+    # +kwargs+:: The keyword arguments passed to the method.
+    def method_missing(action, **kwargs)
+        kwargs["action"] = action.to_s
+
+        # Stringify all keys
+        req(kwargs.map{|k, v| [k.to_s, v]}.to_h)
+    end
+
+    # Convert an amount of MRai to a raw Nano quantity.
+    # Params:
+    # +mrai+:: The quantity of MRai.
+    # Returns:
+    # The quantity of raw Nano, stringified.
+    def self.mrai_to_raw(mrai)
+        BigDecimal(mrai) * BigDecimal("1000000000000000000000000000000")
+    end
+end
+
+# A variant of +NanoRpcClient+ which connects public to Nanode servers using an API key.
+class NanodeClient < NanoRpcClient
+    # Create a new Nanode client.
+    # Params: 
+    # +key+:: A valid Nanode API key.
+    def initialize(key)
+        @dispatcher = HTTP.auth(key)
+        @endpoint = "https://api.nanode.co/"
+    end
+end

data/lib/configuration.rb

@@ -0,0 +1,16 @@
+# Configure the NanoRpc library.
+class NanoConfiguration
+    @@client = nil
+
+    # Set the client used to make requests.
+    # +new_client+:: The new client, which should be an instance of +NanoRpcClient+.
+    def self.client=(new_client)
+        @@client = new_client
+    end
+
+    # Get the client used to make requests.
+    def self.client
+        throw "Set NanoConfiguration.client before making RPC calls" if @@client == nil
+        @@client
+    end
+end

data/lib/nanorpc.rb

@@ -0,0 +1,3 @@
+require_relative "account.rb"
+require_relative "clients.rb"
+require_relative "configuration.rb"

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: nanorpc
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Aaron Christiansen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/account.rb
+- lib/clients.rb
+- lib/configuration.rb
+- lib/nanorpc.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.1
+signing_key: 
+specification_version: 4
+summary: Communicate with the Nano/RaiBlocks network
+test_files: []