ic_agent 0.1.1

data/lib/ic_agent/agent.rb

@@ -0,0 +1,176 @@
+require 'cbor'
+require 'ctf_party'
+
+module IcAgent
+  class Request
+    def self.sign_request(req, iden)
+      req_id = IcAgent::Utils.to_request_id(req)
+      msg = IcAgent::IC_REQUEST_DOMAIN_SEPARATOR + req_id
+      sig = iden.sign(msg)
+      envelop = {
+        'content': req,
+        'sender_pubkey': sig[0],
+        'sender_sig': sig[1]
+      }
+
+      if iden.is_a?(DelegateIdentity)
+        envelop.update({
+                         'sender_pubkey': iden.der_pubkey,
+                         'sender_delegation': iden.delegations
+                       })
+      end
+      [req_id, CBOR.encode(envelop)]
+    end
+  end
+
+  class Agent
+    attr_accessor :identity, :client, :ingress_expiry, :root_key, :nonce_factory
+
+    def initialize(identity, client, nonce_factory = nil, ingress_expiry = 300, root_key = IcAgent::IC_ROOT_KEY)
+      @identity = identity
+      @client = client
+      @ingress_expiry = ingress_expiry
+      @root_key = root_key
+      @nonce_factory = nonce_factory
+    end
+
+    def get_principal
+      @identity.sender
+    end
+
+    def get_expiry_date
+      ((Time.now.to_i + @ingress_expiry) * 10**9).to_i
+    end
+
+    def query_endpoint(canister_id, data)
+      ret = @client.query(canister_id, data)
+      decode_ret = nil
+      begin
+        decode_ret = CBOR.decode(ret)
+      rescue CBOR::MalformedFormatError
+        decode_ret = ret
+        # print logger
+      end
+      decode_ret
+    end
+
+    def call_endpoint(canister_id, request_id, data)
+      @client.call(canister_id, request_id, data)
+      request_id
+    end
+
+    def read_state_endpoint(canister_id, data)
+      result = @client.read_state(canister_id, data)
+      result
+    end
+
+    def query_raw(canister_id, method_name, arg, return_type = nil, effective_canister_id = nil)
+      req_canister_id = canister_id.is_a?(String) ? Principal.from_str(canister_id).bytes : canister_id.bytes
+      req = {
+        'request_type' => 'query',
+        'sender' => @identity.sender.bytes,
+        'canister_id' => req_canister_id,
+        'method_name' => method_name,
+        'arg' => arg.hex2str,
+        'ingress_expiry' => get_expiry_date
+      }
+
+      _, data = Request.sign_request(req, @identity)
+      query_canister_id = effective_canister_id.nil? ? canister_id : effective_canister_id
+      result = query_endpoint(query_canister_id, data)
+      raise Exception, "Malformed result: #{result}" unless result.is_a?(CBOR::Tagged) && result.value.key?('status')
+
+      if result.value['status'] == 'replied'
+        arg = result.value['reply']['arg']
+        if arg[0..3] == 'DIDL'
+          IcAgent::Candid.decode(arg.to_hex, return_type)
+        else
+          arg
+        end
+      elsif result.value['status'] == 'rejected'
+        raise Exception, "Canister reject the call: #{result['reject_message']}"
+      end
+    end
+
+    def update_raw(canister_id, method_name, arg, return_type = nil, effective_canister_id = nil, **kwargs)
+      req_canister_id = canister_id.is_a?(String) ? Principal.from_str(canister_id).bytes : canister_id.bytes
+      req = {
+        'request_type' => 'call',
+        'sender' => @identity.sender.bytes,
+        'canister_id' => req_canister_id,
+        'method_name' => method_name,
+        'arg' => arg.hex2str,
+        'ingress_expiry' => get_expiry_date
+      }
+      req_id, data = Request.sign_request(req, @identity)
+      eid = effective_canister_id.nil? ? canister_id : effective_canister_id
+      _ = call_endpoint(eid, req_id, data)
+      status, result = poll(eid, req_id, **kwargs)
+      if status == 'rejected'
+        raise Exception, "Rejected: #{result.to_s}"
+      elsif status == 'replied'
+        if result[0..3] == 'DIDL'
+          IcAgent::Candid.decode(result.to_hex, return_type)
+        else
+          # Some canisters don't use DIDL (e.g. they might encode using json instead)
+          result
+        end
+      else
+        raise Exception, "Timeout to poll result, current status: #{status.to_s}"
+      end
+    end
+
+    def read_state_raw(canister_id, paths)
+      req = {
+        'request_type' => 'read_state',
+        'sender' => @identity.sender.bytes,
+        'paths' => paths,
+        'ingress_expiry' => get_expiry_date
+      }
+      _, data = Request.sign_request(req, @identity)
+      ret = read_state_endpoint(canister_id, data)
+      if ret == 'Invalid path requested.'
+        raise ValueError, 'Invalid path requested!'
+      elsif ret == 'Could not parse body as read request: invalid type: byte array, expected a sequence'
+        raise ValueError, 'Could not parse body as read request: invalid type: byte array, expected a sequence'
+      end
+
+      begin
+        d = CBOR.decode(ret)
+      rescue StandardError
+        raise ValueError, "Unable to decode cbor value: #{ret}"
+      end
+      CBOR.decode(d.value['certificate'])
+    end
+
+    def request_status_raw(canister_id, req_id)
+      paths = [['request_status', req_id]]
+      cert = read_state_raw(canister_id, paths)
+      status = IcAgent::Certificate.lookup(['request_status', req_id, 'status'], cert)
+      [status, cert]
+    end
+
+    def poll(canister_id, req_id, delay = 1, timeout = IcAgent::DEFAULT_POLL_TIMEOUT_SECS)
+      status = nil
+      cert = nil
+      (timeout / delay).to_i.times do
+        status, cert = request_status_raw(canister_id, req_id)
+        break if %w[replied done rejected].include?(status)
+
+        sleep(delay)
+      end
+
+      if status == 'replied'
+        path = ['request_status', req_id, 'reply']
+        res = IcAgent::Certificate.lookup(path, cert)
+        [status, res]
+      elsif status == 'rejected'
+        path = ['request_status', req_id, 'reject_message']
+        msg = IcAgent::Certificate.lookup(path, cert)
+        [status, msg]
+      else
+        [status, _]
+      end
+    end
+  end
+end

data/lib/ic_agent/ast/assembler.rb

@@ -0,0 +1,192 @@
+require 'ic_agent/candid'
+
+module IcAgent
+  module Ast
+    class Assembler
+      TYPE_MAPPING = {}
+
+      def self.build_single_type(child_type)
+        IcAgent::Candid::BaseTypes.send(child_type)
+      end
+
+      def self.build_blob
+        IcAgent::Candid::BaseTypes.vec(IcAgent::Candid::BaseTypes.nat8)
+      end
+
+      def self.build_opt(child_type, key_types = {})
+        child_type = key_types[child_type].nil? ? build_type(child_type, key_types) : key_types[child_type]
+        IcAgent::Candid::BaseTypes.opt(child_type)
+      end
+
+      def self.build_vec(child_type, key_types = {})
+        child_type = key_types[child_type].nil? ? build_type(child_type, key_types) : key_types[child_type]
+        IcAgent::Candid::BaseTypes.vec(child_type)
+      end
+
+      def self.build_record(child_hash, multi_types = {}, key_types = {})
+        child_types = {}
+        child_hash.each_key do |key|
+          if multi_types[child_hash[key].strip]
+            multi_type = build_type(multi_types[child_hash[key].strip], key_types, multi_types)
+            child_types[key] = multi_type
+          elsif key_types[child_hash[key].strip]
+            child_types[key] = key_types[child_hash[key].strip]
+          else
+            child_types[key] = build_type(child_hash[key], key_types, multi_types)
+          end
+        end
+        IcAgent::Candid::BaseTypes.record(child_types)
+      end
+
+      def self.build_variant(child_hash, multi_types = {}, key_types = {})
+        child_types = {}
+        child_hash.each_key do |key|
+          if multi_types[child_hash[key].strip]
+            multi_type = build_type(multi_types[child_hash[key].strip], multi_types)
+            child_types[key] = multi_type
+          elsif key_types[child_hash[key].strip]
+            child_types[key] = key_types[child_hash[key].strip]
+          else
+            child_types[key] = build_type(child_hash[key], key_types, multi_types)
+          end
+        end
+        IcAgent::Candid::BaseTypes.variant(child_types)
+      end
+
+      def self.build_type(type_str, key_types = {}, multi_types = {})
+        opt_code = get_opt_code(type_str)
+
+        if IcAgent::Candid::SINGLE_TYPES.include? opt_code
+          build_single_type(opt_code)
+        elsif opt_code == 'blob'
+          build_blob
+        elsif opt_code == 'opt'
+          type_str = recover_type(type_str, multi_types)
+          child_code = get_child_code(type_str, ' ')
+          build_opt(child_code, key_types)
+        elsif opt_code == 'vec'
+          type_str = recover_type(type_str, multi_types)
+          child_code = get_child_code(type_str, ' ')
+          build_vec(child_code, key_types)
+        elsif opt_code == 'record'
+          child_code = get_record_content(type_str)
+          pure_child_code, multi_types = replace_multi_type(child_code)
+          child_hash = {}
+          key_index = 0
+          pure_child_code.split(';').each do |item|
+            item_key, item_value = get_record_key_value(item, ' : ', key_index)
+            child_hash[item_key] = item_value
+            key_index += 1
+          end
+          build_record(child_hash, multi_types, key_types)
+        elsif opt_code == 'variant'
+          child_code = get_variant_content(type_str)
+          pure_child_code, multi_types = replace_multi_type(child_code)
+          child_hash = {}
+          pure_child_code.split(';').each do |item|
+            item_arr = item.strip.split(' : ')
+            child_hash[item_arr[0]] = (item_arr.size > 1 ? item_arr[1] : 'null')
+          end
+          build_variant(child_hash, multi_types, key_types)
+        end
+      end
+
+      def self.replace_last_occurrence(string, pattern, replacement)
+        last_index = string.rindex(pattern)
+        return string unless last_index
+
+        string[last_index..-1] = replacement
+        string
+      end
+
+      def self.get_record_content(record_str)
+        record_str = record_str.sub('record', '').sub('{', '')
+        record_str = replace_last_occurrence(record_str, '}', '')
+        record_str.strip
+      end
+
+      def self.get_variant_content(variant_str)
+        variant_str = variant_str.sub('variant', '').sub('{', '')
+        variant_str = replace_last_occurrence(variant_str, '}', '')
+        variant_str.strip
+      end
+
+      def self.get_record_key_value(item_str, index_str, key_index = 0)
+        first_index = item_str.index(index_str)
+        if first_index
+          key = item_str[0..first_index].strip
+          value = item_str[(first_index + index_str.size)..].strip
+        else
+          key = key_index.to_s
+          value = item_str.strip
+        end
+        return key, value
+      end
+
+      def self.get_opt_code(item_str)
+        opt_code = item_str.strip
+        opt_code.split(' ')[0]
+      end
+
+      def self.get_child_code(item_str, index_str)
+        first_index = item_str.index(index_str)
+        item_str[(first_index + index_str.size)..].strip
+      end
+
+      def self.replace_multi_type(type_str)
+        replaced_hash = {}
+        modified_str = type_str.gsub(/record\s*{[^{}]*}/) do |match|
+          rad_id = rand(100000..999999)
+          type_name = "record_#{rad_id}"
+          replaced_hash[type_name] = match
+          type_name
+        end
+
+        modified_str = modified_str.gsub(/variant\s*{[^{}]*}/) do |match|
+          rad_id = rand(100000..999999)
+          type_name = "variant_#{rad_id}"
+          replaced_hash[type_name] = match
+          type_name
+        end
+
+        return modified_str, replaced_hash
+      end
+
+      def self.get_params_refer_values(type_str)
+        pure_child_code, replaced_hash = replace_multi_type(type_str)
+        key_index = 0
+        value_arr = []
+        pure_child_code.split(';').each do |item|
+          _, item_value = get_record_key_value(item, ' : ', key_index)
+          value_arr << item_value.split(' ')
+          key_index += 1
+        end
+
+        replaced_hash.each_key do |key|
+          item_arr = replaced_hash[key].strip.split(';')
+          item_arr.each do |item|
+            multi_item_arr = item.strip.split(':')
+            if multi_item_arr.size > 1
+              item_value_arr = multi_item_arr[1].strip.split(' ').collect { |v| v.strip.gsub(';', '') }
+              item_value_arr.delete('{')
+              item_value_arr.delete('}')
+              item_value_arr.delete('{}')
+              value_arr << item_value_arr
+            else
+              value_arr << multi_item_arr[1].strip
+            end
+          end
+          value_arr.delete(key)
+        end
+        value_arr.flatten.uniq - IcAgent::Candid::ALL_TYPES - replaced_hash.keys
+      end
+
+      def self.recover_type(type_str, multi_types)
+        multi_types.each_key do |key|
+          type_str = type_str.gsub(key, multi_types[key])
+        end
+        type_str
+      end
+    end
+  end
+end

data/lib/ic_agent/ast/did_grammar.treetop

@@ -0,0 +1,159 @@
+grammar DIDGrammar
+
+  rule body
+    ( type_declaration / service_declaration / comment / end_of_line )* <IcAgent::Ast::Nodes::DIDFile>
+  end
+
+  rule base_type
+    'bool' / 'text' / 'null' / 'reserved' / 'empty' / 'principal' / 'nat8' / 'nat16' / 'nat32' / 'nat64' / 'int8' / 'int16' / 'int32' / 'int64' / 'float32' / 'float64' /
+    'opt' / 'vec' / 'record' / 'variant' / 'service' / 'func' / 'nat' / 'int' / blob
+  end
+
+  rule base_type_single
+    'bool' / 'text' / 'null' / 'reserved' / 'empty' / 'principal' / 'nat8' / 'nat16' / 'nat32' / 'nat64' / 'int8' / 'int16' / 'int32' / 'int64' / 'float32' / 'float64' / 'nat' / 'int' / 'blob'
+  end
+
+  rule base_type_base
+    base_type_single+ <IcAgent::Ast::Nodes::BaseTypeSingle>
+  end
+
+  rule base_type_code
+    [a-zA-Z0-9_]+ <IcAgent::Ast::Nodes::BaseTypeOther>
+  end
+
+  rule base_type_key
+      [a-zA-Z0-9_]+ <IcAgent::Ast::Nodes::BaseTypeKey>
+  end
+
+  rule base_type_vec
+    'vec' space ic_all_type <IcAgent::Ast::Nodes::BaseTypeVec>
+  end
+
+  rule base_type_opt
+    'opt' space ic_all_type <IcAgent::Ast::Nodes::BaseTypeOpt>
+  end
+
+  rule base_type_record
+    'record' space '{' space_and_line ic_base_content space_and_line '}' <IcAgent::Ast::Nodes::BaseTypeRecord>
+  end
+
+  rule base_type_record_null
+    'record {}' <IcAgent::Ast::Nodes::BaseTypeRecord>
+  end
+
+  rule base_type_variant
+    'variant' space '{' space_and_line ic_base_content space_and_line '}' <IcAgent::Ast::Nodes::BaseTypeVariant>
+  end
+
+  rule base_type_func
+    'func' space? "(" service_method_params? ")" space? "->" space? "(" service_method_return_type ")" space? method_query? <IcAgent::Ast::Nodes::BaseTypeFunc>
+  end
+
+  rule ic_all_type
+    base_type_base / base_type_vec / base_type_record / base_type_record_null / base_type_variant / base_type_opt / base_type_func / base_type_code
+  end
+
+  rule ic_base_content
+    (ic_base_type)+  <IcAgent::Ast::Nodes::BaseTypeContent>
+  end
+
+  rule ic_base_type
+    space? base_type_key space? (':' space ic_all_type)* optional_semicolon <IcAgent::Ast::Nodes::BaseTypeChild>
+  end
+
+  rule type_declaration
+    'type' space_and_line type_name space_and_line '=' space_and_line ic_all_type ';' end_of_line <IcAgent::Ast::Nodes::TypeDeclaration>
+  end
+
+  rule type_name
+    [a-zA-Z0-9_]+ <IcAgent::Ast::Nodes::TypeName>
+  end
+
+  rule comment
+    space? '//' space? rest_of_line <IcAgent::Ast::Nodes::Comment>
+  end
+
+  rule service_declaration
+    "service" space ":" space service_name* "{" end_of_line service_methods "}"  <IcAgent::Ast::Nodes::Service>
+  end
+
+  rule service_name
+    "(" ic_service_name ")" space? "->" space?
+  end
+
+  rule ic_service_name
+    [a-zA-Z0-9_]* <IcAgent::Ast::Nodes::IcServiceName>
+  end
+
+  rule service_methods
+    (service_item)+ <IcAgent::Ast::Nodes::IcServiceMethods>
+  end
+
+  rule service_item
+    space? service_method_name space? ":" space? "(" service_method_params? ")" space? "->" space? "(" service_method_return_type ")" space? method_query? ';' end_of_line? <IcAgent::Ast::Nodes::IcServiceItem>
+  end
+
+  rule service_method_params
+    param_element (", " param_element)* <IcAgent::Ast::Nodes::IcServiceMethodParams>
+  end
+
+  rule service_method_return_type
+    [a-zA-Z0-9_{}: ]* <IcAgent::Ast::Nodes::IcServiceMethodReturn>
+  end
+
+  rule method_query
+    [a-zA-Z0-9_]* <IcAgent::Ast::Nodes::IcServiceMethodQuery>
+  end
+
+  rule words
+    [a-zA-Z_] [a-zA-Z0-9_]*
+  end
+
+  rule param_element
+    [a-zA-Z0-9_ ]+
+  end
+
+  rule service_method_name
+    [a-zA-Z0-9_]* <IcAgent::Ast::Nodes::IcServiceMethodName>
+  end
+
+  rule string_without_spaces
+    [\S]* <IcAgent::Ast::Nodes::StringLiteral>
+  end
+
+  rule rest_of_line
+    [^\n]* <IcAgent::Ast::Nodes::StringLiteral>
+  end
+
+  rule end_of_line
+    [\n]+
+  end
+
+  rule block_record
+    '{}'
+  end
+
+  rule has_end_of_line
+    [\n]*
+  end
+
+  rule splite_code
+    ' : '
+  end
+
+  rule space_and_line
+    [\s\n]*
+  end
+
+  rule space
+    [\s]+
+  end
+
+  rule start_space
+    [^\s]+
+  end
+
+  rule optional_semicolon
+    [;]*
+  end
+end

data/lib/ic_agent/ast/did_grammar_v1.treetop

@@ -0,0 +1,111 @@
+grammar DIDGrammar
+
+  rule body
+    ( type_declaration / service_declaration / comment / end_of_line )* <IcAgent::Ast::Nodes::DIDFile>
+  end
+
+  rule base_type
+    'bool' / 'text' / 'null' / 'reserved' / 'empty' / 'principal' / 'nat' / 'nat8' / 'nat16' / 'nat32' / 'nat64' / 'int' / 'int8' / 'int16' / 'int32' / 'int64' / 'float32' / 'float64' /
+    'opt' / 'vec' / 'record' / 'variant' / 'service' / 'func'
+  end
+
+  rule type_declaration
+    "type" space type_name space "=" space type_input_base_type space "{" end_of_line? type_body "};" end_of_line <IcAgent::Ast::Nodes::TypeDeclaration>
+  end
+
+  rule type_name
+    [a-zA-Z0-9_]+ <IcAgent::Ast::Nodes::TypeName>
+  end
+
+  rule type_body
+    type_body_item* <IcAgent::Ast::Nodes::TypeBody>
+  end
+
+  rule type_input_base_type
+      base_type+ <IcAgent::Ast::Nodes::TypeInputBaseType>
+  end
+
+  rule type_body_item
+    type_body_item_obj (';' space)* <IcAgent::Ast::Nodes::TypeBodyItem>
+  end
+
+  rule type_body_item_obj
+    type_body_item_name ':'? type_body_item_value? <IcAgent::Ast::Nodes::TypeBodyItemObj>
+  end
+
+  rule type_body_item_name
+    [a-zA-Z0-9_ ]+ <IcAgent::Ast::Nodes::TypeBodyItemName>
+  end
+
+  rule type_body_item_value
+    [a-zA-Z0-9_ ]+ <IcAgent::Ast::Nodes::TypeBodyItemValue>
+  end
+
+  rule body_item_element
+    [a-zA-Z0-9_: ]+
+  end
+
+  rule comment
+    space? '//' space? rest_of_line <IcAgent::Ast::Nodes::Comment>
+  end
+
+  rule service_declaration
+    "service" space ":" space "(" ic_service_name ")" space? "->" space? "{" end_of_line service_methods "}"  <IcAgent::Ast::Nodes::Service>
+  end
+
+  rule ic_service_name
+    [a-zA-Z0-9_]* <IcAgent::Ast::Nodes::IcServiceName>
+  end
+
+  rule service_methods
+    (service_item)+ <IcAgent::Ast::Nodes::IcServiceMethods>
+  end
+
+  rule service_item
+    space? service_method_name space? ":" space? "(" service_method_params? ")" space? "->" space? "(" service_method_return_type ")" space? method_query? ';' end_of_line? <IcAgent::Ast::Nodes::IcServiceItem>
+  end
+
+  rule service_method_params
+    param_element (", " param_element)* <IcAgent::Ast::Nodes::IcServiceMethodParams>
+  end
+
+  rule service_method_return_type
+    [a-zA-Z0-9_]* <IcAgent::Ast::Nodes::IcServiceMethodReturn>
+  end
+
+  rule method_query
+    [a-zA-Z0-9_]* <IcAgent::Ast::Nodes::IcServiceMethodQuery>
+  end
+
+  rule words
+    [a-zA-Z_] [a-zA-Z0-9_]*
+  end
+
+  rule param_element
+    [a-zA-Z0-9_ ]+
+  end
+
+  rule service_method_name
+    [a-zA-Z0-9_]* <IcAgent::Ast::Nodes::IcServiceMethodName>
+  end
+
+  rule string_without_spaces
+    [\S]* <IcAgent::Ast::Nodes::StringLiteral>
+  end
+
+  rule rest_of_line
+    [^\n]* <IcAgent::Ast::Nodes::StringLiteral>
+  end
+
+  rule end_of_line
+    [\n]+
+  end
+
+  rule space
+    [\s]+
+  end
+
+  rule start_space
+    [^\s]+
+  end
+end