sigma_mint 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a7066884c595e6013111476407b65e48778e29c6fbe7a28c1b3b525fac944522
+  data.tar.gz: 9336dc029423e66c5e58872d270240ae1ed34c7854f5551a321444e7ac8e66cc
+SHA512:
+  metadata.gz: ea7777f22c196ed6cd7beaae5a3b38b1e09d41025a1108c0924f3d4da65b7cc8c9a03b05ca8f7e3ca1284bb06966a04fee39500eb89af070d12c7c6ae57783f8
+  data.tar.gz: 82e4679bab22c836f050fa1430b41a15e3995043f602da3f6090176f6d03efa4844a40e085913af51c5f1e0dd462e05fb49b093d65712c05be50df992857cdfb

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Dark Lord of Programming
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,72 @@
+# sigma_mint
+Ergo assets utility library
+
+### Installation
+This library uses [sigma_rb](https://github.com/thedlop/sigma_rb) which has extra installation instructions, please ensure it installs correctly first.
+
+Add to Gemfile
+`gem 'sigma_mint', '0.1.1'`  
+
+### Usage
+In an effort to save time I will share code that called this lib below. This code is straight from my [two tens](https://twotens.art) project source.
+
+
+#### PinataClient
+We can use Pinata REST API to pin files on ipfs. This requires a Pinata account (free up to 1GB) and a corresponding JWT to use when making requests. The following ENV variables are required:
+```
+# Required for PinataClient
+PINATA_JWT= 
+```
+
+For pinning images on ipfs via `PinataClient`:
+
+```
+pc = SigmaMint::PinataClient.new  
+...
+# png_path is a string path to the file we wish pin
+# nft_config is a ruby hash (dictionary) that contains some metadata
+# config is also a ruby hash (dictionary) that contains other metadata
+r = pc.pin!(png_path, "#{nft_config[:name]}", metadata: {set: config[:name], number: nft_config[:set_number]})  
+
+# you may need the ipfs_hash or sha later, it is a requirement for minting an nft picture in ErgoNodeClient  
+ipfs_hash = JSON.parse(r.body)['IpfsHash']
+```
+
+#### ErgoNodeClient
+We can utilize the Ergo Node API to mint a picture nft with royalty. Now this requires running your own node, or a node you have API access and wallet access to. The following ENV variables
+are required, you set them by adding them to your `.env` file or adding them at runtime.
+```
+# Required for ErgoNodeClient                                                                                                                                  
+ERGO_NODE_URL=
+ERGO_NODE_API_KEY=
+ERGO_NODE_WALLET_PASSWORD=
+```
+For minting a picture nft via `ErgoNodeClient` :
+
+```
+# require at top of file
+require 'sigma_mint'
+...
+
+enc = SigmaMint::ErgoNodeClient.new  
+# nft_config is a ruby hash (dictionary) that contains some metadata about this nft
+# enft_description and enft_name are strings
+# royalty is an integer
+enft = SigmaMint::ErgoNft.new(name: enft_name, 
+             description: enft_description, 
+             royalty: royalty, 
+             ipfs_hash: nft_config[:ipfs_hash], 
+             sha: nft_config[:scaled_sha], 
+             minted: false)  
+             
+# since we are making private calls to our node we must unlock it first  
+enc.unlock_wallet  
+
+# generate and sign nft tranasactions and send to node
+# real can be set to false if you want to see the generated transaction without sending it to the node (default false)
+# minting address is the node wallet address that will do the minting
+# minting_address_ergo_tree is the ergo_tree representation of the minting address
+#   you can get it view `ErgoNodeClient#address_to_tree`
+ r = enc.mint_picture_nft(minting_address, enft, address_ergo_tree: minting_address_ergo_tree, real: real)
+...
+```

data/lib/sigma_mint/ergo_nft.rb

@@ -0,0 +1,25 @@
+module SigmaMint
+  class ErgoNft
+    attr_accessor :name, :description, :royalty, :sha, :ipfs_hash, :minted
+
+    def initialize(name: nil,
+                   description: nil,
+                   royalty: 0,
+                   ipfs_hash: nil,
+                   sha: nil,
+                   minted: true) 
+
+
+      @name = name
+      @description = description
+      @royalty = royalty
+      @sha = sha
+      @ipfs_hash = ipfs_hash
+      @minted = minted
+    end
+
+    def ipfs_link
+      "https://gateway.pinata.cloud/ipfs/#{@ipfs_hash}"
+    end
+  end
+end

data/lib/sigma_mint/ergo_node_client.rb

@@ -0,0 +1,223 @@
+require 'sigma'
+require 'sigma_mint'
+
+module SigmaMint
+  # Simple Ergo Node Client for minting assets
+  # 
+  # Some ENV Variables are required:
+  # - ERGO_NODE_API_KEY : API Key for node
+  # - ERGO_NODE_URL     : Node url (ex: https://paidincrypto.io , http://127.0.0.1 )
+  # - ERGO_NODE_WALLET_PASSWORD : Node wallet password
+  class ErgoNodeClient
+    class MissingEnvVarError < StandardError; end
+
+    def initialize
+      if ENV['ERGO_NODE_API_KEY'].nil?
+        raise MissingEnvVarError.new("ERGO_NODE_API_KEY is blank, required for ErgoNodeClient")
+      end
+
+      if ENV['ERGO_NODE_URL'].nil?
+        raise MissingEnvVarError.new("ERGO_NODE_URL is blank, required for ErgoNodeClient")
+      end
+
+      @conn = Faraday.new(
+        url: ENV['ERGO_NODE_URL'],
+        headers: {'api_key' => ENV['ERGO_NODE_API_KEY'],
+                  'Accept' => 'application/json',
+                  'Content-Type' => 'application/json'
+                  },
+      )
+    end
+
+    def unlock_wallet
+      if ENV['ERGO_NODE_WALLET_PASSWORD'].nil?
+        raise MissingEnvVarError.new("ERGO_NODE_WALLET_PASSWORD is blank, required for ErgoNodeClient")
+      end
+
+      params = {pass: ENV['ERGO_NODE_WALLET_PASSWORD']}
+      @conn.post('/wallet/unlock', params.to_json)
+    end
+
+    def address_to_tree(address)
+      @conn.get("/script/addressToTree/#{address}")
+    end
+
+    ErgoEncodedNFT = Struct.new(
+      :royalty,
+      :address_ergo_tree,
+      :sha,
+      :ipfs_link,
+      keyword_init: :true,
+    )
+
+    def burn_assets(token_ids)
+      assets = token_ids.map do |token_id|
+        { tokenId: token_id,
+          amount: 1}
+      end
+      params = {
+        requests: [
+          {
+            assetsToBurn: assets,
+          }
+        ],
+        fee: 1000000,
+      }
+
+      r = @conn.post('/wallet/transaction/send', params.to_json)
+      puts r.body
+      r
+    end
+
+    def send_nfts(to_address, token_ids)
+      assets = token_ids.map do |token_id|
+        { tokenId: token_id,
+          amount: 1}
+      end
+      params = {
+        requests: [
+          {address: to_address,
+           value: 100000 * token_ids.count,
+           assets: assets,
+          }
+        ],
+        fee: 1000000,
+      }
+      r = @conn.post('/wallet/transaction/send', params.to_json)
+      puts r.body
+      r
+    end
+
+    def send_transaction(ergo_transaction)
+      @conn.post('/transactions', ergo_transaction.to_json)
+    end
+
+    def get_serialized_box_with_pool(box_id)
+      @conn.get("/utxo/withPool/byIdBinary/#{box_id}", {})
+    end
+
+    def get_unspent_boxes(min_confirmations: 0, min_inclusion_height: 0)
+      params = {
+        minConfirmations: min_confirmations,
+        minInclusionHeight: min_inclusion_height,
+      }
+
+      r = @conn.get('/wallet/boxes/unspent', params)
+      return r
+    end
+
+    def mint_picture_nft(address, ergo_nft, real: false, address_ergo_tree: nil)
+
+      if address_ergo_tree.nil?
+        r = address_to_tree(address)
+        address_ergo_tree = JSON.parse(r.body)['tree']
+      end
+
+      # get encoded values
+      encoded = get_encoded_values(ergo_nft, address_ergo_tree: address_ergo_tree)
+
+      royalty_params = {
+        requests: [],
+        fee: Sigma::TxBuilder.suggested_tx_fee.to_i64,
+      }
+
+      royalty_request = {
+        address: address,
+        value: 2000000,
+        registers: {
+          R4: encoded.royalty,
+          R5: encoded.address_ergo_tree,
+        }
+      }
+
+      royalty_params[:requests] = [royalty_request]
+    
+      # generate royalty txn
+      r = @conn.post('/wallet/transaction/generate', royalty_params.to_json)
+      royalty_txn = JSON.parse(r.body)
+      box_id = royalty_txn['outputs'][0]['boxId']
+      puts "Royalty BoxID: #{box_id}"
+      
+      royalty_box_raw_bytes = nil
+
+      # send royalty txn
+      if real
+        r = send_transaction(royalty_txn)
+
+        # grab royalty box id
+        waiting_for_box_count = 0 
+        waiting_for_box_max = 5
+        loop do
+          if waiting_for_box_count > waiting_for_box_max
+            raise 'Royalty Box never showed up #{box_id}'
+          end
+          r = get_serialized_box_with_pool(box_id)
+          break if r.status == 200
+          waiting_for_box_count += 1
+          puts "Waiting for Royalty Box #{waiting_for_box_count}"
+          sleep 1
+        end
+
+        royalty_box_raw_bytes = JSON.parse(r.body)['bytes']
+        puts "Royalty Box Bytes: #{royalty_box_raw_bytes}"
+      end
+
+      nft_request = {
+        address: address,
+        amount: 1,
+        name: ergo_nft.name,
+        description: ergo_nft.description,
+        decimals: 0,
+        registers: {
+          R7: "0e020101", # PICTURE NFT
+          R8: encoded.sha,
+          R9: encoded.ipfs_link,
+        },
+      }
+
+      nft_params = {
+        requests: [nft_request],
+        fee: Sigma::TxBuilder.suggested_tx_fee.to_i64,
+        inputsRaw: [royalty_box_raw_bytes],
+      }
+
+      if real
+        # finally generate nft transaction with royalty box as input
+        @conn.post('/wallet/transaction/generate', nft_params.to_json)
+      else
+        puts "NFT Mint dry run, would send: \n#{nft_params.inspect}"
+      end
+    end
+
+    # @param ergo_nft [ErgoNft] 
+    def get_encoded_values(ergo_nft, address_ergo_tree: nil)
+      raise "address_ergo_tree required!" if address_ergo_tree.nil?
+    
+      #puts "Royalty: #{ergo_nft.royalty} => #{Sigma::Constant.with_i32(ergo_nft.royalty * 10).to_base16_string}"
+      # NOTE from EIP-24:  (Royalty) R4 of this box is an Int, showing 1000 * royalty percentage of the artwork. e.g, 20 for 2% royalty.
+      ErgoEncodedNFT.new(
+        ipfs_link: sigma_encode_str(ergo_nft.ipfs_link),
+        royalty: Sigma::Constant.with_i32(ergo_nft.royalty * 10).to_base16_string,
+        sha: sigma_encode_hex_str(ergo_nft.sha),
+        address_ergo_tree: sigma_encode_hex_str(address_ergo_tree), 
+      ) 
+    end
+
+    # Some pre-encoded values (sha, address_ergo_tree) are already hex-encoded
+    def hex_to_str(hex_str)
+      hex_str.scan(/../).map { |hc| hc.hex.chr }.join
+    end
+
+    # Convert hex -> str before encoding with Sigma::Constant
+    def sigma_encode_hex_str(hex_str)
+      str = hex_to_str(hex_str)
+      sigma_encode_str(str)
+    end
+
+    def sigma_encode_str(str)
+      Sigma::Constant.with_bytes(
+        str.each_byte.map { |c| c }
+      ).to_base16_string
+    end
+  end
+end

data/lib/sigma_mint/pinata_client.rb

@@ -0,0 +1,57 @@
+require 'dotenv/load'
+require 'faraday'
+require 'faraday/net_http'
+require 'faraday/multipart'
+Faraday.default_adapter = :net_http
+
+module SigmaMint
+  # Simple Pinata Client for pinning files to IPFS
+  class PinataClient
+    def initialize
+      # https://docs.pinata.cloud/#connecting-to-the-api
+      @conn = Faraday.new( 
+        url: 'https://api.pinata.cloud',
+        headers: {'Authorization' => "Bearer #{ENV['PINATA_JWT']}"},
+        ) do |f|
+          f.request  :multipart, {}
+        end
+    end
+
+    # https://docs.pinata.cloud/api-pinning/pin-file
+    def pin!(filepath, name, metadata: {}, cid_version: '1', mime_type: 'image/png')
+      file = Faraday::Multipart::FilePart.new(filepath, mime_type)
+
+      pinata_options = {
+        cidVersion: cid_version,
+        wrapWithDirectory: false,
+        customPinPolicy: {
+          regions: [
+              {
+                  id: 'FRA1',
+                  desiredReplicationCount: 2
+              },
+              {
+                  id: 'NYC1',
+                  desiredReplicationCount: 2
+              }]}
+      }
+
+      pinata_metadata = {
+        name: name,
+        keyvalues: metadata
+      }
+
+      params = {
+        file: file,
+        pinataOptions: pinata_options,
+        pinataMetadata: pinata_metadata,
+      }
+
+      @conn.post('/pinning/pinFileToIPFS', params)
+    end
+  end
+end
+
+#pc = PinataClient.new
+#testpng = "scratch/test_pngs/test_scaled_bf.png"
+#puts pc.pin!(testpng, "pintest_1", metadata: {set: 'Alpha', number: '1'})

data/lib/sigma_mint.rb

@@ -0,0 +1,5 @@
+module SigmaMint
+  require_relative 'sigma_mint/pinata_client'
+  require_relative 'sigma_mint/ergo_node_client'
+  require_relative 'sigma_mint/ergo_nft'
+end

data/sigma_mint.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |s|
+  s.name        = 'sigma_mint'
+  s.version     = '0.1.1'
+  s.summary     = "Simple ERGO asset creaiton library"
+  s.description = "Provides basic utilities for minting assets on the ERGO blockchain."
+  s.authors     = ["Dark Lord of Programming"]
+  s.email       = 'thedlop@sent.com'
+  s.homepage    = 'https://github.com/thedlop/sigma_mint'
+  s.license       = 'MIT'
+  s.files = Dir.glob("{lib}/**/*")
+  s.files += %w(sigma_mint.gemspec README.md LICENSE)
+  s.add_dependency 'dotenv', '~> 2.7.6'
+  s.add_dependency 'sigma_rb', '0.1.5'
+  s.add_dependency 'faraday', '~> 2.2.0'
+  s.add_dependency 'faraday-multipart', '~> 1.0.3'
+  s.add_development_dependency 'test-unit', '~> 3.5'
+  s.add_development_dependency 'yard', '~> 0.9.20'
+  s.test_files = Dir["tests/**/*.rb"]
+  s.require_paths = ["lib"]
+  s.required_ruby_version = '>= 3.0.1'
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: sigma_mint
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Dark Lord of Programming
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-05-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.7.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.7.6
+- !ruby/object:Gem::Dependency
+  name: sigma_rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+- !ruby/object:Gem::Dependency
+  name: faraday-multipart
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.20
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.20
+description: Provides basic utilities for minting assets on the ERGO blockchain.
+email: thedlop@sent.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/sigma_mint.rb
+- lib/sigma_mint/ergo_nft.rb
+- lib/sigma_mint/ergo_node_client.rb
+- lib/sigma_mint/pinata_client.rb
+- sigma_mint.gemspec
+homepage: https://github.com/thedlop/sigma_mint
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.33
+signing_key:
+specification_version: 4
+summary: Simple ERGO asset creaiton library
+test_files: []