Bringing Blockchain to Corporate Finance. A Smart Contract for Corporate Bonds

Textbook, 2020

69 Pages





1 Introduction

2 Smart Contracts
2.1 Solidity
2.2 Tokens
2.3 ERC20 standard

3 Corporate Bonds

4 Requirements for the Smart Contract

5 Remix

6 The Bond Token Smart Contract

7 Simulations
7.1 Simulation one
7.2 Simulation two

8 Evaluation of the smart contract

Internet references


Bibliografische Information der Deutschen Nationalbibliothek:

Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über abrufbar.


Copyright © EconoBooks 2020

Ein Imprint der GRIN Publishing GmbH, München

Druck und Bindung: Books on Demand GmbH, Norderstedt, Germany

Covergestaltung: GRIN Publishing GmbH


The objective of this master thesis is to examine the technical feasibility of a possible blockchain use case: A smart contract that enables the issuing and trading of corporate bonds without intermediaries. The key features for the smart contract have been derived from the payment mechanisms of a bond and the standard for token contracts established within the Ethereum developer community. The contract’s source code is written in Solidity, an object-oriented, Turing-complete programming language, influenced by JavaScript and C, and designed for Ethereum applications. The coding and testing of the smart contract have been done in the integrated development environment Remix. The requirements for the smart contract could be implemented successfully, as confirmed by the documentation of two simulations.


Table 1: Used Solidity Operators in bond contract

Table 2: Cumulative coupon payments from issuer to investor after each period

Table 3: Cash flow in Ether per investor and period

Table 4: Cumulative coupon payments in Ether per investor and period

Table 5: Cash flow in Ether per investor and period

Table 6: Cumulative coupon payments in Ether per investor and period

1 Introduction

A few month ago was the tenth anniversary of the Bitcoin White Paper publication. (Nakamoto (2008)) Originally intended to be an innovative electronic payment system that could redefine the meaning of the word trust within the financial system, it turned out that the technology Bitcoin is based on, Blockchain, could have a disruptive impact on other industries as well. (The Economist (2015)) Blockchain enthusiasts, private companies, government and academic institutions are currently trying to stake out and unlock the full spectrum of the technology's potential. (Pavlus (2018, p.58)) It is becoming apparent that the areas in which the blockchain will likely drive profound change are the financial industry, the public sector, the energy sector, the Internet of Things, the supply chain management, the medical technology or the media industry. (Schütte et al. (2017, p.6))

The financial industry is currently undertaking most of the blockchain research projects. (Schütte et al. (2017, p.27)) Capital market transactions are among the use cases that are being examined in this sector. Many players are involved in these transactions, resulting in high costs and long transaction times. By integrating blockchain technology into the settlement of security transactions, the cost and complexity of the processes might be significantly reduced and the settlement time substantially shortened as the trading parties can interact directly with each other. (Schütte et al. (2017, p.28))

The crucial instrument for the realization of these potentials are smart contracts, enabled by the Ethereum Blockchain. (Buterin (2013, p.1)) These self-executing agreements facilitate direct transactions between two parties without intermediaries and can be individually designed and set up due to Ethereum's open source nature. (Laurence (2017, p.64)) The Ethereum developer community has already programmed smart contracts for a wide variety of use cases within the financial sector and published their source codes on platforms. If you search on these platforms for smart contracts that aim to facilitate securities transactions, you will find some that cover the issuing of company shares and the management of dividend payments. (Proebsting (2018a)) However, there is a lack of smart contracts in the documentation that allow the issuance and trading of bonds. This is the starting point of this master thesis.

The requirements for the design of such a smart contract are going to be derived from the payment mechanisms of a fixed-interest corporate bond as well as from the established standard for token contracts. The smart contract will be coded and tested in the integrated development environment Remix.

The text assumes basic knowledge about blockchain technology and one of its variants, Ethereum. Therefore the thesis starts with information about smart contracts, the programming language Solidity, the concept of tokens and the established token standard ERC20 in chapter 2. The payment logic and equations for the valuation of a corporate bond are then presented in the following chapter. In Chapter 4, the requirements are derived from the previous presentations. Section 5 introduces the development environment Remix. Chapter 6 shows the contract’s source code and clarifies its features. The contract is being tested by two test simulations in the seventh section. Finally, the contract is going to be discussed in chapter 8.

2 Smart Contracts

The idea of computer programs that automatically enforce agreements originated from Nick Szabo, published in 1994. (Szabo (1994)) Smart contracts, as they are called, lacked practical implementation for years, partly due to technical resource constraints. About two decades later, the founders of Ethereum took up the idea again. (Tapscott and Tapscott (2017, pp.140, 141)) In the Ethereum white paper, smart contracts are defined as programs that “automatically move digital assets according to arbitrary pre-specified rules.” (Buterin (2013, p.1)) These value transfers not necessarily solely involve the exchange of cryptocurrency between two parties, (Antonopoulos (2017, p.275)) also realizable are interchanges of other kinds of information, like digital signatures of physical goods. Thereby Ethereum has expanded the application range of blockchain technology and increased the likelihood that it will have a deeper impact on our economy and everyday life. (Laurence (2017, pp.30, 156))

However, the most important and obvious use cases for blockchain-based smart contracts are within the finance sector. (Biryukov et al. (2017, p.2)) Successful proof-of-concept projects around the world show how securities transactions can be conducted more cost-effectively, quickly, transparently and securely in the future. (Schütte et al. (2017, pp.22, 28))

To give some examples: At the end of 2016, the German Stock Exchange and the German Bundesbank presented a blockchain prototype for the settlement of securities. (Deutsche Bundesbank and Deutsche Börse (2018, p.2)) The American stock exchange NASDAQ, enables private investors to digitally manage their securities through its blockchain application Linq. (Nasdaq (2015, p.1)) The Australian ASX Group, a major stock exchange operator, intends to settle securities via the blockchain in the near future. ( (2017)) Last but not least, Daimler AG, in cooperation with the South German regional bank LBBW, has already documented bond placements using blockchain technology. (Atzler (2017))

Many of the proof-of-concept projects are carried out by the institutions, which theoretically could become dispensable through the blockchain. (Schütte et al. (2017, p.27)) But one of the key visions for the Ethereum project is to give as many economic actors as possible the opportunity to write the financial agreements they conclude with each other without intermediaries. (Buterin (2013, p.13)) For this reason Ethereum has an open source character and provides extensive documentation on how to write your own Smart Contracts in the programming language Solidity. (

2.1 Solidity

Solidity is a high-level, Turing-complete, programming language with similarities to JavaScript and C. It is not the only language used in Ethereum applications, but currently the most common. (Dannen (2017, p.72)) Solidity is constantly evolving, but could be replaced in the future, as it has happened with predecessors. (Crypto (2019)) The most important features of Solidity used for the design of the bond contract are presented in the following paragraphs.

Functions are executable units that change the state variables of a contract. ( (2019a)) They are used to produce values, like numbers, or true or false statements. (Dannen (2017, p.82)) A function can be available for programs outside the contract. Public functions are visible externally as well as internally, one can interact with these functions via a user interface. The default visibility status of functions is private, meaning that the function is only visible within the current contract. (Dannen (2017, p.83)) State variables have the same possible visibilities. ( (2019b))

Via Function Modifiers the behavior of functions can be changed. As used in the bond contract, they can add a condition that must be fulfilled prior to the execution of the function. They are often used when the same lines of code are needed several times within a contract in order to write these lines only once. ( (2019c))

The most common value types in Solidity are Booleans, Signed and Unsigned Integers, Strings and Addresses. Booleans abbreviated with bool are true or false expressions. Signed integers, denoted as int, are negative, whereas unsigned integers, uint, are positive numbers. Strings are sequences of letters enclosed in double or single quotation marks. ( (2019d)) Each account in Ethereum is assigned to an address consisting of 20 bytes of hexadecimal characters. (Buterin (2013, p.13)) Address types have two member types, transfer and balance. These enable to move ether to an account or to request the balance of the account. (Dannen (2017, p.83))

Address-related keywords allow to initiate the execution of common tasks in solidity using the member types:

- <Address>.balance returns the balance of an address in Wei.
- <Address>.transfer sends a given amount of Wei to the address.
- this.balance outputs the balance of the current contract. (Dannen (2017, p.84))

The three complex reference types struct, mapping and array can be used to combine data of more storage than the usual 256 bits of memory. (Dannen (2017, p.84)) Structs are used to group several variables together. ( (2019e)) Mappings assign two values, which can be of different types, to each other. (Dannen (2017, p.84)) By specifying a key value as a parameter, a corresponding value is output. ( (2019f)) Arrays enable to construct lists of any type with an either fixed or dynamic number of elements. ( (2019g))

Global special variables are available for all Solidity smart contracts. Block or transaction properties, time or ether units are subsumed under these variables. Some examples:

- now displays the block’s timestamp in seconds since Unix epoch
- msg.sender returns the address of the transaction call sender
- msg.value is the amount of Wei sent with the message, i.e. transaction (Dannen (2017, p.85))

The operators that have been used within the bond contract are given in the table below. (Dannen (2017, pp.86, 87))

Abbildung in dieser Leseprobe nicht enthalten

Table 1: Used Solidity Operators in bond contract.

Source: Dannen (2017, pp.86, 87)

2.2 Tokens

Tokens are basically a variation of a smart contract and can be considered as digital coins. (Dannen (2017, p.71)) Thus constitute a sub-currency within the applied blockchain protocol if recognized as such by the user community. They can also be utilized as crypto assets, representing company shares, services, physical goods or bonds, as done in the elaborated smart contract. (Dannen (2017, pp.97, 98))

The issuing of tokens within the scope of so-called ICOs (Initial Coin Offerings) is an important instrument of blockchain start-ups to generate funds. In this context, the tokens are associated with shares of the young company or vouchers for the use of its services. (European Banking Authority (2019, p.4)) Several years there were no technical standards to be met for neither these token offerings nor the token itself. (European Central Bank (2018, p.8)) In 2015 such a standard has been introduced by the smart contract developer community. (Azimdoust (2019))

2.3 ERC20 standard

With the ERC20 tokens, a uniform standard has emerged whose rules are widely accepted and adhered to by the majority of smart contract developers. (Azimdoust (2019))

The name consists of the abbreviation for "Ethereum Request for Comments" and the number of the community’s attempts to create a framework for standardizing the functionalities of tokens. This set of rules aims to facilitate and unify the token development process while providing sufficient space for the development of innovative blockchain solutions and increasing usability. ( (2018))

Azimdoust (2019) summarizes the advantages of the ERC20 standard by: “They enable unified and quick transactions, more efficient transaction confirmations, a reduction of the contract violation risk and a more efficient and faster interaction with other tokens.”

The ERC20 standard asks for six function s and two event s to be integrated in the contract. ( (2018)) The required functions determine how tokens must be transferred and how token-related data can be accessed. Events contain formatting specifications for the logging of transactions in the blockchain. ( (2019))

The required functions:

1 A function which outputs the total amount of supplied token is required.
2 The token balance of a token owner needs to be accessible.
3 The transfer of token from one account to another has to be possible.
4 There needs to be a function that assigns a party the allowance to sell token on behalf of someone.
5 It must be possible for the entrusted party to actually assert the allowance and send the tokens on behalf of someone to a third party.
6 One should be able to have insight over how many tokens a party still has a right of disposal. ( (2018))

The required events:

1 The token needs a logging structure that occurs when tokens have been transferred.
2 And also a logging structure, if a disposal permission was granted. ( (2018))

The standard was adhered to during the development of the bond smart contract.

3 Corporate Bonds

In the context of this master's thesis, the word bond always refers to a fixed-interest corporate bond.

The logic of a bond is simple: Once the loan has been handed over to the borrower, the lender receives regular interest payments over the term of the loan. When the due date is reached, the original loan amount is repaid. (Ross et al. (2008, p.192))

A fictitious example to illustrate the payment structure and to define the key figures of a bond: Company X considers to borrow 400,000 € for 5 years, spread on 10 bonds. In order to attract borrower, X needs to pay interest on the loan and competes with other investment opportunities. Company X decides to give 5 percent interest per year, since this is the assumed corresponding interest rate offered by similar companies for similar debt issued. Thus, Company X pays 0.05 * 400,000 € = 20,000 € interest per annum during the 5-year term of the bonds. At the end of the fifth period X will repay the 400,000 € to the lender, 40,000 € per bond. (Ross et al. (2008, p.193)) The annual payment of 2,000 € interests per bond from X to the investors is the bond’s coupon. The coupon rate is equal to the coupon paid every year divided by the face value. Based on the example the equation delivers 2,000 € / 40,000 € = 0.05 or 5 percent as coupon rate. The amount that an investor loans to X per bond and gets repaid at the end is called face value, par value or nominal value of a bond. The maturity represents the date on which the nominal value is repaid to the lender. (Ross et al. (2008, p.193)) The cash flow for each bond is:

Abbildung in dieser Leseprobe nicht enthalten

Table 2: Cumulative coupon payments from issuer to investor after each period.

What happens when the market interest rate changes within the term and the owner considers to trade the bond? Since the cash flow of a bond stays the same over the whole term, a changing market interest rate results in a fluctuating value of the bond. Assuming a raising interest rate, the present value of the bond’s cash flow decreases, thus the bond’s worth shrinks. Vice versa, a lower interest rate leads to an appreciation of the bond. The influential factors for the current value of a bond’s cash flow are the remaining time until maturity, the face value, the coupon, and the interest rate given for bonds with alike key data. (Ross et al. (2008, p.193))

Our example:

There are 4 years left to maturity and the market interest rate raises to 6 percent. How does this affect the present value of the bond?

Present value = € 40,000 / 1.064 = € 40,000 / 1.2625 = 31,683.75 €

The bond cash flow is worth:

Annuity present value = € 2,000 * (1 – 1/1.064) / 0.06 = 6,930.21 €

Added together one receives the bond’s present value of:

Total bond value = 31,683.75 €+ 6,930.21 € = 38,613.96 €

The reason why the bond now sells for less than the 40,000 € face value is that the coupon rate of the bond lies one percentage point below the market interest rate. It would be rational for investors to purchase Company X’s bonds, when they are compensated for the annual coupon loss. A balancing effect is reached by a lower price. (Ross et al. (2008, pp.194, 195))

Combining the separate equations for determining the present value of the bond, one generates a general expression for a bond’s value:

Abbildung in dieser Leseprobe nicht enthalten

C is the coupon paid per period, r refers to the market interest rate, t is equal to the periods remaining to maturity and F is the face value of the bond.

The first summand equals the calculation for the present value of the bonds, the second corresponds to the present value of the face value. (Ross et al. (2008, p.196))

In addition to the price of a bond, the yield, or the effective rate, plays a key role in the purchase decision of the potential buyer. Calculated by the equation below:

Abbildung in dieser Leseprobe nicht enthalten

The coupon rate in percent is denoted with c, p is equal to the purchase price of the bond in percent of the face value and t, again, refers to the remaining periods to maturity. (Altrogge (1996, p.127))

3.1 and 3.2 have been used in the developed bond contract.

4 Requirements for the Smart Contract

The contract should meet the following list of requirements resulting from the transaction mechanisms of a corporate bond, while complying with the ERC20 standard in order to gain community acceptance and achieve high usability. Note, that these are mere technical requirements for the smart contract’s source code. Legal aspects to be considered for the authorization to offer a technical product for financial services have not been taken into account for the preparation of this thesis.

1. The issuer is able to input the issuing volume, the face value, the coupon interest rate, and the term as bond key data.
2. Two types of bond transactions are enabled, firstly between the issuer and an investor and secondly between two investors. The purchaser receives a digital representation of a bond, a token, in return for providing the seller with the corresponding bond value in Ether.
3. The contract allows the issuer to make recurring coupon interests payments.
4. The contract allows the issuer to transfer the face values back to the investors at maturity.

5 Remix

The Remix compiler is a browser- based Integrated Development Environment (IDE) for smart contracts. ( (2017)) Remix facilitates developer to write, deploy and interact with smart contracts, and has been used to develop and test the bond contract. ( (2019a)) The following paragraphs shall introduce the most important features of Remix.

Abbildung in dieser Leseprobe nicht enthalten

In order to create a new contract the developer opens a new Solidity file, by clicking on the plus symbol in the upper left corner. ( (2019d)) The developer needs to select a Solidity version by clicking on the “Compile” tab and choosing the desired version in the list. The chosen version in the compiler tab has to be identical to the version given in your first code line. ( (2019c)) By choosing “Auto compile”, each time when the smart contract code is changed, remix recompiles anew. Syntax errors or warnings are shown in the editor next to the code line numbering. ( (2019b))

Abbildung in dieser Leseprobe nicht enthalten

In the Run tab one can choose between three environments, Injected Web3, Web3 provider and JavaScript VM. The first two environments require that Remix is plugged to one of the following external tools: An Ethereum Node, Mist or Metamask. ( (2019e)) For the development of the bond contract the JavaScript VM has been selected. In this environment all transaction will be passed to a sandbox blockchain in the browser, which is recreated every time when you reload the page, no transaction will be persistent. Below Environment, in the Account field, five test addresses are selectable, initialized with 100 Ether each. If needed, more test accounts can be added. The Gas limit for each transaction in Remix defaults to 3,000,000. Underneath the Gas limit section, one can set the Ether V alue attached to a transaction. After every transaction this value is reset to 0. There are also smaller Ether units that can be picked. The unit Wei for instance, which is the smallest unit of the currency Ether. One Ether is equal to a Quintillion Wei (1018). Solidity calculates and displays all currency transactions in Wei by default. ( (2019f))

Abbildung in dieser Leseprobe nicht enthalten

Below the Value field is the section where new instances can be created. Via Deploy the developer can send a transaction into the sandbox blockchain that creates a new instance of the contract type which is selected in the contract list. When the constructor function of the contract needs parameters as arguments, the developer has to specify them in the line next to the Deploy button. In the section Deployed Contracts the developer can interact with the implemented contract and try out whether the integrated function work in the desired way. Red buttons represent functions that modify the state of the blockchain. Blue buttons only retrieve the data of the contract, clicking them does not create a new transaction and thus does not change the state of the blockchain. ( (2019f))

Abbildung in dieser Leseprobe nicht enthalten

The terminal, below the code editor, displays a message whether the transaction has been mined successfully and could be added to the sandbox blockchain. Validating the transaction can take several seconds, in which the terminal signalizes that it is in a pending state.

The file explorer on the left lists all Solidity files stored in the developer’s browser. It also contains contract files that have been imported by one of the contracts, for instance parent contracts for the usage of oracle services. The developer can rename, delete or add a new file in this section. ( (2019d))

6 The Bond Token Smart Contract

This section introduces the program code of the developed smart contract and explains its functions. The complete program code can be found in the appendix.

The screenshots in this chapter were taken in the open source text editor Atom for better readability and not in the Remix IDE, where the actual coding took place.

Abbildung in dieser Leseprobe nicht enthalten

The syntax of the first line specifies that the source code is written for Solidity version 0.4.24. As already stated in the Remix chapter, this version has to be consistent with the selected compiler version in the “Settings” section. The seventh line commands the creation of a contract with the name BondContract, which in the following is also called Bond Token Smart Contract or Bond Token Contract. ( (2019h))

Abbildung in dieser Leseprobe nicht enthalten

The combination of the struct AccountBondData and the mapping BalancesOf store bond data and link it to an investor's account. It connects four variables, of type unsigned integer with 256 bytes, grouped together by the struct, to one Ethereum address. The mapping has a visibility status public, in order to make the values of the struct variables accessible and to meet the second required function of the EC20 standard. The first variable of the struct, SumOfBondToken, records the number of all bonds held by a single account. The second variable, SumOfFaceValues, represents the total of all bond’s face values assigned to an account. The third variable contains the amount of coupon interests, which has been transferred to an investor’s address, memorized by the SumOfTransferredCoupons variable. The fourth variable within the struct, TimesCouponTransferredToAccount, serves as counter variable for how often the coupon payments have already been made. (Will it Scale-Channel (2017a))

Abbildung in dieser Leseprobe nicht enthalten

A second struct, PurchaseOfferData, serves as storage for trade relevant data. This struct contains the amount of offered token, denoted as AmountOfOfferedBondToken, the trading price per Bond Token, represented by the variable TradingPricePerBondTokenInWei, and the Yield that could be realized by taking the offer. Data within the struct is changed with the help of the mapping MyOfferData, which connects the struct data with two addresses, the potential seller’s and purchaser’s address . (Will it Scale-Channel (2017a))

The lines subsequent to the second struct and before the constructor function are used for the declaration of variables. ( (2019i)) In order to keep the length of the thesis within reasonable limits and due to their triviality, the declaration is not documented and explained here, and can instead be studied in the appendix.

Abbildung in dieser Leseprobe nicht enthalten

The contract is being built and deployed in the sandbox blockchain via the constructor function. The issuing company inputs four arguments: The issuance volume, and the nominal value, both given in Ether, the coupon rate in percent and the term of the bond, given in years. The visibility is set to public, obviously, since the function needs to be accessible for it’s users. ( (2019j)) The constructor is also payable, making it possible for the function to receive Ether. The state changing expressions of a function are enclosed in curly brackets. ( (2019k))

Abbildung in dieser Leseprobe nicht enthalten

The lines within the curly brackets of the constructor function process the inputs passed by the initiator. The input parameters are being transformed from a temporary variable into a permanent state variable and converted from Ether to Wei, the unit in which Solidity does currency related calculations. Each expression is terminated by a semicolon. Msg.sender refers to the address that initiated a function call. (Dannen (2017, p.85)) The initiator of the constructor function is assigned to the variable Issuer. SafeMultiplication and SafeAddition are used to prevent calculations from an integer overflow. (Dourlens (2017)) The arguments within the brackets are the products, of the multiplication, respectively the summands of the addition. The decimals variable is set to 18 to convert the currency bearing variables from Ether to Wei, such that the term (uint256(10) ** decimals) is equal to ten to the power of eighteen, the conversion rate from Ether to Wei. Two parameters are getting converted into Wei. The IssuanceVolumeInEther and the BondTokenFaceValueInEther variable. (Proebsting (2018a))

Abbildung in dieser Leseprobe nicht enthalten

Still within the constructor function, the maturity of the Bond Tokens is calculated in the Solidity supported time format seconds since the UNIX epoch, i.e. Solidity does all time related computing in seconds. ( (2019l)) The UNIX time started at 00:00:00 UTC on January 1st 1970. ( (2019k)) Also, the end of the Bond Token sale is determined. The code within the constructor function also creates new tokens, each representing one bond, denoted as Bond Token. The amount of disposable Bond Tokens is calculated by the division (safeDivision) of the issuance volume and the Bond Token face value, and gets stored in the public variable TotalBondTokenSupply, leading to the fulfillment of the first required function for the ERC20 standard. Initially the code assigns all tokens to the issuer’s account address. (Proebsting (2018b)) The syntax for updating a specific struct variable is shown in the last line of the screenshot above. It is composed of the mapping name, followed by the key value of the mapping put in square brackets, and a dot followed by the name of the variable. This sequence is equaled to the new value. (Will it Scale-Channel (2017a))

Abbildung in dieser Leseprobe nicht enthalten

The function BuyBondTokenFromIssuer is one of the key features within the contract. With this function the contract fulfils the third of the required functions for the ERC20 standard. It takes one argument of type uint256, the amount of Bond Tokens the purchaser aims to acquire. This function obviously demands to be payable, allowing the Bond-Token-owner-to-be to attach the required Ether amount as transaction price. When all conditions within the function are met, the terminal outputs “True” as signal that the transaction has been successful. ( (2019k))

Abbildung in dieser Leseprobe nicht enthalten

Within the BuyBondTokenFromIssuer function code lines the transaction price is calculated as product of the face value and the token amount. Furthermore there are three conditions that must be fulfilled for processing the function, reflected by the three require statements. 1. The transaction price needs to be equal or less than the remaining amount of Ether that the issuer aims to collect. 2. The Ether value that is attached to the function call needs to equal the transaction price. 3. The token sale has not ended yet. (Proebsting (2018b))

Abbildung in dieser Leseprobe nicht enthalten

The lines of the above screenshot update the data of the struct variables SumOfFaceValues and SumOfBondToken of the issuer’s as well as of the investor’s account. The temporary variable investor acts as a shortcut for the sequence of the mapping BalancesOf and the msg.sender as key value. Investors.push(msg.sender) adds the address of the message sender as new entry in the Investors array. (Will it Scale-Channel (2017a))

Abbildung in dieser Leseprobe nicht enthalten


Excerpt out of 69 pages


Bringing Blockchain to Corporate Finance. A Smart Contract for Corporate Bonds
Catalog Number
ISBN (eBook)
ISBN (Book)
Internet of Things, solidity, token, ERC20 standard, corporate bonds
Quote paper
Christian Schäfer (Author), 2020, Bringing Blockchain to Corporate Finance. A Smart Contract for Corporate Bonds, Munich, GRIN Verlag,


  • No comments yet.
Look inside the ebook
Title: Bringing Blockchain to Corporate Finance. A Smart Contract for Corporate Bonds

Upload papers

Your term paper / thesis:

- Publication as eBook and book
- High royalties for the sales
- Completely free - with ISBN
- It only takes five minutes
- Every paper finds readers

Publish now - it's free