flow_client 0.1.1 → 0.2.2

data/docker-compose.yml

@@ -0,0 +1,12 @@
+version: "3"
+services:
+  emulator:
+    image: gcr.io/flow-container-registry/emulator:latest
+    ports:
+      - "8080:8080"
+      - "3569:3569"
+    environment:
+      - FLOW_SERVICEPRIVATEKEY=4d9287571c8bff7482ffc27ef68d5b4990f9bd009a1e9fa812aae08ba167d57f
+      - FLOW_SERVICEKEYSIGALGO=ECDSA_P256
+      - FLOW_SERVICEKEYHASHALGO=SHA3_256
+      - FLOW_VERBOSE=true

data/flow.json

@@ -0,0 +1,21 @@
+{
+	"emulators": {
+		"default": {
+			"port": 3569,
+			"serviceAccount": "emulator-account"
+		}
+	},
+	"contracts": {},
+	"networks": {
+		"emulator": "127.0.0.1:3569",
+		"mainnet": "access.mainnet.nodes.onflow.org:9000",
+		"testnet": "access.devnet.nodes.onflow.org:9000"
+	},
+	"accounts": {
+		"emulator-account": {
+			"address": "f8d6e0586b0a20c7",
+			"key": "38a7eef2053e165c2d635fb471fb26c91d9da2914a8f13c58ec210412adb2067"
+		}
+	},
+	"deployments": {}
+}

data/flow_client.gemspec

@@ -7,7 +7,6 @@ Gem::Specification.new do |spec|
   spec.version       = FlowClient::VERSION
   spec.authors       = ["Nico du Plessis"]
   spec.email         = ["nico@glucode.com"]
-
   spec.summary       = "A Ruby client for the Flow blockchain"
   spec.description   = "A Ruby client for the Flow blockchain"
   spec.homepage      = "https://github.com/glucode/flow_client"
@@ -30,14 +29,11 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   # Uncomment to register a new dependency of your gem
-  spec.add_dependency "digest-sha3"
-  spec.add_dependency "ecdsa"
   spec.add_dependency "grpc"
   spec.add_dependency "grpc-tools"
   spec.add_dependency "json"
   spec.add_dependency "openssl"
   spec.add_dependency "rlp"
-  spec.add_dependency "rspec"
 
   # For more information and examples about making a new gem, checkout our
   # guide at: https://bundler.io/guides/creating_gem.html

data/lib/cadence/contracts/NonFungibleToken.cdc

@@ -0,0 +1,144 @@
+/**
+
+## The Flow Non-Fungible Token standard
+
+## `NonFungibleToken` contract interface
+
+The interface that all non-fungible token contracts could conform to.
+If a user wants to deploy a new nft contract, their contract would need
+to implement the NonFungibleToken interface.
+
+Their contract would have to follow all the rules and naming
+that the interface specifies.
+
+## `NFT` resource
+
+The core resource type that represents an NFT in the smart contract.
+
+## `Collection` Resource
+
+The resource that stores a user's NFT collection.
+It includes a few functions to allow the owner to easily
+move tokens in and out of the collection.
+
+## `Provider` and `Receiver` resource interfaces
+
+These interfaces declare functions with some pre and post conditions
+that require the Collection to follow certain naming and behavior standards.
+
+They are separate because it gives the user the ability to share a reference
+to their Collection that only exposes the fields and functions in one or more
+of the interfaces. It also gives users the ability to make custom resources
+that implement these interfaces to do various things with the tokens.
+
+By using resources and interfaces, users of NFT smart contracts can send
+and receive tokens peer-to-peer, without having to interact with a central ledger
+smart contract.
+
+To send an NFT to another user, a user would simply withdraw the NFT
+from their Collection, then call the deposit function on another user's
+Collection to complete the transfer.
+
+*/
+
+// The main NFT contract interface. Other NFT contracts will
+// import and implement this interface
+//
+pub contract interface NonFungibleToken {
+
+    // The total number of tokens of this type in existence
+    pub var totalSupply: UInt64
+
+    // Event that emitted when the NFT contract is initialized
+    //
+    pub event ContractInitialized()
+
+    // Event that is emitted when a token is withdrawn,
+    // indicating the owner of the collection that it was withdrawn from.
+    //
+    // If the collection is not in an account's storage, `from` will be `nil`.
+    //
+    pub event Withdraw(id: UInt64, from: Address?)
+
+    // Event that emitted when a token is deposited to a collection.
+    //
+    // It indicates the owner of the collection that it was deposited to.
+    //
+    pub event Deposit(id: UInt64, to: Address?)
+
+    // Interface that the NFTs have to conform to
+    //
+    pub resource interface INFT {
+        // The unique ID that each NFT has
+        pub let id: UInt64
+    }
+
+    // Requirement that all conforming NFT smart contracts have
+    // to define a resource called NFT that conforms to INFT
+    pub resource NFT: INFT {
+        pub let id: UInt64
+    }
+
+    // Interface to mediate withdraws from the Collection
+    //
+    pub resource interface Provider {
+        // withdraw removes an NFT from the collection and moves it to the caller
+        pub fun withdraw(withdrawID: UInt64): @NFT {
+            post {
+                result.id == withdrawID: "The ID of the withdrawn token must be the same as the requested ID"
+            }
+        }
+    }
+
+    // Interface to mediate deposits to the Collection
+    //
+    pub resource interface Receiver {
+
+        // deposit takes an NFT as an argument and adds it to the Collection
+        //
+        pub fun deposit(token: @NFT)
+    }
+
+    // Interface that an account would commonly 
+    // publish for their collection
+    pub resource interface CollectionPublic {
+        pub fun deposit(token: @NFT)
+        pub fun getIDs(): [UInt64]
+        pub fun borrowNFT(id: UInt64): &NFT
+    }
+
+    // Requirement for the the concrete resource type
+    // to be declared in the implementing contract
+    //
+    pub resource Collection: Provider, Receiver, CollectionPublic {
+
+        // Dictionary to hold the NFTs in the Collection
+        pub var ownedNFTs: @{UInt64: NFT}
+
+        // withdraw removes an NFT from the collection and moves it to the caller
+        pub fun withdraw(withdrawID: UInt64): @NFT
+
+        // deposit takes a NFT and adds it to the collections dictionary
+        // and adds the ID to the id array
+        pub fun deposit(token: @NFT)
+
+        // getIDs returns an array of the IDs that are in the collection
+        pub fun getIDs(): [UInt64]
+
+        // Returns a borrowed reference to an NFT in the collection
+        // so that the caller can read data and call methods from it
+        pub fun borrowNFT(id: UInt64): &NFT {
+            pre {
+                self.ownedNFTs[id] != nil: "NFT does not exist in the collection!"
+            }
+        }
+    }
+
+    // createEmptyCollection creates an empty Collection
+    // and returns it to the caller so that they can own NFTs
+    pub fun createEmptyCollection(): @Collection {
+        post {
+            result.getIDs().length == 0: "The created collection must be empty!"
+        }
+    }
+}

data/lib/cadence/templates/add-account-key.cdc

@@ -0,0 +1,16 @@
+transaction(publicKey: String, weight: UFix64) {
+	prepare(signer: AuthAccount) {
+		// signer.addPublicKey(publicKey.decodeHex())
+
+		let key = PublicKey(
+			publicKey: publicKey.decodeHex(),
+			signatureAlgorithm: SignatureAlgorithm.ECDSA_P256
+		)
+
+		signer.keys.add(
+			publicKey: key,
+			hashAlgorithm: HashAlgorithm.SHA3_256,
+			weight: weight
+		)
+	}
+}

data/lib/cadence/templates/add-contract.cdc

@@ -0,0 +1,5 @@
+transaction(name: String, code: String) {
+	prepare(signer: AuthAccount) {
+		signer.contracts.add(name: name, code: code.decodeHex())
+	}
+}

data/lib/cadence/templates/create-account.cdc

@@ -0,0 +1,21 @@
+transaction(publicKeys: [String], contracts: {String: String}) {
+	prepare(signer: AuthAccount) {
+		let acct = AuthAccount(payer: signer)
+		for keyHex in publicKeys {
+			let key = PublicKey(
+				publicKey: keyHex.decodeHex(),
+				signatureAlgorithm: SignatureAlgorithm.ECDSA_P256
+			)
+
+			acct.keys.add(
+				publicKey: key,
+				hashAlgorithm: HashAlgorithm.SHA3_256,
+				weight: 1000.0
+			)
+		}
+	
+		for contract in contracts.keys {
+			acct.contracts.add(name: contract, code: contracts[contract]!.decodeHex())
+		}
+	}
+}

data/lib/cadence/templates/remove-contract.cdc

@@ -0,0 +1,5 @@
+transaction(name: String) {
+	prepare(signer: AuthAccount) {
+		signer.contracts.remove(name: name)
+	}
+}

data/lib/cadence/templates/update-contract.cdc

@@ -0,0 +1,5 @@
+transaction(name: String, code: String) {
+	prepare(signer: AuthAccount) {
+		signer.contracts.update__experimental(name: name, code: code.decodeHex())
+	}
+}

data/lib/flow_client/account.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module FlowClient
+  class AccountKey
+    attr_accessor :public_key,
+                  :index, :sequence_number,
+                  :sign_algo, :hash_algo,
+                  :weight, :revoked
+
+    def initialize(public_key: nil, index: nil, sequence_number: nil, weight: 1000, revoked: false, hash_algo: FlowClient::Crypto::HashAlgos::SHA3_256)
+      @public_key = public_key
+      @index = index
+      @sequence_number = sequence_number
+      @weight = weight
+      @revoked = revoked
+      @hash_algo = hash_algo
+    end
+  end
+
+  class Account
+    attr_accessor :address, :balance, :keys, :contracts
+
+    def initialize(address: nil, balance: nil, keys: [], contracts: {})
+      @keys = keys
+      @address = address
+      @balance = balance
+      @contracts = contracts
+      @contracts = {}
+    end
+  end
+end

data/lib/flow_client/block.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module FlowClient
+  # Represents a block
+  class Block
+    attr_accessor :id,
+                  :parent_id,
+                  :height,
+                  :timestamp,
+                  :collection_guarantees,
+                  :block_seals,
+                  :signatures
+
+    def initialize
+      @id = nil
+      @parent_id = nil
+      @height = nil
+      @timestamp = nil
+      @collection_guarantees = []
+      @block_seals = []
+      @signatures = []
+    end
+
+    def self.parse_grpc_block_response(block_response)
+      block = Block.new
+      block.id = block_response.block.id.unpack1("H*")
+      block.parent_id = block_response.block.parent_id.unpack1("H*")
+      block.height = block_response.block.height
+      block.timestamp = FlowClient::Utils.parse_protobuf_timestamp(block_response.block.timestamp)
+      block.collection_guarantees = block_response.block.collection_guarantees.to_a.map do |cg|
+        FlowClient::CollectionGuarantee.parse_grpc_type(cg)
+      end
+      block.block_seals = block_response.block.block_seals.to_a.map do |seal|
+        FlowClient::BlockSeal.parse_grpc_type(seal)
+      end
+      block.signatures = block_response.block.signatures.to_a.map { |sig| sig.unpack1("H*") }
+      block
+    end
+  end
+
+  # Represents a block seal
+  class BlockSeal
+    attr_accessor :block_id,
+                  :execution_receipt_id,
+                  :execution_receipt_signatures,
+                  :result_approval_signatures
+
+    def initialize
+      @block_id = nil
+      @execution_receipt_id = nil
+      @execution_receipt_signatures = []
+      @result_approval_signatures = []
+    end
+
+    def self.parse_grpc_type(grpc_type)
+      block_seal = BlockSeal.new
+      block_seal.block_id = grpc_type.block_id.unpack1("H*")
+      block_seal.execution_receipt_id = grpc_type.execution_receipt_id.unpack1("H*")
+      block_seal.execution_receipt_signatures = grpc_type.execution_receipt_signatures.to_a.map do |sig|
+        sig.unpack1("H*")
+      end
+      block_seal.result_approval_signatures = grpc_type.result_approval_signatures.to_a.map { |sig| sig.unpack1("H*") }
+      block_seal
+    end
+  end
+
+  # Represents a block header
+  class BlockHeader
+    attr_accessor :id, :parent_id, :height, :timestamp
+
+    def initialize; end
+
+    def self.parse_grpc_type(grpc_type)
+      header = BlockHeader.new
+      header.id = grpc_type.id.unpack1("H*")
+      header.height = grpc_type.height
+      header.timestamp = FlowClient::Utils.parse_protobuf_timestamp(grpc_type.timestamp)
+      header
+    end
+  end
+end

data/lib/flow_client/cadence_type.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require "ostruct"
+
+module FlowClient
+  module CadenceType
+    # Returns an OpenStruct representing a Cadence String type
+    #
+    # @example
+    #   @arg = FlowClient::CadenceType.String("Hello world!")
+    #
+    # @param [String] the string value
+    #
+    # @returns [OpenStruct] the Cadence String struct
+    def self.String(value)
+      OpenStruct.new(type: "String", value: value.to_s)
+    end
+
+    # Returns an OpenStruct representing a Cadence Optional type
+    #
+    # @example
+    #   @arg = FlowClient::CadenceType.Optional("Hello world!")
+    #   @arg = FlowClient::CadenceType.Optional()
+    #
+    # @param [String] the string value
+    #
+    # @returns [OpenStruct] the Cadence Optional struct
+    def self.Optional(value = nil)
+      OpenStruct.new(type: "Optional", value: value)
+    end
+
+    # Returns an OpenStruct representing a Cadence Void type
+    #
+    # @example
+    #   @arg = FlowClient::CadenceType.Void()
+    #
+    # @returns [OpenStruct] the Cadence Void struct
+    def self.Void
+      OpenStruct.new(type: "Void")
+    end
+
+    def self.Bool(bool)
+      OpenStruct.new(type: "Bool", value: bool.to_s.downcase == "true")
+    end
+
+    def self.Address(address)
+      OpenStruct.new(type: "Address", value: address.to_s)
+    end
+
+    def self.Int(value)
+      OpenStruct.new(type: "Int", value: value.to_s)
+    end
+
+    def self.UInt(value)
+      OpenStruct.new(type: "UInt", value: value.to_s)
+    end
+
+    def self.Int8(value)
+      OpenStruct.new(type: "Int8", value: value.to_s)
+    end
+
+    def self.UInt8(value)
+      OpenStruct.new(type: "UInt8", value: value.to_s)
+    end
+
+    def self.Int16(value)
+      OpenStruct.new(type: "Int16", value: value.to_s)
+    end
+
+    def self.UInt16(value)
+      OpenStruct.new(type: "UInt16", value: value.to_s)
+    end
+
+    def self.Int32(value)
+      OpenStruct.new(type: "Int32", value: value.to_s)
+    end
+
+    def self.UInt32(value)
+      OpenStruct.new(type: "UInt32", value: value.to_s)
+    end
+
+    def self.Int64(value)
+      OpenStruct.new(type: "Int64", value: value.to_s)
+    end
+
+    def self.UInt64(value)
+      OpenStruct.new(type: "UInt64", value: value.to_s)
+    end
+
+    def self.Int128(value)
+      OpenStruct.new(type: "Int128", value: value.to_s)
+    end
+
+    def self.UInt128(value)
+      OpenStruct.new(type: "UInt128", value: value.to_s)
+    end
+
+    def self.Int256(value)
+      OpenStruct.new(type: "Int256", value: value.to_s)
+    end
+
+    def self.UInt256(value)
+      OpenStruct.new(type: "UInt256", value: value.to_s)
+    end
+
+    def self.Word8(value)
+      OpenStruct.new(type: "Word8", value: value.to_s)
+    end
+
+    def self.Word16(value)
+      OpenStruct.new(type: "Word16", value: value.to_s)
+    end
+
+    def self.Word32(value)
+      OpenStruct.new(type: "Word32", value: value.to_s)
+    end
+
+    def self.Word64(value)
+      OpenStruct.new(type: "Word64", value: value.to_s)
+    end
+
+    def self.Fix64(value)
+      OpenStruct.new(type: "Fix64", value: value.to_s)
+    end
+
+    def self.UFix64(value)
+      OpenStruct.new(type: "UFix64", value: value.to_s)
+    end
+
+    def self.Array(values)
+      OpenStruct.new(type: "Array", value: values)
+    end
+
+    def self.Dictionary(values)
+      OpenStruct.new(type: "Dictionary", value: values)
+    end
+
+    def self.DictionaryValue(key, value)
+      OpenStruct.new(key: key, value: value)
+    end
+
+    def self.Path(domain, identifier)
+      unless %w[storage private public].include? domain.to_s.downcase
+        raise raise ArgumentError, "Domain can only be one of storage, private or public"
+      end
+
+      OpenStruct.new(
+        type: "Path",
+        value: OpenStruct.new(domain: domain, identifier: identifier)
+      )
+    end
+
+    def self.Type(type_value)
+      OpenStruct.new(type: "Type", value: OpenStruct.new(staticType: type_value.to_s))
+    end
+
+    def self.Capability(path, address, borrow_type)
+      OpenStruct.new(
+        type: "Capability",
+        value: OpenStruct.new(
+          path: path.to_s,
+          address: address.to_s,
+          borrowType: borrow_type.to_s
+        )
+      )
+    end
+
+    def self.Composite(type, value)
+      valid_types = %i[struct resource event contract enum]
+      unless valid_types.include? type
+        raise ArgumentError, "incorrect type, expected :struct, :resource, :event, :contract or :enum"
+      end
+
+      OpenStruct.new(type: type.to_s.capitalize, value: value)
+    end
+
+    def self.CompositeValue(id, fields)
+      OpenStruct.new(id: id, fields: fields)
+    end
+
+    def self.Field(name, value)
+      OpenStruct.new(name: name, value: value)
+    end
+  end
+end