flow_client 0.1.2 → 0.2.0

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/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,30 @@
+# 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 = {}
+    end
+  end
+end

data/lib/flow_client/block.rb

@@ -0,0 +1,75 @@
+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 { |cg| FlowClient::CollectionGuarantee.parse_grpc_type(cg) }
+      block.block_seals = block_response.block.block_seals.to_a.map { |seal| FlowClient::BlockSeal.parse_grpc_type(seal) }
+      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 { |sig| sig.unpack1("H*") }
+      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,197 @@
+require "ostruct"
+
+module FlowClient
+  module CadenceType
+    # class CadenceType
+    #   def to_json
+    #   end
+    # end
+
+    # class String
+    # end
+
+    def self.String(value)
+      OpenStruct.new(type: "String", value: value.to_s)
+    end
+
+    def self.Optional(value = nil)
+      OpenStruct.new(type: "Optional", value: value)
+    end
+
+    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_i)
+    end
+
+    def self.Int8(value)
+      OpenStruct.new(type: "Int8", value: value.to_i)
+    end
+
+    def self.UInt8(value)
+      OpenStruct.new(type: "UInt8", value: value.to_i)
+    end
+
+    def self.Int16(value)
+      OpenStruct.new(type: "Int16", value: value.to_i)
+    end
+
+    def self.UInt16(value)
+      OpenStruct.new(type: "UInt16", value: value.to_i)
+    end
+
+    def self.Int32(value)
+      OpenStruct.new(type: "Int32", value: value.to_i)
+    end
+
+    def self.UInt32(value)
+      OpenStruct.new(type: "UInt32", value: value.to_i)
+    end
+
+    def self.Int64(value)
+      OpenStruct.new(type: "Int64", value: value.to_i)
+    end
+
+    def self.UInt64(value)
+      OpenStruct.new(type: "UInt64", value: value.to_i)
+    end
+
+    def self.Int64(value)
+      OpenStruct.new(type: "Int64", value: value.to_i)
+    end
+
+    def self.UInt64(value)
+      OpenStruct.new(type: "UInt64", value: value.to_i)
+    end
+
+    def self.Int128(value)
+      OpenStruct.new(type: "Int128", value: value.to_i)
+    end
+
+    def self.UInt128(value)
+      OpenStruct.new(type: "UInt128", value: value.to_i)
+    end
+
+    def self.Int256(value)
+      OpenStruct.new(type: "Int256", value: value.to_i)
+    end
+
+    def self.UInt256(value)
+      OpenStruct.new(type: "UInt256", value: value.to_i)
+    end
+
+    def self.Word8(value)
+      OpenStruct.new(type: "Word8", value: value.to_i)
+    end
+
+    def self.Word8(value)
+      OpenStruct.new(type: "Word8", value: value.to_i)
+    end
+
+    def self.Word16(value)
+      OpenStruct.new(type: "Word16", value: value.to_i)
+    end
+
+    def self.Word16(value)
+      OpenStruct.new(type: "Word16", value: value.to_i)
+    end
+
+    def self.Word32(value)
+      OpenStruct.new(type: "Word32", value: value.to_i)
+    end
+
+    def self.Word32(value)
+      OpenStruct.new(type: "Word32", value: value.to_i)
+    end
+
+    def self.Word64(value)
+      OpenStruct.new(type: "Word64", value: value.to_i)
+    end
+
+    def self.Word64(value)
+      OpenStruct.new(type: "Word64", value: value.to_i)
+    end
+
+    def self.Fix64(value)
+      OpenStruct.new(type: "Fix64", value: value.to_i)
+    end
+
+    def self.Fix64(value)
+      OpenStruct.new(type: "Fix64", value: value.to_i)
+    end
+
+    def self.UFix64(value)
+      OpenStruct.new(type: "Fix64", value: value.to_i)
+    end
+
+    def self.UFix64(value)
+      OpenStruct.new(type: "Fix64", value: value.to_i)
+    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)
+      raise raise ArgumentError.new(
+        "Domain can only be one of storage, private or public"
+      ) unless ["storage", "private", "public"].include? domain.to_s.downcase
+
+      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: "Type",
+        value: OpenStruct.new(
+          path: path.to_s,
+          address: address.to_s,
+          borrow_type: borrow_type.to_s
+        )
+      )
+    end
+
+    def self.Composite(type, value)
+      valid_types = [:struct, :resource, :event, :contract, :enum]
+      raise ArgumentError.new("incorrect type, expected :struct, :resource, :event, :contract or :enum") unless valid_types.include? type
+      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