mirror of
https://github.com/corda/corda.git
synced 2025-06-14 21:28:14 +00:00
Regen docsite
This commit is contained in:
Mike Hearn
266
docs/build/html/tutorial-contract-clauses.html
vendored
266
docs/build/html/tutorial-contract-clauses.html
vendored
@ -89,7 +89,9 @@
|
||||
<ul>
|
||||
<li class="toctree-l1"><a class="reference internal" href="inthebox.html">What’s included?</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="getting-set-up.html">Getting set up</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="getting-set-up-fault-finding.html">Getting Set Up : Faultfinding</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="running-the-demos.html">Running the demos</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="CLI-vs-IDE.html">CLI vs IDE</a></li>
|
||||
</ul>
|
||||
<p class="caption"><span class="caption-text">Key concepts</span></p>
|
||||
<ul>
|
||||
@ -97,6 +99,16 @@
|
||||
<li class="toctree-l1"><a class="reference internal" href="transaction-data-types.html">Data types</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="merkle-trees.html">Transaction tear-offs</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="consensus.html">Consensus model</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="clauses.html">Clauses key concepts</a></li>
|
||||
</ul>
|
||||
<p class="caption"><span class="caption-text">CorDapps</span></p>
|
||||
<ul>
|
||||
<li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapps Background</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html#gradle-plugins-for-cordapps">Gradle plugins for CorDapps</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp Template</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html#building-the-cordapp-template">Building the CorDapp template</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html#running-the-sample-cordapp">Running the Sample CorDapp</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html#using-the-sample-cordapp">Using the sample CorDapp</a></li>
|
||||
</ul>
|
||||
<p class="caption"><span class="caption-text">The Corda node</span></p>
|
||||
<ul>
|
||||
@ -110,30 +122,30 @@
|
||||
<li class="toctree-l1"><a class="reference internal" href="node-explorer.html">Node Explorer</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="permissioning.html">Network permissioning</a></li>
|
||||
</ul>
|
||||
<p class="caption"><span class="caption-text">CorDapps</span></p>
|
||||
<ul>
|
||||
<li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">Creating a CorDapp</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html#gradle-plugins-for-cordapps">Gradle plugins for CorDapps</a></li>
|
||||
</ul>
|
||||
<p class="caption"><span class="caption-text">Tutorials</span></p>
|
||||
<ul class="current">
|
||||
<li class="toctree-l1"><a class="reference internal" href="where-to-start.html">Where to start</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="tutorial-contract.html">Writing a contract</a></li>
|
||||
<li class="toctree-l1 current"><a class="current reference internal" href="#">Writing a contract using clauses</a><ul>
|
||||
<li class="toctree-l2"><a class="reference internal" href="#what-are-clauses-and-why-to-use-them">What are clauses and why to use them?</a></li>
|
||||
<li class="toctree-l2"><a class="reference internal" href="#how-clauses-work">How clauses work?</a></li>
|
||||
<li class="toctree-l2"><a class="reference internal" href="#commercial-paper-class">Commercial paper class</a></li>
|
||||
<li class="toctree-l2"><a class="reference internal" href="#clauses">Clauses</a></li>
|
||||
<li class="toctree-l2"><a class="reference internal" href="#simple-clauses">Simple Clauses</a></li>
|
||||
<li class="toctree-l2"><a class="reference internal" href="#group-clause">Group clause</a></li>
|
||||
<li class="toctree-l2"><a class="reference internal" href="#summary">Summary</a></li>
|
||||
<li class="toctree-l2"><a class="reference internal" href="#debugging">Debugging</a></li>
|
||||
</ul>
|
||||
</li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="tutorial-test-dsl.html">Writing a contract test</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="tutorial-integration-testing.html">Integration Test Tutorial</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="tutorial-clientrpc-api.html">Client RPC API tutorial</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="tutorial-building-transactions.html">Building Transactions</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="flow-state-machines.html">Writing flows</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="flow-testing.html">Writing flow tests</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="running-a-notary.html">Running a notary service</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="using-a-notary.html">Using a notary service</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="oracles.html">Writing oracle services</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="oracles.html#implementing-an-oracle-with-continuously-varying-data">Implementing an oracle with continuously varying data</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="oracles.html#using-an-oracle">Using an oracle</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="tutorial-attachments.html">Using attachments</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="event-scheduling.html">Event scheduling</a></li>
|
||||
</ul>
|
||||
@ -150,6 +162,8 @@
|
||||
<p class="caption"><span class="caption-text">Appendix</span></p>
|
||||
<ul>
|
||||
<li class="toctree-l1"><a class="reference internal" href="loadtesting.html">Load testing</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="setting-up-a-corda-network.html">Introduction - What is a corda network?</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="setting-up-a-corda-network.html#setting-up-your-own-network">Setting up your own network</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="secure-coding-guidelines.html">Secure coding guidelines</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="release-process.html">Release process</a></li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="release-process.html#steps-to-cut-a-release">Steps to cut a release</a></li>
|
||||
@ -208,44 +222,51 @@
|
||||
<script type="text/javascript" src="_static/codesets.js"></script><div class="section" id="writing-a-contract-using-clauses">
|
||||
<h1>Writing a contract using clauses<a class="headerlink" href="#writing-a-contract-using-clauses" title="Permalink to this headline">¶</a></h1>
|
||||
<p>This tutorial will take you through restructuring the commercial paper contract to use clauses. You should have
|
||||
already completed “<a class="reference internal" href="tutorial-contract.html"><span class="doc">Writing a contract</span></a>”.</p>
|
||||
already completed “<a class="reference internal" href="tutorial-contract.html"><span class="doc">Writing a contract</span></a>”.
|
||||
As before, the example is focused on basic implementation of commercial paper, which is essentially a simpler version of a corporate
|
||||
bond. A company issues CP with a particular face value, say $100, but sells it for less, say $90. The paper can be redeemed
|
||||
for cash at a given date in the future. Thus this example would have a 10% interest rate with a single repayment.
|
||||
Whole Kotlin code can be found in <code class="docutils literal"><span class="pre">CommercialPaper.kt</span></code>.</p>
|
||||
<div class="section" id="what-are-clauses-and-why-to-use-them">
|
||||
<h2>What are clauses and why to use them?<a class="headerlink" href="#what-are-clauses-and-why-to-use-them" title="Permalink to this headline">¶</a></h2>
|
||||
<p>Clauses are essentially micro-contracts which contain independent verification logic, and can be logically composed
|
||||
together to form a contract. Clauses are designed to enable re-use of common logic, for example issuing state objects
|
||||
together to form a contract. Clauses are designed to enable re-use of common verification parts, for example issuing state objects
|
||||
is generally the same for all fungible contracts, so a common issuance clause can be inherited for each contract’s
|
||||
issue clause. This cuts down on scope for error, and improves consistency of behaviour. By splitting verification logic
|
||||
into smaller chunks, they can also be readily tested in isolation.</p>
|
||||
<p>Clauses can be composed of subclauses, for example the <code class="docutils literal"><span class="pre">AllClause</span></code> or <code class="docutils literal"><span class="pre">AnyClause</span></code> clauses take list of clauses
|
||||
that they delegate to. Clauses can also change the scope of states and commands being verified, for example grouping
|
||||
together fungible state objects and running a clause against each distinct group.</p>
|
||||
<p>The commercial paper contract has a <code class="docutils literal"><span class="pre">Group</span></code> outermost clause, which contains the <code class="docutils literal"><span class="pre">Issue</span></code>, <code class="docutils literal"><span class="pre">Move</span></code> and <code class="docutils literal"><span class="pre">Redeem</span></code>
|
||||
clauses. The result is a contract that looks something like this:</p>
|
||||
<blockquote>
|
||||
<div><ol class="arabic">
|
||||
<li><dl class="first docutils">
|
||||
<dt>Group input and output states together, and then apply the following clauses on each group:</dt>
|
||||
<dd><ol class="first last loweralpha simple">
|
||||
<li>If an <code class="docutils literal"><span class="pre">Issue</span></code> command is present, run appropriate tests and end processing this group.</li>
|
||||
<li>If a <code class="docutils literal"><span class="pre">Move</span></code> command is present, run appropriate tests and end processing this group.</li>
|
||||
<li>If a <code class="docutils literal"><span class="pre">Redeem</span></code> command is present, run appropriate tests and end processing this group.</li>
|
||||
</ol>
|
||||
</dd>
|
||||
</dl>
|
||||
</li>
|
||||
</ol>
|
||||
</div></blockquote>
|
||||
</div>
|
||||
<div class="section" id="how-clauses-work">
|
||||
<h2>How clauses work?<a class="headerlink" href="#how-clauses-work" title="Permalink to this headline">¶</a></h2>
|
||||
<p>We have different types of clauses, the most basic are the ones that define verification logic for particular command set.
|
||||
We will see them later as elementary building blocks that commercial paper consist of - <code class="docutils literal"><span class="pre">Move</span></code>, <code class="docutils literal"><span class="pre">Issue</span></code> and <code class="docutils literal"><span class="pre">Redeem</span></code>.
|
||||
As a developer you need to identify reusable parts of your contract and decide how they should be combined. It is where
|
||||
composite clauses become useful. They gather many clause subcomponents and resolve how and which of them should be checked.</p>
|
||||
<p>For example, assume that we want to verify a transaction using all constraints defined in separate clauses. We need to
|
||||
wrap classes that define them into <code class="docutils literal"><span class="pre">AllComposition</span></code> composite clause. It assures that all clauses from that combination
|
||||
match with commands in a transaction - only then verification logic can be executed.
|
||||
It may be a little confusing, but composite clause is also a clause and you can even wrap it in the special grouping clause.
|
||||
In <code class="docutils literal"><span class="pre">CommercialPaper</span></code> it looks like that:</p>
|
||||
<img alt="_images/commPaperClauses.png" src="_images/commPaperClauses.png" />
|
||||
<p>The most basic types of composite clauses are <code class="docutils literal"><span class="pre">AllComposition</span></code>, <code class="docutils literal"><span class="pre">AnyComposition</span></code> and <code class="docutils literal"><span class="pre">FirstComposition</span></code>.
|
||||
In this tutorial we will use <code class="docutils literal"><span class="pre">GroupClauseVerifier</span></code> and <code class="docutils literal"><span class="pre">AnyComposition</span></code>. It’s important to understand how they work.
|
||||
Charts showing execution and more detailed information can be found in <a class="reference internal" href="clauses.html"><span class="doc">Clauses key concepts</span></a>.</p>
|
||||
</div>
|
||||
<div class="section" id="commercial-paper-class">
|
||||
<h2>Commercial paper class<a class="headerlink" href="#commercial-paper-class" title="Permalink to this headline">¶</a></h2>
|
||||
<p>To use the clause verification logic, the contract needs to call the <code class="docutils literal"><span class="pre">verifyClause</span></code> function, passing in the
|
||||
transaction, a clause to verify, and a collection of commands the clauses are expected to handle all of. This list of
|
||||
commands is important because <code class="docutils literal"><span class="pre">verifyClause</span></code> checks that none of the commands are left unprocessed at the end, and
|
||||
raises an error if they are. The top level clause would normally be a composite clause (such as <code class="docutils literal"><span class="pre">AnyComposition</span></code>,
|
||||
<code class="docutils literal"><span class="pre">AllComposition</span></code>, etc.) which contains further clauses. The following examples are trimmed to the modified class
|
||||
definition and added elements, for brevity:</p>
|
||||
<span id="verify-ref"></span><h2>Commercial paper class<a class="headerlink" href="#commercial-paper-class" title="Permalink to this headline">¶</a></h2>
|
||||
<p>We start from defining <code class="docutils literal"><span class="pre">CommercialPaper</span></code> class. As in previous tutorial we need some elementary parts: <code class="docutils literal"><span class="pre">Commands</span></code> interface,
|
||||
<code class="docutils literal"><span class="pre">generateMove</span></code>, <code class="docutils literal"><span class="pre">generateIssue</span></code>, <code class="docutils literal"><span class="pre">generateRedeem</span></code> - so far so good that stays the same. The new part is verification and
|
||||
<code class="docutils literal"><span class="pre">Clauses</span></code> interface (you will see them later in code). Let’s start from the basic structure:</p>
|
||||
<div class="codeset container">
|
||||
<div class="highlight-kotlin"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">CommercialPaper</span> <span class="p">:</span> <span class="n">Contract</span> <span class="p">{</span>
|
||||
<span class="k">override</span> <span class="k">val</span> <span class="py">legalContractReference</span><span class="p">:</span> <span class="n">SecureHash</span> <span class="p">=</span> <span class="n">SecureHash</span><span class="p">.</span><span class="n">sha256</span><span class="p">(</span><span class="s">"https://en.wikipedia.org/wiki/Commercial_paper"</span><span class="p">)</span>
|
||||
|
||||
<span class="k">override</span> <span class="k">fun</span> <span class="nf">verify</span><span class="p">(</span><span class="n">tx</span><span class="p">:</span> <span class="n">TransactionForContract</span><span class="p">)</span> <span class="p">=</span> <span class="n">verifyClause</span><span class="p">(</span><span class="n">tx</span><span class="p">,</span> <span class="n">Clauses</span><span class="p">.</span><span class="n">Group</span><span class="p">(),</span> <span class="n">tx</span><span class="p">.</span><span class="n">commands</span><span class="p">.</span><span class="n">select</span><span class="p"><</span><span class="n">Commands</span><span class="p">>())</span>
|
||||
|
||||
<span class="k">interface</span> <span class="nc">Commands</span> <span class="p">:</span> <span class="n">CommandData</span> <span class="p">{</span>
|
||||
<span class="k">data</span> <span class="k">class</span> <span class="nc">Move</span><span class="p">(</span><span class="k">override</span> <span class="k">val</span> <span class="py">contractHash</span><span class="p">:</span> <span class="n">SecureHash</span><span class="p">?</span> <span class="p">=</span> <span class="k">null</span><span class="p">)</span> <span class="p">:</span> <span class="n">FungibleAsset</span><span class="p">.</span><span class="n">Commands</span><span class="p">.</span><span class="n">Move</span><span class="p">,</span> <span class="n">Commands</span>
|
||||
<span class="k">class</span> <span class="nc">Redeem</span> <span class="p">:</span> <span class="n">TypeOnlyCommandData</span><span class="p">(),</span> <span class="n">Commands</span>
|
||||
<span class="k">data</span> <span class="k">class</span> <span class="nc">Issue</span><span class="p">(</span><span class="k">override</span> <span class="k">val</span> <span class="py">nonce</span><span class="p">:</span> <span class="n">Long</span> <span class="p">=</span> <span class="n">random63BitValue</span><span class="p">())</span> <span class="p">:</span> <span class="n">IssueCommand</span><span class="p">,</span> <span class="n">Commands</span>
|
||||
<span class="p">}</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="highlight-java"><div class="highlight"><pre><span></span><span class="kd">public</span> <span class="kd">class</span> <span class="nc">CommercialPaper</span> <span class="kd">implements</span> <span class="n">Contract</span> <span class="o">{</span>
|
||||
@ -258,85 +279,132 @@ definition and added elements, for brevity:</p>
|
||||
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">verify</span><span class="o">(</span><span class="nd">@NotNull</span> <span class="n">TransactionForContract</span> <span class="n">tx</span><span class="o">)</span> <span class="kd">throws</span> <span class="n">IllegalArgumentException</span> <span class="o">{</span>
|
||||
<span class="n">ClauseVerifier</span><span class="o">.</span><span class="na">verifyClause</span><span class="o">(</span><span class="n">tx</span><span class="o">,</span> <span class="k">new</span> <span class="n">Clauses</span><span class="o">.</span><span class="na">Group</span><span class="o">(),</span> <span class="n">extractCommands</span><span class="o">(</span><span class="n">tx</span><span class="o">));</span>
|
||||
<span class="o">}</span>
|
||||
|
||||
<span class="kd">public</span> <span class="kd">interface</span> <span class="nc">Commands</span> <span class="kd">extends</span> <span class="n">CommandData</span> <span class="o">{</span>
|
||||
<span class="kd">class</span> <span class="nc">Move</span> <span class="kd">implements</span> <span class="n">Commands</span> <span class="o">{</span>
|
||||
<span class="nd">@Override</span>
|
||||
<span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">equals</span><span class="o">(</span><span class="n">Object</span> <span class="n">obj</span><span class="o">)</span> <span class="o">{</span> <span class="k">return</span> <span class="n">obj</span> <span class="k">instanceof</span> <span class="n">Move</span><span class="o">;</span> <span class="o">}</span>
|
||||
<span class="o">}</span>
|
||||
|
||||
<span class="kd">class</span> <span class="nc">Redeem</span> <span class="kd">implements</span> <span class="n">Commands</span> <span class="o">{</span>
|
||||
<span class="nd">@Override</span>
|
||||
<span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">equals</span><span class="o">(</span><span class="n">Object</span> <span class="n">obj</span><span class="o">)</span> <span class="o">{</span> <span class="k">return</span> <span class="n">obj</span> <span class="k">instanceof</span> <span class="n">Redeem</span><span class="o">;</span> <span class="o">}</span>
|
||||
<span class="o">}</span>
|
||||
|
||||
<span class="kd">class</span> <span class="nc">Issue</span> <span class="kd">implements</span> <span class="n">Commands</span> <span class="o">{</span>
|
||||
<span class="nd">@Override</span>
|
||||
<span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">equals</span><span class="o">(</span><span class="n">Object</span> <span class="n">obj</span><span class="o">)</span> <span class="o">{</span> <span class="k">return</span> <span class="n">obj</span> <span class="k">instanceof</span> <span class="n">Issue</span><span class="o">;</span> <span class="o">}</span>
|
||||
<span class="o">}</span>
|
||||
<span class="o">}</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
<p>As you can see we used <code class="docutils literal"><span class="pre">verifyClause</span></code> function with <code class="docutils literal"><span class="pre">Clauses.Group()</span></code> in place of previous verification.
|
||||
It’s an entry point to running clause logic. <code class="docutils literal"><span class="pre">verifyClause</span></code> takes the transaction, a clause (usually a composite one)
|
||||
to verify, and a collection of commands the clause is expected to handle all of. This list of commands is important because
|
||||
<code class="docutils literal"><span class="pre">verifyClause</span></code> checks that none of the commands are left unprocessed at the end, and raises an error if they are.</p>
|
||||
</div>
|
||||
<div class="section" id="clauses">
|
||||
<h2>Clauses<a class="headerlink" href="#clauses" title="Permalink to this headline">¶</a></h2>
|
||||
<p>We’ll tackle the inner clauses that contain the bulk of the verification logic, first, and the clause which handles
|
||||
grouping of input/output states later. The clauses must extend the <code class="docutils literal"><span class="pre">Clause</span></code> abstract class, which defines
|
||||
the <code class="docutils literal"><span class="pre">verify</span></code> function, and the <code class="docutils literal"><span class="pre">requiredCommands</span></code> property used to determine the conditions under which a clause
|
||||
is triggered. Composite clauses should extend the <code class="docutils literal"><span class="pre">CompositeClause</span></code> abstract class, which extends <code class="docutils literal"><span class="pre">Clause</span></code> to
|
||||
add support for wrapping around multiple clauses.</p>
|
||||
<p>The <code class="docutils literal"><span class="pre">verify</span></code> function defined in the <code class="docutils literal"><span class="pre">Clause</span></code> interface is similar to the conventional <code class="docutils literal"><span class="pre">Contract</span></code> verification
|
||||
function, although it adds new parameters and returns the set of commands which it has processed. Normally this returned
|
||||
set is identical to the <code class="docutils literal"><span class="pre">requiredCommands</span></code> used to trigger the clause, however in some cases the clause may process
|
||||
further optional commands which it needs to report that it has handled.</p>
|
||||
<p>The <code class="docutils literal"><span class="pre">Move</span></code> clause for the commercial paper contract is relatively simple, so we will start there:</p>
|
||||
<div class="section" id="simple-clauses">
|
||||
<h2>Simple Clauses<a class="headerlink" href="#simple-clauses" title="Permalink to this headline">¶</a></h2>
|
||||
<p>Let’s move to constructing contract logic in terms of clauses language. Commercial paper contract has three commands and
|
||||
three corresponding behaviours: <code class="docutils literal"><span class="pre">Issue</span></code>, <code class="docutils literal"><span class="pre">Move</span></code> and <code class="docutils literal"><span class="pre">Redeem</span></code>. Each of them has a specific set of requirements that must be satisfied -
|
||||
perfect material for defining clauses. For brevity we will show only <code class="docutils literal"><span class="pre">Move</span></code> clause, rest is constructed in similar manner
|
||||
and included in the <code class="docutils literal"><span class="pre">CommercialPaper.kt</span></code> code.</p>
|
||||
<div class="codeset container">
|
||||
<div class="highlight-kotlin"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Move</span><span class="p">:</span> <span class="n">Clause</span><span class="p"><</span><span class="n">State</span><span class="p">,</span> <span class="n">Commands</span><span class="p">,</span> <span class="n">Issued</span><span class="p"><</span><span class="n">Terms</span><span class="p">>>()</span> <span class="p">{</span>
|
||||
<span class="k">override</span> <span class="k">val</span> <span class="py">requiredCommands</span><span class="p">:</span> <span class="n">Set</span><span class="p"><</span><span class="n">Class</span><span class="p"><</span><span class="k">out</span> <span class="n">CommandData</span><span class="p">>></span>
|
||||
<span class="k">get</span><span class="p">()</span> <span class="p">=</span> <span class="n">setOf</span><span class="p">(</span><span class="n">Commands</span><span class="p">.</span><span class="n">Move</span><span class="o">::</span><span class="k">class</span><span class="p">.</span><span class="n">java</span><span class="p">)</span>
|
||||
<div class="highlight-kotlin"><div class="highlight"><pre><span></span><span class="k">interface</span> <span class="nc">Clauses</span> <span class="p">{</span>
|
||||
<span class="k">class</span> <span class="nc">Move</span><span class="p">:</span> <span class="n">Clause</span><span class="p"><</span><span class="n">State</span><span class="p">,</span> <span class="n">Commands</span><span class="p">,</span> <span class="n">Issued</span><span class="p"><</span><span class="n">Terms</span><span class="p">>>()</span> <span class="p">{</span>
|
||||
<span class="k">override</span> <span class="k">val</span> <span class="py">requiredCommands</span><span class="p">:</span> <span class="n">Set</span><span class="p"><</span><span class="n">Class</span><span class="p"><</span><span class="k">out</span> <span class="n">CommandData</span><span class="p">>></span>
|
||||
<span class="k">get</span><span class="p">()</span> <span class="p">=</span> <span class="n">setOf</span><span class="p">(</span><span class="n">Commands</span><span class="p">.</span><span class="n">Move</span><span class="o">::</span><span class="k">class</span><span class="p">.</span><span class="n">java</span><span class="p">)</span>
|
||||
|
||||
<span class="k">override</span> <span class="k">fun</span> <span class="nf">verify</span><span class="p">(</span><span class="n">tx</span><span class="p">:</span> <span class="n">TransactionForContract</span><span class="p">,</span>
|
||||
<span class="k">override</span> <span class="k">fun</span> <span class="nf">verify</span><span class="p">(</span><span class="n">tx</span><span class="p">:</span> <span class="n">TransactionForContract</span><span class="p">,</span>
|
||||
<span class="n">inputs</span><span class="p">:</span> <span class="n">List</span><span class="p"><</span><span class="n">State</span><span class="p">>,</span>
|
||||
<span class="n">outputs</span><span class="p">:</span> <span class="n">List</span><span class="p"><</span><span class="n">State</span><span class="p">>,</span>
|
||||
<span class="n">commands</span><span class="p">:</span> <span class="n">List</span><span class="p"><</span><span class="n">AuthenticatedObject</span><span class="p"><</span><span class="n">Commands</span><span class="p">>>,</span>
|
||||
<span class="n">groupingKey</span><span class="p">:</span> <span class="n">Issued</span><span class="p"><</span><span class="n">Terms</span><span class="p">>?):</span> <span class="n">Set</span><span class="p"><</span><span class="n">Commands</span><span class="p">></span> <span class="p">{</span>
|
||||
<span class="k">val</span> <span class="py">command</span> <span class="p">=</span> <span class="n">commands</span><span class="p">.</span><span class="n">requireSingleCommand</span><span class="p"><</span><span class="n">Commands</span><span class="p">.</span><span class="n">Move</span><span class="p">>()</span>
|
||||
<span class="k">val</span> <span class="py">input</span> <span class="p">=</span> <span class="n">inputs</span><span class="p">.</span><span class="n">single</span><span class="p">()</span>
|
||||
<span class="n">requireThat</span> <span class="p">{</span>
|
||||
<span class="s">"the transaction is signed by the owner of the CP"</span> <span class="k">by</span> <span class="p">(</span><span class="n">input</span><span class="p">.</span><span class="n">owner</span> <span class="k">in</span> <span class="n">command</span><span class="p">.</span><span class="n">signers</span><span class="p">)</span>
|
||||
<span class="s">"the state is propagated"</span> <span class="k">by</span> <span class="p">(</span><span class="n">outputs</span><span class="p">.</span><span class="n">size</span> <span class="p">==</span> <span class="m">1</span><span class="p">)</span>
|
||||
<span class="k">val</span> <span class="py">command</span> <span class="p">=</span> <span class="n">commands</span><span class="p">.</span><span class="n">requireSingleCommand</span><span class="p"><</span><span class="n">Commands</span><span class="p">.</span><span class="n">Move</span><span class="p">>()</span>
|
||||
<span class="k">val</span> <span class="py">input</span> <span class="p">=</span> <span class="n">inputs</span><span class="p">.</span><span class="n">single</span><span class="p">()</span>
|
||||
<span class="n">requireThat</span> <span class="p">{</span>
|
||||
<span class="s">"the transaction is signed by the owner of the CP"</span> <span class="k">by</span> <span class="p">(</span><span class="n">input</span><span class="p">.</span><span class="n">owner</span> <span class="k">in</span> <span class="n">command</span><span class="p">.</span><span class="n">signers</span><span class="p">)</span>
|
||||
<span class="s">"the state is propagated"</span> <span class="k">by</span> <span class="p">(</span><span class="n">outputs</span><span class="p">.</span><span class="n">size</span> <span class="p">==</span> <span class="m">1</span><span class="p">)</span>
|
||||
<span class="c1">// Don't need to check anything else, as if outputs.size == 1 then the output is equal to</span>
|
||||
<span class="c1">// the input ignoring the owner field due to the grouping.</span>
|
||||
<span class="p">}</span>
|
||||
<span class="k">return</span> <span class="n">setOf</span><span class="p">(</span><span class="n">command</span><span class="p">.</span><span class="n">value</span><span class="p">)</span>
|
||||
<span class="p">}</span>
|
||||
<span class="p">}</span>
|
||||
<span class="p">...</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="highlight-java"><div class="highlight"><pre><span></span><span class="kd">public</span> <span class="kd">interface</span> <span class="nc">Clauses</span> <span class="o">{</span>
|
||||
<span class="kd">class</span> <span class="nc">Move</span> <span class="kd">extends</span> <span class="n">Clause</span><span class="o"><</span><span class="n">State</span><span class="o">,</span> <span class="n">Commands</span><span class="o">,</span> <span class="n">State</span><span class="o">></span> <span class="o">{</span>
|
||||
<span class="nd">@NotNull</span>
|
||||
<span class="nd">@Override</span>
|
||||
<span class="kd">public</span> <span class="n">Set</span><span class="o"><</span><span class="n">Class</span><span class="o"><?</span> <span class="kd">extends</span> <span class="n">CommandData</span><span class="o">>></span> <span class="nf">getRequiredCommands</span><span class="o">()</span> <span class="o">{</span>
|
||||
<span class="k">return</span> <span class="n">Collections</span><span class="o">.</span><span class="na">singleton</span><span class="o">(</span><span class="n">Commands</span><span class="o">.</span><span class="na">Move</span><span class="o">.</span><span class="na">class</span><span class="o">);</span>
|
||||
<span class="o">}</span>
|
||||
|
||||
<span class="nd">@NotNull</span>
|
||||
<span class="nd">@Override</span>
|
||||
<span class="kd">public</span> <span class="n">Set</span><span class="o"><</span><span class="n">Commands</span><span class="o">></span> <span class="nf">verify</span><span class="o">(</span><span class="nd">@NotNull</span> <span class="n">TransactionForContract</span> <span class="n">tx</span><span class="o">,</span>
|
||||
<span class="nd">@NotNull</span> <span class="n">List</span><span class="o"><?</span> <span class="kd">extends</span> <span class="n">State</span><span class="o">></span> <span class="n">inputs</span><span class="o">,</span>
|
||||
<span class="nd">@NotNull</span> <span class="n">List</span><span class="o"><?</span> <span class="kd">extends</span> <span class="n">State</span><span class="o">></span> <span class="n">outputs</span><span class="o">,</span>
|
||||
<span class="nd">@NotNull</span> <span class="n">List</span><span class="o"><?</span> <span class="kd">extends</span> <span class="n">AuthenticatedObject</span><span class="o"><?</span> <span class="kd">extends</span> <span class="n">Commands</span><span class="o">>></span> <span class="n">commands</span><span class="o">,</span>
|
||||
<span class="nd">@NotNull</span> <span class="n">State</span> <span class="n">groupingKey</span><span class="o">)</span> <span class="o">{</span>
|
||||
<span class="n">AuthenticatedObject</span><span class="o"><</span><span class="n">Commands</span><span class="o">.</span><span class="na">Move</span><span class="o">></span> <span class="n">cmd</span> <span class="o">=</span> <span class="n">requireSingleCommand</span><span class="o">(</span><span class="n">tx</span><span class="o">.</span><span class="na">getCommands</span><span class="o">(),</span> <span class="n">Commands</span><span class="o">.</span><span class="na">Move</span><span class="o">.</span><span class="na">class</span><span class="o">);</span>
|
||||
<span class="c1">// There should be only a single input due to aggregation above</span>
|
||||
<span class="n">State</span> <span class="n">input</span> <span class="o">=</span> <span class="n">single</span><span class="o">(</span><span class="n">inputs</span><span class="o">);</span>
|
||||
|
||||
<span class="k">if</span> <span class="o">(!</span><span class="n">cmd</span><span class="o">.</span><span class="na">getSigners</span><span class="o">().</span><span class="na">contains</span><span class="o">(</span><span class="n">input</span><span class="o">.</span><span class="na">getOwner</span><span class="o">()))</span>
|
||||
<span class="k">throw</span> <span class="k">new</span> <span class="n">IllegalStateException</span><span class="o">(</span><span class="s">"Failed requirement: the transaction is signed by the owner of the CP"</span><span class="o">);</span>
|
||||
|
||||
<span class="c1">// Check the output CP state is the same as the input state, ignoring the owner field.</span>
|
||||
<span class="k">if</span> <span class="o">(</span><span class="n">outputs</span><span class="o">.</span><span class="na">size</span><span class="o">()</span> <span class="o">!=</span> <span class="mi">1</span><span class="o">)</span> <span class="o">{</span>
|
||||
<span class="k">throw</span> <span class="k">new</span> <span class="n">IllegalStateException</span><span class="o">(</span><span class="s">"the state is propagated"</span><span class="o">);</span>
|
||||
<span class="o">}</span>
|
||||
<span class="c1">// Don't need to check anything else, as if outputs.size == 1 then the output is equal to</span>
|
||||
<span class="c1">// the input ignoring the owner field due to the grouping.</span>
|
||||
<span class="p">}</span>
|
||||
<span class="k">return</span> <span class="n">setOf</span><span class="p">(</span><span class="n">command</span><span class="p">.</span><span class="n">value</span><span class="p">)</span>
|
||||
<span class="p">}</span>
|
||||
<span class="p">}</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="highlight-java"><div class="highlight"><pre><span></span><span class="kd">class</span> <span class="nc">Move</span> <span class="kd">extends</span> <span class="n">Clause</span><span class="o"><</span><span class="n">State</span><span class="o">,</span> <span class="n">Commands</span><span class="o">,</span> <span class="n">State</span><span class="o">></span> <span class="o">{</span>
|
||||
<span class="nd">@NotNull</span>
|
||||
<span class="nd">@Override</span>
|
||||
<span class="kd">public</span> <span class="n">Set</span><span class="o"><</span><span class="n">Class</span><span class="o"><?</span> <span class="kd">extends</span> <span class="n">CommandData</span><span class="o">>></span> <span class="nf">getRequiredCommands</span><span class="o">()</span> <span class="o">{</span>
|
||||
<span class="k">return</span> <span class="n">Collections</span><span class="o">.</span><span class="na">singleton</span><span class="o">(</span><span class="n">Commands</span><span class="o">.</span><span class="na">Move</span><span class="o">.</span><span class="na">class</span><span class="o">);</span>
|
||||
<span class="o">}</span>
|
||||
|
||||
<span class="nd">@NotNull</span>
|
||||
<span class="nd">@Override</span>
|
||||
<span class="kd">public</span> <span class="n">Set</span><span class="o"><</span><span class="n">Commands</span><span class="o">></span> <span class="nf">verify</span><span class="o">(</span><span class="nd">@NotNull</span> <span class="n">TransactionForContract</span> <span class="n">tx</span><span class="o">,</span>
|
||||
<span class="nd">@NotNull</span> <span class="n">List</span><span class="o"><?</span> <span class="kd">extends</span> <span class="n">State</span><span class="o">></span> <span class="n">inputs</span><span class="o">,</span>
|
||||
<span class="nd">@NotNull</span> <span class="n">List</span><span class="o"><?</span> <span class="kd">extends</span> <span class="n">State</span><span class="o">></span> <span class="n">outputs</span><span class="o">,</span>
|
||||
<span class="nd">@NotNull</span> <span class="n">List</span><span class="o"><?</span> <span class="kd">extends</span> <span class="n">AuthenticatedObject</span><span class="o"><?</span> <span class="kd">extends</span> <span class="n">Commands</span><span class="o">>></span> <span class="n">commands</span><span class="o">,</span>
|
||||
<span class="nd">@NotNull</span> <span class="n">State</span> <span class="n">groupingKey</span><span class="o">)</span> <span class="o">{</span>
|
||||
<span class="n">AuthenticatedObject</span><span class="o"><</span><span class="n">Commands</span><span class="o">.</span><span class="na">Move</span><span class="o">></span> <span class="n">cmd</span> <span class="o">=</span> <span class="n">requireSingleCommand</span><span class="o">(</span><span class="n">tx</span><span class="o">.</span><span class="na">getCommands</span><span class="o">(),</span> <span class="n">Commands</span><span class="o">.</span><span class="na">Move</span><span class="o">.</span><span class="na">class</span><span class="o">);</span>
|
||||
<span class="c1">// There should be only a single input due to aggregation above</span>
|
||||
<span class="n">State</span> <span class="n">input</span> <span class="o">=</span> <span class="n">single</span><span class="o">(</span><span class="n">inputs</span><span class="o">);</span>
|
||||
|
||||
<span class="k">if</span> <span class="o">(!</span><span class="n">cmd</span><span class="o">.</span><span class="na">getSigners</span><span class="o">().</span><span class="na">contains</span><span class="o">(</span><span class="n">input</span><span class="o">.</span><span class="na">getOwner</span><span class="o">()))</span>
|
||||
<span class="k">throw</span> <span class="k">new</span> <span class="n">IllegalStateException</span><span class="o">(</span><span class="s">"Failed requirement: the transaction is signed by the owner of the CP"</span><span class="o">);</span>
|
||||
|
||||
<span class="c1">// Check the output CP state is the same as the input state, ignoring the owner field.</span>
|
||||
<span class="k">if</span> <span class="o">(</span><span class="n">outputs</span><span class="o">.</span><span class="na">size</span><span class="o">()</span> <span class="o">!=</span> <span class="mi">1</span><span class="o">)</span> <span class="o">{</span>
|
||||
<span class="k">throw</span> <span class="k">new</span> <span class="n">IllegalStateException</span><span class="o">(</span><span class="s">"the state is propagated"</span><span class="o">);</span>
|
||||
<span class="k">return</span> <span class="n">Collections</span><span class="o">.</span><span class="na">singleton</span><span class="o">(</span><span class="n">cmd</span><span class="o">.</span><span class="na">getValue</span><span class="o">());</span>
|
||||
<span class="o">}</span>
|
||||
<span class="c1">// Don't need to check anything else, as if outputs.size == 1 then the output is equal to</span>
|
||||
<span class="c1">// the input ignoring the owner field due to the grouping.</span>
|
||||
<span class="k">return</span> <span class="n">Collections</span><span class="o">.</span><span class="na">singleton</span><span class="o">(</span><span class="n">cmd</span><span class="o">.</span><span class="na">getValue</span><span class="o">());</span>
|
||||
<span class="o">}</span>
|
||||
<span class="o">}</span>
|
||||
<span class="o">...</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
<p>We took part of code for <code class="docutils literal"><span class="pre">Command.Move</span></code> verification from previous tutorial and put it into the verify function
|
||||
of <code class="docutils literal"><span class="pre">Move</span></code> class. Notice that this class must extend the <code class="docutils literal"><span class="pre">Clause</span></code> abstract class, which defines
|
||||
the <code class="docutils literal"><span class="pre">verify</span></code> function, and the <code class="docutils literal"><span class="pre">requiredCommands</span></code> property used to determine the conditions under which a clause
|
||||
is triggered. In the above example it means that the clause will run verification when the <code class="docutils literal"><span class="pre">Commands.Move</span></code> is present in a transaction.</p>
|
||||
<div class="admonition note">
|
||||
<p class="first admonition-title">Note</p>
|
||||
<p class="last">Notice that commands refer to all input and output states in a transaction. For clause to be executed, transaction has
|
||||
to include all commands from <code class="docutils literal"><span class="pre">requiredCommands</span></code> set.</p>
|
||||
</div>
|
||||
<p>Few important changes:</p>
|
||||
<ul class="simple">
|
||||
<li><code class="docutils literal"><span class="pre">verify</span></code> function returns the set of commands which it has processed. Normally this returned set is identical to the
|
||||
<code class="docutils literal"><span class="pre">requiredCommands</span></code> used to trigger the clause, however in some cases the clause may process further optional commands
|
||||
which it needs to report that it has handled.</li>
|
||||
<li>Verification takes new parameters. Usually inputs and outputs are some subset of the original transaction entries
|
||||
passed to the clause by outer composite or grouping clause. <code class="docutils literal"><span class="pre">groupingKey</span></code> is a key used to group original states.</li>
|
||||
</ul>
|
||||
<p>As a simple example imagine input states:</p>
|
||||
<ol class="arabic simple">
|
||||
<li>1000 GBP issued by Bank of England</li>
|
||||
<li>500 GBP issued by Bank of England</li>
|
||||
<li>1000 GBP issued by Bank of Scotland</li>
|
||||
</ol>
|
||||
<p>We will group states by Issuer so in the first group we have inputs 1 and 2, in second group input number 3. Grouping keys are:
|
||||
‘GBP issued by Bank of England’ and ‘GBP issued by Bank of Scotland’.</p>
|
||||
<p>How the states can be grouped and passed in that form to the <code class="docutils literal"><span class="pre">Move</span></code> clause? That leads us to the concept of <code class="docutils literal"><span class="pre">GroupClauseVerifier</span></code>.</p>
|
||||
</div>
|
||||
<div class="section" id="group-clause">
|
||||
<h2>Group clause<a class="headerlink" href="#group-clause" title="Permalink to this headline">¶</a></h2>
|
||||
<p>We need to wrap the move clause (as well as the issue and redeem clauses - see the relevant contract code for their
|
||||
full specifications) in an outer clause that understands how to group contract states and objects. For this we extend
|
||||
the standard <code class="docutils literal"><span class="pre">GroupClauseVerifier</span></code> and specify how to group input/output states, as well as the top-level to run on
|
||||
each group. As with the top level clause on a contract, this is normally a composite clause that delegates to subclauses.</p>
|
||||
<p>We may have a transaction with similar but unrelated state evolutions which need to be validated independently. It
|
||||
makes sense to check <code class="docutils literal"><span class="pre">Move</span></code> command on groups of related inputs and outputs (see example above). Thus, we need to collect
|
||||
relevant states together.
|
||||
For this we extend the standard <code class="docutils literal"><span class="pre">GroupClauseVerifier</span></code> and specify how to group input/output states, as well as the top-level
|
||||
clause to run on each group. In our example a top-level is a composite clause - <code class="docutils literal"><span class="pre">AnyCompostion</span></code> that delegates verification to
|
||||
it’s subclasses (wrapped move, issue, redeem). Any in this case means that it will take 0 or more clauses that match transaction commands.</p>
|
||||
<div class="codeset container">
|
||||
<div class="highlight-kotlin"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Group</span> <span class="p">:</span> <span class="n">GroupClauseVerifier</span><span class="p"><</span><span class="n">State</span><span class="p">,</span> <span class="n">Commands</span><span class="p">,</span> <span class="n">Issued</span><span class="p"><</span><span class="n">Terms</span><span class="p">>>(</span>
|
||||
<span class="n">AnyComposition</span><span class="p">(</span>
|
||||
@ -366,15 +434,17 @@ each group. As with the top level clause on a contract, this is normally a compo
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
<p>For the <code class="docutils literal"><span class="pre">CommercialPaper</span></code> contract, this is the top level clause for the contract, and is passed directly into
|
||||
<code class="docutils literal"><span class="pre">verifyClause</span></code> (see the example code at the top of this tutorial).</p>
|
||||
<p>For the <code class="docutils literal"><span class="pre">CommercialPaper</span></code> contract, <code class="docutils literal"><span class="pre">Group</span></code> is the main clause for the contract, and is passed directly into
|
||||
<code class="docutils literal"><span class="pre">verifyClause</span></code> (see the example code at the top of this tutorial). We used <code class="docutils literal"><span class="pre">groupStates</span></code> function here, it’s worth reminding
|
||||
how it works: <a class="reference internal" href="tutorial-contract.html#state-ref"><span class="std std-ref">Using state groups</span></a>.</p>
|
||||
</div>
|
||||
<div class="section" id="summary">
|
||||
<h2>Summary<a class="headerlink" href="#summary" title="Permalink to this headline">¶</a></h2>
|
||||
<p>In summary the top level contract <code class="docutils literal"><span class="pre">CommercialPaper</span></code> specifies a single grouping clause of type
|
||||
<code class="docutils literal"><span class="pre">CommercialPaper.Clauses.Group</span></code> which in turn specifies <code class="docutils literal"><span class="pre">GroupClause</span></code> implementations for each type of command
|
||||
(<code class="docutils literal"><span class="pre">Redeem</span></code>, <code class="docutils literal"><span class="pre">Move</span></code> and <code class="docutils literal"><span class="pre">Issue</span></code>). This reflects the flow of verification: In order to verify a <code class="docutils literal"><span class="pre">CommercialPaper</span></code>
|
||||
(<code class="docutils literal"><span class="pre">Redeem</span></code>, <code class="docutils literal"><span class="pre">Move</span></code> and <code class="docutils literal"><span class="pre">Issue</span></code>). This reflects the flow of verification: in order to verify a <code class="docutils literal"><span class="pre">CommercialPaper</span></code>
|
||||
we first group states, check which commands are specified, and run command-specific verification logic accordingly.</p>
|
||||
<img alt="_images/commPaperExecution.png" src="_images/commPaperExecution.png" />
|
||||
</div>
|
||||
<div class="section" id="debugging">
|
||||
<h2>Debugging<a class="headerlink" href="#debugging" title="Permalink to this headline">¶</a></h2>
|
||||
@ -404,7 +474,7 @@ performing the validation. To enable this, ensure trace level logging is enabled
|
||||
|
||||
<div role="contentinfo">
|
||||
<p>
|
||||
© Copyright 2016, Distributed Ledger Group, LLC.
|
||||
© Copyright 2016, R3 Limited.
|
||||
|
||||
</p>
|
||||
</div>
|
||||
|
||||
Reference in New Issue
Block a user