glueby 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d128fa095b1dacb936a8a9ff3306b750d3cf258133f6fa469ccaf9d4d830c08
-  data.tar.gz: 0a0496a04b1a6b86d3f2790555ac832094cb2a809ea10262f0641520dc7cb96b
+  metadata.gz: 14bc1f60be9eefa4527231fb46fbb0d96b7a2253b1634d94b3a8464290d2ddbb
+  data.tar.gz: b268217f39285ae42fc2a4107bfcb5c32d9a71225e1fbb2b01296d24e62f1a1f
 SHA512:
-  metadata.gz: '07178bc49443f227073442e2d5e767e2350a1b363f72b1041b6f2feb2a6a7a413399617c97017acf73537d49e57f10d0aecb7439a8524a7c80691ccaf0620ce6'
-  data.tar.gz: 86d4f463995f258d3ab3496206eabc97af77f16554705f61db69c339efc146d876375cda34bf8a17425954bf51ad6c1699eb19f37676e54401c57e5026bec597
+  metadata.gz: 5a51e8f38bf391baec903a06e240294e8e75c5a881285f9be369009b77bf6fe9e8fe86fe41f43a1659344a6a38c1fcb3e2293951e8bb1a41d8beb282f63e96f6
+  data.tar.gz: 464fb058d159a083ab096bdb077981b65069e60d1fb73d664d6ea7fb09555c2e0794f4266bb114b5d4d315910f884a3548e6dfd1cd3412c93395f3433a75eaad

data/README.md

@@ -1,9 +1,35 @@
 # Glueby [![Ruby](https://github.com/chaintope/glueby/actions/workflows/ruby.yml/badge.svg)](https://github.com/chaintope/glueby/actions/workflows/ruby.yml) [![Gem Version](https://badge.fury.io/rb/glueby.svg)](https://badge.fury.io/rb/glueby) [![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](LICENSE)
 
+Glueby is a smart contract library on the [Tapyrus blockchain](https://github.com/chaintope/tapyrus-core). This is 
+designed as you can use without any deep blockchain understanding.
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/glueby`. To experiment with that code, run `bin/console` for an interactive prompt.
+## Features
 
-TODO: Delete this and the text above, and describe your gem
+Glueby has below features.
+
+1. Wallet
+   You can manage wallets for application users. This wallet feature is a foundation of Contracts below to specify tx
+   sender and so on.  
+   You can choose two sorts of wallet implementation :activerecord and :core. :activerecord is implemented using
+   ActiveRecord on RDB. :core uses the wallet that bundled with Tapyrus Core.
+   
+2. Contracts  
+   You can use some smart contracts easily  
+   - [Timestamp](#Timestamp): Record any data as a timestamp to a tapyrus blockchain.
+   - [Payment](./lib/glueby/contract/payment.rb): Transfer TPC.
+   - [Token](./lib/glueby/contract/token.rb): Issue, transfer and burn colored coin.
+
+3. Sync blocks with your application   
+   You can use BlockSyncer when you need to synchronize the state of an application with the state of a blockchain.  
+   See more details at [BlockSyncer](./lib/glueby/block_syncer.rb).
+
+4. Take over tx sender's fees  
+   FeeProvider module can bear payments of sender's fees. You should provide funds for fees to FeeProvider before use.  
+   See how to set up at [Use fee provider mode](#use-fee-provider-mode)
+
+5. Utxo Provider
+   The UtxoProvider allows users to create a variety of transactions without having to manage the TPCs they hold in their wallets.
+   See more details at [Use utxo provider](#use-utxo-provider)
 
 ## Installation
 
@@ -21,13 +47,95 @@ Or install it yourself as:
 
     $ gem install glueby
 
-## Usage
+### Setup for Ruby on Rails application development
 
-Glueby has below features.
+1. Add this line to your application's Gemfile
+
+    ```ruby
+    gem 'glueby'
+    ```
+
+    and then execute 
+    
+        $ bundle install
+
+2. Run installation rake task
+
+        $ rails glueby:contract:install
+
+3. Run Tapyrus Core as dev mode
+
+    We recommend to run as a Docker container. 
+    Docker image is here.
+
+    * [tapyus/tapyrusd](https://hub.docker.com/repository/docker/tapyrus/tapyrusd)
+
+    Starts tapryusd container
+
+        $ docker run -d --name 'tapyrus_node_dev' -p 12381:12381 -e GENESIS_BLOCK_WITH_SIG='0100000000000000000000000000000000000000000000000000000000000000000000002b5331139c6bc8646bb4e5737c51378133f70b9712b75548cb3c05f9188670e7440d295e7300c5640730c4634402a3e66fb5d921f76b48d8972a484cc0361e66ef74f45e012103af80b90d25145da28c583359beb47b21796b2fe1a23c1511e443e7a64dfdb27d40e05f064662d6b9acf65ae416379d82e11a9b78cdeb3a316d1057cd2780e3727f70a61f901d10acbe349cd11e04aa6b4351e782c44670aefbe138e99a5ce75ace01010000000100000000000000000000000000000000000000000000000000000000000000000000000000ffffffff0100f2052a010000001976a91445d405b9ed450fec89044f9b7a99a4ef6fe2cd3f88ac00000000' tapyrus/tapyrusd:edge
+
+4. Modify the glueby configuration
+
+    ```ruby
+    # Use tapyrus dev network
+    Tapyrus.chain_params = :dev
+    Glueby.configure do |config|
+      config.wallet_adapter = :activerecord
+      # Modify rpc connection info in config/initializers/glueby.rb that is created in step 3.
+      config.rpc_config = { schema: 'http', host: '127.0.0.1', port: 12381, user: 'rpcuser', password: 'rpcpassword' }
+    end
+    ```
+
+5. Generate db migration files for wallet feature
+
+    These are essential if you use `config.wallet_adapter = :activerecord` configuration. 
+
+        $ rails g glueby:contract:block_syncer
+        $ rails g glueby:contract:wallet_adapter
+
+    If you want to use reissuable token or timestamp, you need to do below generators.
+
+        $ rails g glueby:contract:reissuable_token
+        $ rails g glueby:contract:timestamp
+
+    Then, run the migrations.
 
-- [Timestamp](#Timestamp)
+        $ rails db:migrate
 
-### Timestamp
+### Provide initial TPC (Tapyrus Coin) to wallets
+
+To use contracts, wallets need to have TPC and it can be provided from coinbase tx.
+
+1. Create a wallet and get receive address 
+
+    ```ruby
+    wallet = Glueby::Wallet.create
+    wallet.balances # => {}
+    address = wallet.internal_wallet.receive_address
+    puts address
+    ```
+
+2. Generate a block
+
+    Set an address you got in previous step to `[Your address]`
+
+        $ docker exec tapyrus_node_dev tapyrus-cli -conf=/etc/tapyrus/tapyrus.conf generatetoaddress 1 "[Your address]" "cUJN5RVzYWFoeY8rUztd47jzXCu1p57Ay8V7pqCzsBD3PEXN7Dd4"
+
+3. Sync blocks if you use `:activerecord` wallet adapter
+
+    You don't need to do this if you are using `:core` wallet_adapter.
+
+        $ rails glueby:contract:block_syncer:start
+
+   Here the wallet created in step 1 have 50 TPC and you can see like this:
+
+    ```ruby
+    wallet.balances # =>  {""=>5000000000}
+    ```
+
+    TPC amount is shown as tapyrus unit. 1 TPC = 100000000 tapyrus.
+
+## Timestamp
 
 ```ruby
 
@@ -99,7 +207,7 @@ We can see the timestamp transaction using getrawblockchain command
 }
 ```
 
-#### Rails support
+### Rails support
 
 Glueby supports ruby on rails integration.
 
@@ -119,6 +227,9 @@ Glueby.configure do |config|
   config.wallet_adapter = :activerecord
   config.rpc_config = { schema: 'http', host: '127.0.0.1', port: 12381, user: 'user', password: 'pass' }
 end
+
+# Uncomment next line when using timestamp feature
+# Glueby::BlockSyncer.register_syncer(Glueby::Contract::Timestamp::Syncer)
 ```
 
 If you use timestamp feature, use `glueby:contract:timestamp` generator.
@@ -155,11 +266,10 @@ bin/rails glueby:contract:timestamp:create
 broadcasted (id=1, txid=8d602ca8ebdd50fa70b5ee6bc6351965b614d0a4843adacf9f43fedd7112fbf4)
 ```
 
-Run `glueby:contract:timestamp:confirm` task to confirm the transaction and update status(unconfirmed -> confirmded).
+Run `glueby:block_syncer:start` task to confirm the transaction and update status(unconfirmed -> confirmded).
 
 ```
-bin/rails glueby:contract:timestamp:confirm
-confirmed (id=1, txid=8d602ca8ebdd50fa70b5ee6bc6351965b614d0a4843adacf9f43fedd7112fbf4)
+bin/rails glueby:block_syncer:start
 ```
 
 ## Use fee provider mode
@@ -190,6 +300,7 @@ Glueby.configure do |config|
     # The fee that Fee Provider pays on each transaction.
     fixed_fee: 1000,
     # Fee Provider tries to keep the number of utxo in utxo pool as this size using `glueby:fee_provider:manage_utxo_pool` rake task
+    # This size should not be greater than 2000.
     utxo_pool_size: 20 
   }
 end
@@ -262,6 +373,77 @@ Configuration:
   utxo_pool_size = 20
 ```
 
+## Use Utxo Provider
+
+UtxoProvider will pay TPC on behalf of the user.
+
+TPCs are required to create transactions in many cases where Glueby is used, such as issuing tokens or recording timestamps.
+However, on the other hand, each user may not want to fund or manage TPCs.
+
+The UtxoProvider allows users to create a variety of transactions without having to manage the TPCs they hold in their wallets.
+
+### Set up Utxo Provider
+
+1. Configure using Glueby.configure
+
+```ruby
+Glueby.configure do |config|
+  # using Utxo Provider
+  config.enable_utxo_provider!
+
+  # If not using Utxo Provider and each wallet manages TPCs by itself (Default behavior)
+  # config.disable_utxo_provider!
+
+  config.utxo_provider_config = {
+    # The amount that each utxo in utxo pool posses.
+    default_value: 1_000,
+    # The number of utxos in utxo pool. This size should not be greater than 2000.
+    utxo_pool_size: 20
+  }
+end
+```
+
+2. Deposit TPC into Utxo Provider's wallet
+
+Get an address from the wallet, and send enough TPCs to the address.
+
+```
+$ bundle exec rake glueby:utxo_provider:address
+mqYTLdLCUCCZkTkcpbVx1GqpvV1gK4euRD
+```
+
+3. Manage UTXO pool
+
+Run the rake task `glueby:utxo_provider:manage_utxo_pool`
+This rake task tries to split UTOXs up to `utxo_pool_size`. If the pool has more than `utxo_pool_size` UTXOs, it does nothing
+
+```
+$ bundle exec rake glueby:utxo_provider:manage_utxo_pool
+
+Status: Ready
+TPC amount: 4_999_990_000
+UTXO pool size: 20
+
+Configuration:
+  default_value = 1_000
+  utxo_pool_size = 20
+```
+
+If you want to get the status information, you can use the `status` task.
+
+```
+$ bundle exec rake glueby:utxo_provider:status
+Status: Ready  q
+TPC amount: 4_999_990_000
+UTXO pool size: 20
+
+Configuration:
+  default_value = 1_000
+  utxo_pool_size = 20
+
+```
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/glueby.gemspec

@@ -27,6 +27,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency 'tapyrus', '>= 0.2.9'
-  spec.add_runtime_dependency 'activerecord'
+  spec.add_runtime_dependency 'activerecord', '~> 6.1.3'
   spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'rails', '~> 6.1.3'
 end

data/lib/generators/glueby/contract/templates/initializer.rb.erb

@@ -1,3 +1,8 @@
 # Edit configuration for connection to tapyrus core
-config = {adapter: 'core', schema: 'http', host: '127.0.0.1', port: 12381, user: 'user', password: 'pass'}
-Glueby::Wallet.configure(config)
+Glueby.configure do |config|
+  config.wallet_adapter = :activerecord
+  config.rpc_config = { schema: 'http', host: '127.0.0.1', port: 12381, user: 'user', password: 'pass' }
+end
+
+# Uncomment next line when using timestamp feature
+# Glueby::BlockSyncer.register_syncer(Glueby::Contract::Timestamp::Syncer)

data/lib/glueby/block_syncer.rb

@@ -0,0 +1,98 @@
+module Glueby
+  # You can use BlockSyncer when you need to synchronize the state of
+  # an application with the state of a blockchain. When BlockSyncer
+  # detects the generation of a new block, it executes the registered
+  # syncer code on a block-by-block or transaction-by-transaction basis.
+  # By using this, an application can detect that the issued transaction
+  # has been captured in  blocks, receive a new remittance, and so on.
+  #
+  # # Syncer logic registration
+  #
+  # For registration, create a class that implements the method that performs
+  # synchronization processing and registers it in BlockSyncer. Implement
+  # methods with the following name in that class.
+  #
+  # Method name        | Arguments             | Call conditions
+  # ------------------ | --------------------- | ------------------------------
+  # block_sync (block) | block: Tapyrus::Block | When a new block is created
+  # block_tx (tx)      | tx: Tapyrus::Tx       | When a new block is created, it is executed for each tx contained in that block.
+  #
+  # @example Register a synchronous logic
+  #   class Syncer
+  #     def block_sync (block)
+  #       # sync a block
+  #     end
+  #
+  #     def tx_sync (tx)
+  #       # sync a tx
+  #     end
+  #   end
+  #   BlockSyncer.register_syncer(Syncer)
+  #
+  # @example Unregister the synchronous logic
+  #   BlockSyncer.unregister_syncer(Syncer)
+  #
+  # # Run BlockSyncer
+  #
+  # Run the `glueby: block_syncer: start` rake task periodically with a program
+  # for periodic execution such as cron. If it detects the generation of a new
+  # block when it is executed, the synchronization process will be executed.
+  # Determine the execution interval according to the requirements of the application.
+  class BlockSyncer
+    # @!attribute [r] height
+    #   @return [Integer] The block height to be synced
+    attr_reader :height
+
+    class << self
+      # @!attribute r syncers
+      #   @return [Array<Class>] The syncer classes that is registered
+      attr_reader :syncers
+
+      # Register syncer class
+      # @param [Class] syncer The syncer to be registered.
+      def register_syncer(syncer)
+        @syncers ||= []
+        @syncers << syncer
+      end
+
+      # Unregister syncer class
+      # @param [Class] syncer The syncer to be unregistered.
+      def unregister_syncer(syncer)
+        @syncers ||= []
+        @syncers.delete(syncer)
+      end
+    end
+
+    # @param [Integer] height The block height to be synced in the instance
+    def initialize(height)
+      @height = height
+    end
+
+    # Run a block synchronization
+    def run
+      return if self.class.syncers.nil?
+
+      self.class.syncers.each do |syncer|
+        instance = syncer.new
+        instance.block_sync(block) if instance.respond_to?(:block_sync)
+
+        if instance.respond_to?(:tx_sync)
+          block.transactions.each { |tx| instance.tx_sync(tx) }
+        end
+      end
+    end
+
+    private
+
+    def block
+      @block ||= begin
+                   block = Glueby::Internal::RPC.client.getblock(block_hash, 0)
+                   Tapyrus::Block.parse_from_payload(block.htb)
+                 end
+    end
+
+    def block_hash
+      @block_hash ||= Glueby::Internal::RPC.client.getblockhash(height)
+    end
+  end
+end

data/lib/glueby/configuration.rb

@@ -10,11 +10,17 @@ module Glueby
   #     end
   class Configuration
 
-    attr_reader :fee_provider_bears
+    attr_reader :fee_provider_bears, :use_utxo_provider
     alias_method :fee_provider_bears?, :fee_provider_bears
+    alias_method :use_utxo_provider?, :use_utxo_provider
+
+    module Errors
+      class InvalidConfiguration < StandardError; end
+    end
 
     def initialize
       @fee_provider_bears = false
+      @use_utxo_provider = false
     end
 
     # Specify wallet adapter.
@@ -54,9 +60,27 @@ module Glueby
     # Specify FeeProvider configuration.
     # @param [Hash] config
     # @option config [Integer] :fixed_fee - The fee that Fee Provider pays on each transaction.
-    # @option config [Integer] :utxo_pool_size - Fee Provider tries to keep the number of utxo in utxo pool as this size using `glueby:fee_provider:manage_utxo_pool` rake task
+    # @option config [Integer] :utxo_pool_size - Fee Provider tries to keep the number of utxo in utxo pool as this size using `glueby:fee_provider:manage_utxo_pool` rake task. this size should not be greater than 2000.
     def fee_provider_config=(config)
       FeeProvider.configure(config)
     end
+
+    # Enable UtxoProvider feature
+    def enable_utxo_provider!
+      @use_utxo_provider = true
+    end
+
+    # Disable UtxoProvider feature
+    def disable_utxo_provider!
+      @use_utxo_provider = false
+    end
+
+    # Set UtxoProvider configuration
+    # @param [Hash] config
+    # @option config [Integer] :default_value - The fee that Fee Provider pays on each transaction.
+    # @option config [Integer] :utxo_pool_size - Utxo Provider tries to keep the number of utxo in utxo pool as this size using `glueby:utxo_provider:manage_utxo_pool` rake task. this size should not be greater than 2000.
+    def utxo_provider_config=(config)
+      UtxoProvider.configure(config)
+    end
   end
 end

data/lib/glueby/contract/timestamp/syncer.rb

@@ -0,0 +1,13 @@
+module Glueby
+  module Contract
+    class Timestamp
+      class Syncer
+        def block_sync(block)
+          Glueby::Contract::AR::Timestamp
+            .where(txid: block.transactions.map(&:txid), status: :unconfirmed)
+            .update_all(status: :confirmed)
+        end
+      end
+    end
+  end
+end

data/lib/glueby/contract/timestamp.rb

@@ -10,34 +10,39 @@ module Glueby
     class Timestamp
       include Glueby::Contract::TxBuilder
 
+      autoload :Syncer, 'glueby/contract/timestamp/syncer'
+
       module Util
         include Glueby::Internal::Wallet::TapyrusCoreWalletAdapter::Util
         module_function
 
-        def create_tx(wallet, prefix, data, fee_estimator)
-          tx = Tapyrus::Tx.new
-          tx.outputs << Tapyrus::TxOut.new(value: 0, script_pubkey: create_script(prefix, data))
-  
-          fee = fee_estimator.fee(dummy_tx(tx))
-          sum, outputs = wallet.internal_wallet.collect_uncolored_outputs(fee)
-          fill_input(tx, outputs)
-  
-          fill_change_tpc(tx, wallet, sum - fee)
-          wallet.internal_wallet.sign_tx(tx)
-        end
-  
-        def create_payload(prefix, data)
-          payload = +''
-          payload << prefix
-          payload << data
-          payload
-        end
+        def create_txs(wallet, prefix, data, fee_estimator, utxo_provider)
+          txb = Tapyrus::TxBuilder.new
+          txb.data(prefix + data)
+          fee = fee_estimator.fee(dummy_tx(txb.build))
+          if utxo_provider
+            script_pubkey = Tapyrus::Script.parse_from_addr(wallet.internal_wallet.receive_address)
+            funding_tx, index = utxo_provider.get_utxo(script_pubkey, fee)
+            txb.add_utxo({
+              script_pubkey: funding_tx.outputs[index].script_pubkey,
+              txid: funding_tx.txid,
+              index: index,
+              value: funding_tx.outputs[index].value
+            })
+          else
+            sum, outputs = wallet.internal_wallet.collect_uncolored_outputs(fee)
+            outputs.each do |utxo|
+              txb.add_utxo({
+                script_pubkey: Tapyrus::Script.parse_from_payload(utxo[:script_pubkey].htb),
+                txid: utxo[:txid],
+                index: utxo[:vout],
+                value: utxo[:amount]
+              })
+            end
+          end
 
-        def create_script(prefix, data)
-          script = Tapyrus::Script.new
-          script << Tapyrus::Script::OP_RETURN
-          script << create_payload(prefix, data)
-          script
+          txb.fee(fee).change_address(wallet.internal_wallet.change_address)
+          [funding_tx, wallet.internal_wallet.sign_tx(txb.build)]
         end
 
         def get_transaction(tx)
@@ -61,13 +66,15 @@ module Glueby
         content:,
         prefix: '',
         fee_estimator: Glueby::Contract::FixedFeeEstimator.new,
-        digest: :sha256
+        digest: :sha256,
+        utxo_provider: nil
       )
         @wallet = wallet
         @content = content
         @prefix = prefix
         @fee_estimator = fee_estimator
         @digest = digest
+        @utxo_provider = utxo_provider
       end
 
       # broadcast to Tapyrus Core
@@ -77,7 +84,8 @@ module Glueby
       def save!
         raise Glueby::Contract::Errors::TxAlreadyBroadcasted if @txid
 
-        @tx = create_tx(@wallet, @prefix, digest_content, @fee_estimator)
+        funding_tx, @tx = create_txs(@wallet, @prefix, digest_content, @fee_estimator, @utxo_provider)
+        @wallet.internal_wallet.broadcast(funding_tx) if funding_tx
         @txid = @wallet.internal_wallet.broadcast(@tx)
       end
 

data/lib/glueby/contract/token.rb

@@ -80,7 +80,8 @@ module Glueby
         private
 
         def issue_reissuable_token(issuer:, amount:)
-          funding_tx = create_funding_tx(wallet: issuer)
+          utxo_provider = Glueby::UtxoProvider.new if Glueby.configuration.use_utxo_provider?
+          funding_tx = create_funding_tx(wallet: issuer, utxo_provider: utxo_provider)
           script_pubkey = funding_tx.outputs.first.script_pubkey
           color_id = Tapyrus::Color::ColorIdentifier.reissuable(script_pubkey)
 
@@ -96,21 +97,37 @@ module Glueby
         end
 
         def issue_non_reissuable_token(issuer:, amount:)
-          tx = create_issue_tx_for_non_reissuable_token(issuer: issuer, amount: amount)
+          utxo_provider = Glueby::UtxoProvider.new if Glueby.configuration.use_utxo_provider?
+          funding_tx = create_funding_tx(wallet: issuer, utxo_provider: utxo_provider) if utxo_provider
+          funding_tx = issuer.internal_wallet.broadcast(funding_tx) if funding_tx
+
+          tx = create_issue_tx_for_non_reissuable_token(funding_tx: funding_tx, issuer: issuer, amount: amount)
           tx = issuer.internal_wallet.broadcast(tx)
 
           out_point = tx.inputs.first.out_point
           color_id = Tapyrus::Color::ColorIdentifier.non_reissuable(out_point)
-          [[tx], color_id]
+          if funding_tx
+            [[funding_tx, tx], color_id]
+          else
+            [[tx], color_id]
+          end
         end
 
         def issue_nft_token(issuer:)
-          tx = create_issue_tx_for_nft_token(issuer: issuer)
+          utxo_provider = Glueby::UtxoProvider.new if Glueby.configuration.use_utxo_provider?
+          funding_tx = create_funding_tx(wallet: issuer, utxo_provider: utxo_provider) if utxo_provider
+          funding_tx = issuer.internal_wallet.broadcast(funding_tx) if funding_tx
+
+          tx = create_issue_tx_for_nft_token(funding_tx: funding_tx, issuer: issuer)
           tx = issuer.internal_wallet.broadcast(tx)
 
           out_point = tx.inputs.first.out_point
           color_id = Tapyrus::Color::ColorIdentifier.nft(out_point)
-          [[tx], color_id]
+          if funding_tx
+            [[funding_tx, tx], color_id]
+          else
+            [[tx], color_id]
+          end
         end
       end
 
@@ -128,9 +145,10 @@ module Glueby
       def reissue!(issuer:, amount:)
         raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
         raise Glueby::Contract::Errors::InvalidTokenType unless token_type == Tapyrus::Color::TokenTypes::REISSUABLE
+        utxo_provider = Glueby::UtxoProvider.new if Glueby.configuration.use_utxo_provider?
 
         if validate_reissuer(wallet: issuer)
-          funding_tx = create_funding_tx(wallet: issuer, script: @script_pubkey)
+          funding_tx = create_funding_tx(wallet: issuer, script: @script_pubkey, utxo_provider: utxo_provider)
           funding_tx = issuer.internal_wallet.broadcast(funding_tx)
           tx = create_reissue_tx(funding_tx: funding_tx, issuer: issuer, amount: amount, color_id: color_id)
           tx = issuer.internal_wallet.broadcast(tx)
@@ -153,7 +171,11 @@ module Glueby
       def transfer!(sender:, receiver_address:, amount: 1)
         raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
 
-        tx = create_transfer_tx(color_id: color_id, sender: sender, receiver_address: receiver_address, amount: amount)
+        utxo_provider = Glueby::UtxoProvider.new if Glueby.configuration.use_utxo_provider?
+        funding_tx = create_funding_tx(wallet: sender, utxo_provider: utxo_provider) if utxo_provider
+        funding_tx = sender.internal_wallet.broadcast(funding_tx) if funding_tx
+
+        tx = create_transfer_tx(funding_tx: funding_tx, color_id: color_id, sender: sender, receiver_address: receiver_address, amount: amount)
         sender.internal_wallet.broadcast(tx)
         [color_id, tx]
       end
@@ -169,7 +191,11 @@ module Glueby
       def burn!(sender:, amount: 0)
         raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
 
-        tx = create_burn_tx(color_id: color_id, sender: sender, amount: amount)
+        utxo_provider = Glueby::UtxoProvider.new if Glueby.configuration.use_utxo_provider?
+        funding_tx = create_funding_tx(wallet: sender, utxo_provider: utxo_provider) if utxo_provider
+        funding_tx = sender.internal_wallet.broadcast(funding_tx) if funding_tx
+
+        tx = create_burn_tx(funding_tx: funding_tx, color_id: color_id, sender: sender, amount: amount)
         sender.internal_wallet.broadcast(tx)
       end