Corda Oracle

　       //Oracleから為替レートを取得しコマンドを設定
        val oracle = getOracle(serviceHub)　　　

        //Oracleからデータを取得
        val rateOfferedFromOracle =  subFlow(QueryRate(oracle,symbol))
        
　　　　 //指定したレート以下なら例外発生
        require(rateOfferedFromOracle["open"] as Double > rate)
        
　　　　 //取得したデータをコマンドに挿入
　　　　　val command = Command(
                CoinContract.CoinTrade(rateOfferedFromOracle),
                listOf(ourIdentity.owningKey, oracle.owningKey)
        )

        //TransactionをFilteringする
        val filteredtx = ptx.buildFilteredTransaction(Predicate {
            when (it) {
                is Command<*> -> oracle.owningKey in it.signers && it.value is CoinContract.CoinTrade
                else -> false
            }
        })
        //Oracleの署名を取得
        val oracleSignature =  subFlow(SignRate(oracle,filteredtx,rateOfferedFromOracle["txid"] as SecureHash))

        //Oracleの署名をTransactionに追加
        val stx =  ptx.withAdditionalSignature(oracleSignature)

@Suspendable
override fun call() {
　　　　  //QueryRateから送られた通貨情報を受け取る
        val request = session.receive<String>().unwrap { it }
        val response = try {
            
            //為替レートを受け取る
            val response = serviceHub.cordaService(Oracle::class.java).query(request) 
            
            //為替レートをvaultに登録する
            val stx = subFlow(OracleRateRegistFlow(response))
            response["txid"] = stx.id
            response
        } catch (e: Exception) {
            throw FlowException(e)
        }       
         //QueryRate側のセッションに為替レートを送る
        session.send(response)
    }
}

@Suspendable
override fun call() {    
    //SignRateからFilterTransactionとTransactionIdを受け取る
    val request = session.receive<FilteredTransaction>().unwrap { it }
    val txId = session.receive<SecureHash>().unwrap { it }    
    val response = try {       
        
        //Oracleの署名を受け取る
        serviceHub.cordaService(Oracle::class.java).sign(request, txId)
     } catch (e: Exception) {
        throw FlowException(e)
     }     
     //SignRate側のsessionにOracleの署名を送る
     session.send(response)
 }

fun query(symbol: String): Map<String, Any> {
    val requestUrl = "リクエストするURL"   
    
    //URLオブジェクトを生成
    val url = URL(requestUrl)  
    
    //URLを指定してデータを取得し返す
    return client.newCall(
            Request.Builder()
                    .url(url)
                    .build()
    ).execute().body!!.let {
        val json = it.string()
        val tree = mapper.readTree(json)
        val rate = //JSONオブジェクトを取得    
        
        // 取得したデータをマップに入れる
        val map = linkedMapOf<String, Any>()
        map["open"] = rate["open"].asDouble()
        map["currencyPairCode"] = rate["currencyPairCode"].asText()
        map
    }
}

fun sign(ftx: FilteredTransaction, 
　　　　　txid: SecureHash):TransactionSignature {
    
        //部分的なマークルツリーをチェック 
        ftx.verify()       
    
        val rateState = //Query時に登録したStateを取得する 
    
        fun isCommandWithCorrectRateAndIAmSigner(elem: Any) =
        when {
            elem is Command<*>  && elem.value is CoinContract.CoinTrade -> 
            {
                val cmdData = elem.value as CoinContract.CoinTrade
                myKey in elem.signers && rateState.state.data.open ==　cmdData.map["open"]
            }
            else -> false
        }
    
        //正しいデータかチェック
        val isValidMerkleTree = ftx.checkWithFun(::isCommandWithCorrectRateAndIAmSigner)
    
        //他のコマンドがオラクルによる署名を必要としないことを確認     
        ftx.checkCommandVisibility(services.myInfo.legalIdentities.first().owningKey) 
        if (isValidMerkleTree) {
            return services.createSignature(ftx, myKey)
        } else {
            throw IllegalArgumentException("Oracle signature requested over invalid transaction.")
        }
    }
}

@InitiatingFlow
@StartableByRPC
class CoinTradeFlow(val symbol: String,　//取得する通貨単位
                    val quantity: Double, //交換するJPYの量
                    val rate: Double,　//交換する最低レート
                    val issuer : Party　//所持しているTokenの発行者
) : FlowLogic<SignedTransaction>() {

    @Suspendable
    override fun call(): SignedTransaction {
        //Notaryを取得
        val notary = serviceHub.networkMapCache.notaryIdentities.first()
        
        //Oracleから為替レート取得しコマンドを設定
        val oracle = getOracle(serviceHub) 
        
        //Oracleからデータを取得
        val rateOfferedFromOracle = subFlow(QueryRate(oracle, symbol))
        
        //指定したレート以下なら例外発生              
        require(rateOfferedFromOracle["open"] as Double > rate) 
        
        //取得したデータをコマンドに挿入
        val command = Command(
                CoinContract.CoinTrade(rateOfferedFromOracle),
                listOf(ourIdentity.owningKey, oracle.owningKey)
        )

        //txの生成
        val txBuilder = TransactionBuilder(notary).addCommand(command)

        //USDに変換するJPYの償還
        val JPYTokenType = TokenType("JPY", 3)
        val amount = amount(quantity, JPYTokenType)
        val queryCriteria =　tokenAmountWithHolderCriteria(JPYTokenType,ourIdentity)

        addFungibleTokensToRedeem(txBuilder,serviceHub,amount,issuer,ourIdentity,queryCriteria)

        //USDTokenの発行
        val USDTokenType = TokenType("USD", 3)
        val issuedTokenType = USDTokenType issuedBy issuer
        val amountUSD = amount.quantity.times(amount.displayTokenSize.toDouble()).div(rateOfferedFromOracle["open"] as Double)
        val fungibleToken = FungibleToken(amount(amountUSD, issuedTokenType), ourIdentity)

        addIssueTokens(txBuilder, fungibleToken)

        txBuilder.verify(serviceHub)
        val ptx = serviceHub.signInitialTransaction(txBuilder)

        //TransactionをFilteringする
        val filtertx = ptx.buildFilteredTransaction(Predicate {
            when (it) {
                is Command<*> -> oracle.owningKey in it.signers 
                           && it.value is CoinContract.CoinTrade
                else -> false
            }
        })       
        
        //Oracleの署名を取得
        val oracleSignature = subFlow(SignRate(oracle, filtertx, rateOfferedFromOracle["txid"] as SecureHash))
        
        //Oracleの署名をTransactionに追加
        val stx :SignedTransaction = ptx.withAdditionalSignature(oracleSignature)

        val issuerSession = initiateFlow(issuer)
        val ftx = subFlow(CollectSignaturesFlow(stx, listOf(issuerSession)))

        return subFlow(FinalityFlow(ftx, listOf(issuerSession)))
    }
}

@InitiatedBy(CoinTradeFlow::class)
class CoinTradeFlowHandler(
        val otherPartySession: FlowSession): FlowLogic<Unit>() {
    @Suspendable
    override fun call() {
        val oracle = getOracle(serviceHub)
        val signTransactionFlow = object: SignTransactionFlow(otherPartySession) {
            override fun checkTransaction(stx: SignedTransaction) = requireThat {
                        
　　　　　　　　//TransactionにOracleの署名が含まれている
             require(stx.sigs.map{it.by}.contains(oracle.owningKey))

            }
        }
        subFlow(signTransactionFlow)

        subFlow(ReceiveFinalityFlow(otherPartySession,statesToRecord = StatesToRecord.ONLY_RELEVANT))
    }
}
//Oracleを取得するためのプライベート関数
private fun getOracle(serviceHub: ServiceHub): Party {
    val oracleName = CordaX500Name("Oracle", "New York", "US")
    return serviceHub.networkMapCache.getNodeByLegalName(oracleName)?.legalIdentities?.first()
            ?: throw IllegalArgumentException("Requested oracle $oracleName not found on network.")
}

@InitiatingFlow
class QueryRate(val oracle: Party,
                val symbol: String)
    : FlowLogic<LinkedHashMap<String,Any>>() {

    @Suspendable override fun call() = initiateFlow(oracle).sendAndReceive<LinkedHashMap<String,Any>>(symbol).unwrap { it }

}

@InitiatedBy(QueryRate::class)
class QueryRateHandler(val session: FlowSession) 
    : FlowLogic<Unit>() {

    @Suspendable
    override fun call() {
    
        //QueryRateから送られた通貨情報を受け取る
        val request = session.receive<String>().unwrap { it }       
        val response = try {  
        
            //為替レートを受け取る
            val response = serviceHub.cordaService(Oracle::class.java).query(request)  
            
            //為替レートをvaultに登録する
            val stx = subFlow(OracleRateRegistFlow(response))
            
            response["txid"] = stx.id
            response
        } catch (e: Exception) {
            throw FlowException(e)
        }     
        
        //QueryRate側のセッションに為替レートを送る
        session.send(response)
    }
}

@InitiatingFlow
class SignRate(val oracle: Party,
               val ftx: FilteredTransaction,
               val txid: SecureHash)
    : FlowLogic<TransactionSignature>() {
    @Suspendable
    override fun call(): TransactionSignature {
        val session = initiateFlow(oracle)
        session.send(ftx)
        return session.sendAndReceive<TransactionSignature>(txid).unwrap { it }
    }
}

@InitiatedBy(SignRate::class)
class SignRateHandler(val session: FlowSession)
    : FlowLogic<Unit>() {
    @Suspendable
    override fun call() {        
        
        //SignRateからFilterTransactionとTransactionIdを受け取る
        val request = session.receive<FilteredTransaction>() .unwrap { it }
        val txId = session.receive<SecureHash>().unwrap { it }       
        val response = try {
        
            //Oracleの署名を受け取る
            serviceHub.cordaService(Oracle::class.java).sign(request, txId)
        } catch (e: Exception) {
            throw FlowException(e)
        }        
        //SignRate側のsessionにOracleの署名を送る
        session.send(response)
    }
}

@CordaService
class Oracle(val services: AppServiceHub) : SingletonSerializeAsToken() {

    private var client = OkHttpClient()
    private val mapper = ObjectMapper()
    private val myKey = services.myInfo.legalIdentities.first().owningKey

    fun query(symbol: String): LinkedHashMap<String, Any> {
        val requestUrl = ”リクエストするURL”

        //URLオブジェクトを生成
        val url = URL(requestUrl) //URLを指定してデータを取得し返す
        return client.newCall(Request.Builder().url(url).build()
        ).execute().body!!.let {
                                val json = it.string()
                                val tree = mapper.readTree(json)
                                val rate = //JSONオブジェクトを取得            
                                val map = linkedMapOf<String, Any>()
                                // 取得したデータをマップに入れる
                                map["open"] = rate["open"].asDouble()
                                map["currencyPairCode"] = rate["currencyPairCode"].asText()
                                map
                            }
                                            
    }


    fun sign(ftx: FilteredTransaction, txid: SecureHash)
          : TransactionSignature {        
        //部分的なマークルツリーをチェック
        ftx.verify()　　　　 
              
        //Query時に登録したStateを取得する
        val states = services.vaultService.queryBy<RateState>().states
        val rateState = states.filter { it.ref.txhash == txid }.first()

        fun isCommandWithCorrectRateAndIAmSigner(elem: Any) =
                when {
                    elem is Command<*> && elem.value is CoinContract.CoinTrade->
                    {
                        val cmdData = elem.value as CoinContract.CoinTrade
                        myKey in elem.signers && rateState.state.data.open == cmdData.map["open"]
                    }
                    else -> false
                }

　　　   //正しいデータかチェック
        val isValidMerkleTree = ftx.checkWithFun(::isCommandWithCorrectRateAndIAmSigner)    
        
        //他のコマンドがオラクルによる署名を必要としないことを確認
        ftx.checkCommandVisibility(services.myInfo.legalIdentities.first()owningKey )

        if (isValidMerkleTree) {
            return services.createSignature(ftx, myKey)
        } else {
            throw IllegalArgumentException("Oracle signature requested over invalid transaction.")
        }
    }
}