2017-01-28 21:26:43 -08:00
|
|
|
package ibc
|
|
|
|
|
2017-07-06 04:06:58 -07:00
|
|
|
// import (
|
|
|
|
// "bytes"
|
|
|
|
// "encoding/json"
|
|
|
|
// "errors"
|
|
|
|
// "fmt"
|
|
|
|
// "net/url"
|
|
|
|
// "strconv"
|
|
|
|
// "strings"
|
|
|
|
|
|
|
|
// abci "github.com/tendermint/abci/types"
|
|
|
|
// "github.com/tendermint/go-wire"
|
|
|
|
// merkle "github.com/tendermint/merkleeyes/iavl"
|
|
|
|
// cmn "github.com/tendermint/tmlibs/common"
|
|
|
|
|
|
|
|
// "github.com/tendermint/basecoin/types"
|
|
|
|
// tm "github.com/tendermint/tendermint/types"
|
|
|
|
// )
|
|
|
|
|
|
|
|
// const (
|
|
|
|
// // Key parts
|
|
|
|
// _IBC = "ibc"
|
|
|
|
// _BLOCKCHAIN = "blockchain"
|
|
|
|
// _GENESIS = "genesis"
|
|
|
|
// _STATE = "state"
|
|
|
|
// _HEADER = "header"
|
|
|
|
// _EGRESS = "egress"
|
|
|
|
// _INGRESS = "ingress"
|
|
|
|
// _CONNECTION = "connection"
|
|
|
|
// )
|
|
|
|
|
|
|
|
// type IBCPluginState struct {
|
|
|
|
// // @[:ibc, :blockchain, :genesis, ChainID] <~ BlockchainGenesis
|
|
|
|
// // @[:ibc, :blockchain, :state, ChainID] <~ BlockchainState
|
|
|
|
// // @[:ibc, :blockchain, :header, ChainID, Height] <~ tm.Header
|
|
|
|
// // @[:ibc, :egress, Src, Dst, Sequence] <~ Packet
|
|
|
|
// // @[:ibc, :ingress, Dst, Src, Sequence] <~ Packet
|
|
|
|
// // @[:ibc, :connection, Src, Dst] <~ Connection # TODO - keep connection state
|
|
|
|
// }
|
|
|
|
|
|
|
|
// type BlockchainGenesis struct {
|
|
|
|
// ChainID string
|
|
|
|
// Genesis string
|
|
|
|
// }
|
|
|
|
|
|
|
|
// type BlockchainState struct {
|
|
|
|
// ChainID string
|
|
|
|
// Validators []*tm.Validator
|
|
|
|
// LastBlockHash []byte
|
|
|
|
// LastBlockHeight uint64
|
|
|
|
// }
|
|
|
|
|
|
|
|
// type Packet struct {
|
|
|
|
// SrcChainID string
|
|
|
|
// DstChainID string
|
|
|
|
// Sequence uint64
|
|
|
|
// Type string // redundant now that Type() is a method on Payload ?
|
|
|
|
// Payload Payload
|
|
|
|
// }
|
|
|
|
|
|
|
|
// func NewPacket(src, dst string, seq uint64, payload Payload) Packet {
|
|
|
|
// return Packet{
|
|
|
|
// SrcChainID: src,
|
|
|
|
// DstChainID: dst,
|
|
|
|
// Sequence: seq,
|
|
|
|
// Type: payload.Type(),
|
|
|
|
// Payload: payload,
|
|
|
|
// }
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // GetSequenceNumber gets the sequence number for packets being sent from the src chain to the dst chain.
|
|
|
|
// // The sequence number counts how many packets have been sent.
|
|
|
|
// // The next packet must include the latest sequence number.
|
2017-07-06 05:23:38 -07:00
|
|
|
// func GetSequenceNumber(store state.KVStore, src, dst string) uint64 {
|
2017-07-06 04:06:58 -07:00
|
|
|
// sequenceKey := toKey(_IBC, _EGRESS, src, dst)
|
|
|
|
// seqBytes := store.Get(sequenceKey)
|
|
|
|
// if seqBytes == nil {
|
|
|
|
// return 0
|
|
|
|
// }
|
|
|
|
// seq, err := strconv.ParseUint(string(seqBytes), 10, 64)
|
|
|
|
// if err != nil {
|
|
|
|
// cmn.PanicSanity(err.Error())
|
|
|
|
// }
|
|
|
|
// return seq
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // SetSequenceNumber sets the sequence number for packets being sent from the src chain to the dst chain
|
2017-07-06 05:23:38 -07:00
|
|
|
// func SetSequenceNumber(store state.KVStore, src, dst string, seq uint64) {
|
2017-07-06 04:06:58 -07:00
|
|
|
// sequenceKey := toKey(_IBC, _EGRESS, src, dst)
|
|
|
|
// store.Set(sequenceKey, []byte(strconv.FormatUint(seq, 10)))
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // SaveNewIBCPacket creates an IBC packet with the given payload from the src chain to the dst chain
|
|
|
|
// // using the correct sequence number. It also increments the sequence number by 1
|
2017-07-06 05:23:38 -07:00
|
|
|
// func SaveNewIBCPacket(state state.KVStore, src, dst string, payload Payload) {
|
2017-07-06 04:06:58 -07:00
|
|
|
// // fetch sequence number and increment by 1
|
|
|
|
// seq := GetSequenceNumber(state, src, dst)
|
|
|
|
// SetSequenceNumber(state, src, dst, seq+1)
|
|
|
|
|
|
|
|
// // save ibc packet
|
|
|
|
// packetKey := toKey(_IBC, _EGRESS, src, dst, cmn.Fmt("%v", seq))
|
|
|
|
// packet := NewPacket(src, dst, uint64(seq), payload)
|
|
|
|
// save(state, packetKey, packet)
|
|
|
|
// }
|
|
|
|
|
2017-07-06 05:23:38 -07:00
|
|
|
// func GetIBCPacket(state state.KVStore, src, dst string, seq uint64) (Packet, error) {
|
2017-07-06 04:06:58 -07:00
|
|
|
// packetKey := toKey(_IBC, _EGRESS, src, dst, cmn.Fmt("%v", seq))
|
|
|
|
// packetBytes := state.Get(packetKey)
|
|
|
|
|
|
|
|
// var packet Packet
|
|
|
|
// err := wire.ReadBinaryBytes(packetBytes, &packet)
|
|
|
|
// return packet, err
|
|
|
|
// }
|
|
|
|
|
|
|
|
// //--------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
// const (
|
|
|
|
// PayloadTypeBytes = byte(0x01)
|
|
|
|
// PayloadTypeCoins = byte(0x02)
|
|
|
|
// )
|
|
|
|
|
|
|
|
// var _ = wire.RegisterInterface(
|
|
|
|
// struct{ Payload }{},
|
|
|
|
// wire.ConcreteType{DataPayload{}, PayloadTypeBytes},
|
|
|
|
// wire.ConcreteType{CoinsPayload{}, PayloadTypeCoins},
|
|
|
|
// )
|
|
|
|
|
|
|
|
// type Payload interface {
|
|
|
|
// AssertIsPayload()
|
|
|
|
// Type() string
|
|
|
|
// ValidateBasic() abci.Result
|
|
|
|
// }
|
|
|
|
|
|
|
|
// func (DataPayload) AssertIsPayload() {}
|
|
|
|
// func (CoinsPayload) AssertIsPayload() {}
|
|
|
|
|
|
|
|
// type DataPayload []byte
|
|
|
|
|
|
|
|
// func (p DataPayload) Type() string {
|
|
|
|
// return "data"
|
|
|
|
// }
|
|
|
|
|
|
|
|
// func (p DataPayload) ValidateBasic() abci.Result {
|
|
|
|
// return abci.OK
|
|
|
|
// }
|
|
|
|
|
|
|
|
// type CoinsPayload struct {
|
|
|
|
// Address []byte
|
|
|
|
// Coins types.Coins
|
|
|
|
// }
|
|
|
|
|
|
|
|
// func (p CoinsPayload) Type() string {
|
|
|
|
// return "coin"
|
|
|
|
// }
|
|
|
|
|
|
|
|
// func (p CoinsPayload) ValidateBasic() abci.Result {
|
|
|
|
// // TODO: validate
|
|
|
|
// return abci.OK
|
|
|
|
// }
|
|
|
|
|
|
|
|
// //--------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
// const (
|
|
|
|
// IBCTxTypeRegisterChain = byte(0x01)
|
|
|
|
// IBCTxTypeUpdateChain = byte(0x02)
|
|
|
|
// IBCTxTypePacketCreate = byte(0x03)
|
|
|
|
// IBCTxTypePacketPost = byte(0x04)
|
|
|
|
|
|
|
|
// IBCCodeEncodingError = abci.CodeType(1001)
|
|
|
|
// IBCCodeChainAlreadyExists = abci.CodeType(1002)
|
|
|
|
// IBCCodePacketAlreadyExists = abci.CodeType(1003)
|
|
|
|
// IBCCodeUnknownHeight = abci.CodeType(1004)
|
|
|
|
// IBCCodeInvalidCommit = abci.CodeType(1005)
|
|
|
|
// IBCCodeInvalidProof = abci.CodeType(1006)
|
|
|
|
// )
|
|
|
|
|
|
|
|
// var _ = wire.RegisterInterface(
|
|
|
|
// struct{ IBCTx }{},
|
|
|
|
// wire.ConcreteType{IBCRegisterChainTx{}, IBCTxTypeRegisterChain},
|
|
|
|
// wire.ConcreteType{IBCUpdateChainTx{}, IBCTxTypeUpdateChain},
|
|
|
|
// wire.ConcreteType{IBCPacketCreateTx{}, IBCTxTypePacketCreate},
|
|
|
|
// wire.ConcreteType{IBCPacketPostTx{}, IBCTxTypePacketPost},
|
|
|
|
// )
|
|
|
|
|
|
|
|
// type IBCTx interface {
|
|
|
|
// AssertIsIBCTx()
|
|
|
|
// ValidateBasic() abci.Result
|
|
|
|
// }
|
|
|
|
|
|
|
|
// func (IBCRegisterChainTx) AssertIsIBCTx() {}
|
|
|
|
// func (IBCUpdateChainTx) AssertIsIBCTx() {}
|
|
|
|
// func (IBCPacketCreateTx) AssertIsIBCTx() {}
|
|
|
|
// func (IBCPacketPostTx) AssertIsIBCTx() {}
|
|
|
|
|
|
|
|
// type IBCRegisterChainTx struct {
|
|
|
|
// BlockchainGenesis
|
|
|
|
// }
|
|
|
|
|
|
|
|
// func (IBCRegisterChainTx) ValidateBasic() (res abci.Result) {
|
|
|
|
// // TODO - validate
|
|
|
|
// return
|
|
|
|
// }
|
|
|
|
|
|
|
|
// type IBCUpdateChainTx struct {
|
|
|
|
// Header tm.Header
|
|
|
|
// Commit tm.Commit
|
|
|
|
// // TODO: NextValidators
|
|
|
|
// }
|
|
|
|
|
|
|
|
// func (IBCUpdateChainTx) ValidateBasic() (res abci.Result) {
|
|
|
|
// // TODO - validate
|
|
|
|
// return
|
|
|
|
// }
|
|
|
|
|
|
|
|
// type IBCPacketCreateTx struct {
|
|
|
|
// Packet
|
|
|
|
// }
|
|
|
|
|
|
|
|
// func (IBCPacketCreateTx) ValidateBasic() (res abci.Result) {
|
|
|
|
// // TODO - validate
|
|
|
|
// return
|
|
|
|
// }
|
|
|
|
|
|
|
|
// type IBCPacketPostTx struct {
|
|
|
|
// FromChainID string // The immediate source of the packet, not always Packet.SrcChainID
|
|
|
|
// FromChainHeight uint64 // The block height in which Packet was committed, to check Proof
|
|
|
|
// Packet
|
|
|
|
// Proof *merkle.IAVLProof
|
|
|
|
// }
|
|
|
|
|
|
|
|
// func (IBCPacketPostTx) ValidateBasic() (res abci.Result) {
|
|
|
|
// // TODO - validate
|
|
|
|
// return
|
|
|
|
// }
|
|
|
|
|
|
|
|
// //--------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
// type IBCPlugin struct {
|
|
|
|
// }
|
|
|
|
|
|
|
|
// func (ibc *IBCPlugin) Name() string {
|
|
|
|
// return "IBC"
|
|
|
|
// }
|
|
|
|
|
|
|
|
// func (ibc *IBCPlugin) StateKey() []byte {
|
|
|
|
// return []byte("IBCPlugin.State")
|
|
|
|
// }
|
|
|
|
|
|
|
|
// func New() *IBCPlugin {
|
|
|
|
// return &IBCPlugin{}
|
|
|
|
// }
|
|
|
|
|
2017-07-06 05:23:38 -07:00
|
|
|
// func (ibc *IBCPlugin) SetOption(store state.KVStore, key string, value string) (log string) {
|
2017-07-06 04:06:58 -07:00
|
|
|
// return ""
|
|
|
|
// }
|
|
|
|
|
2017-07-06 05:23:38 -07:00
|
|
|
// func (ibc *IBCPlugin) RunTx(store state.KVStore, ctx types.CallContext, txBytes []byte) (res abci.Result) {
|
2017-07-06 04:06:58 -07:00
|
|
|
// // Decode tx
|
|
|
|
// var tx IBCTx
|
|
|
|
// err := wire.ReadBinaryBytes(txBytes, &tx)
|
|
|
|
// if err != nil {
|
|
|
|
// return abci.ErrBaseEncodingError.AppendLog("Error decoding tx: " + err.Error())
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // Validate tx
|
|
|
|
// res = tx.ValidateBasic()
|
|
|
|
// if res.IsErr() {
|
|
|
|
// return res.PrependLog("ValidateBasic Failed: ")
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // TODO - Check whether sufficient funds
|
|
|
|
|
|
|
|
// defer func() {
|
|
|
|
// // TODO - Refund any remaining funds left over
|
|
|
|
// // e.g. !ctx.Coins.Minus(tx.Fee).IsZero()
|
|
|
|
// // ctx.CallerAccount is synced w/ store, so just modify that and store it.
|
|
|
|
// // NOTE: We should use the CallContext to store fund/refund information.
|
|
|
|
// }()
|
|
|
|
|
|
|
|
// sm := &IBCStateMachine{store, ctx, abci.OK}
|
|
|
|
|
|
|
|
// switch tx := tx.(type) {
|
|
|
|
// case IBCRegisterChainTx:
|
|
|
|
// sm.runRegisterChainTx(tx)
|
|
|
|
// case IBCUpdateChainTx:
|
|
|
|
// sm.runUpdateChainTx(tx)
|
|
|
|
// case IBCPacketCreateTx:
|
|
|
|
// sm.runPacketCreateTx(tx)
|
|
|
|
// case IBCPacketPostTx:
|
|
|
|
// sm.runPacketPostTx(tx)
|
|
|
|
// }
|
|
|
|
|
|
|
|
// return sm.res
|
|
|
|
// }
|
|
|
|
|
|
|
|
// type IBCStateMachine struct {
|
2017-07-06 05:23:38 -07:00
|
|
|
// store state.KVStore
|
2017-07-06 04:06:58 -07:00
|
|
|
// ctx types.CallContext
|
|
|
|
// res abci.Result
|
|
|
|
// }
|
|
|
|
|
|
|
|
// func (sm *IBCStateMachine) runRegisterChainTx(tx IBCRegisterChainTx) {
|
|
|
|
// chainGenKey := toKey(_IBC, _BLOCKCHAIN, _GENESIS, tx.ChainID)
|
|
|
|
// chainStateKey := toKey(_IBC, _BLOCKCHAIN, _STATE, tx.ChainID)
|
|
|
|
// chainGen := tx.BlockchainGenesis
|
|
|
|
|
|
|
|
// // Parse genesis
|
|
|
|
// chainGenDoc := new(tm.GenesisDoc)
|
|
|
|
// err := json.Unmarshal([]byte(chainGen.Genesis), chainGenDoc)
|
|
|
|
// if err != nil {
|
|
|
|
// sm.res.Code = IBCCodeEncodingError
|
|
|
|
// sm.res.Log = "Genesis doc couldn't be parsed: " + err.Error()
|
|
|
|
// return
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // Make sure chainGen doesn't already exist
|
|
|
|
// if exists(sm.store, chainGenKey) {
|
|
|
|
// sm.res.Code = IBCCodeChainAlreadyExists
|
|
|
|
// sm.res.Log = "Already exists"
|
|
|
|
// return
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // Save new BlockchainGenesis
|
|
|
|
// save(sm.store, chainGenKey, chainGen)
|
|
|
|
|
|
|
|
// // Create new BlockchainState
|
|
|
|
// chainState := BlockchainState{
|
|
|
|
// ChainID: chainGenDoc.ChainID,
|
|
|
|
// Validators: make([]*tm.Validator, len(chainGenDoc.Validators)),
|
|
|
|
// LastBlockHash: nil,
|
|
|
|
// LastBlockHeight: 0,
|
|
|
|
// }
|
|
|
|
// // Make validators slice
|
|
|
|
// for i, val := range chainGenDoc.Validators {
|
|
|
|
// pubKey := val.PubKey
|
|
|
|
// address := pubKey.Address()
|
|
|
|
// chainState.Validators[i] = &tm.Validator{
|
|
|
|
// Address: address,
|
|
|
|
// PubKey: pubKey,
|
|
|
|
// VotingPower: val.Amount,
|
|
|
|
// }
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // Save new BlockchainState
|
|
|
|
// save(sm.store, chainStateKey, chainState)
|
|
|
|
// }
|
|
|
|
|
|
|
|
// func (sm *IBCStateMachine) runUpdateChainTx(tx IBCUpdateChainTx) {
|
|
|
|
// chainID := tx.Header.ChainID
|
|
|
|
// chainStateKey := toKey(_IBC, _BLOCKCHAIN, _STATE, chainID)
|
|
|
|
|
|
|
|
// // Make sure chainState exists
|
|
|
|
// if !exists(sm.store, chainStateKey) {
|
|
|
|
// return // Chain does not exist, do nothing
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // Load latest chainState
|
|
|
|
// var chainState BlockchainState
|
|
|
|
// exists, err := load(sm.store, chainStateKey, &chainState)
|
|
|
|
// if err != nil {
|
|
|
|
// sm.res = abci.ErrInternalError.AppendLog(cmn.Fmt("Loading ChainState: %v", err.Error()))
|
|
|
|
// return
|
|
|
|
// }
|
|
|
|
// if !exists {
|
|
|
|
// sm.res = abci.ErrInternalError.AppendLog(cmn.Fmt("Missing ChainState"))
|
|
|
|
// return
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // Check commit against last known state & validators
|
|
|
|
// err = verifyCommit(chainState, &tx.Header, &tx.Commit)
|
|
|
|
// if err != nil {
|
|
|
|
// sm.res.Code = IBCCodeInvalidCommit
|
|
|
|
// sm.res.Log = cmn.Fmt("Invalid Commit: %v", err.Error())
|
|
|
|
// return
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // Store header
|
|
|
|
// headerKey := toKey(_IBC, _BLOCKCHAIN, _HEADER, chainID, cmn.Fmt("%v", tx.Header.Height))
|
|
|
|
// save(sm.store, headerKey, tx.Header)
|
|
|
|
|
|
|
|
// // Update chainState
|
|
|
|
// chainState.LastBlockHash = tx.Header.Hash()
|
|
|
|
// chainState.LastBlockHeight = uint64(tx.Header.Height)
|
|
|
|
|
|
|
|
// // Store chainState
|
|
|
|
// save(sm.store, chainStateKey, chainState)
|
|
|
|
// }
|
|
|
|
|
|
|
|
// func (sm *IBCStateMachine) runPacketCreateTx(tx IBCPacketCreateTx) {
|
|
|
|
// packet := tx.Packet
|
|
|
|
// packetKey := toKey(_IBC, _EGRESS,
|
|
|
|
// packet.SrcChainID,
|
|
|
|
// packet.DstChainID,
|
|
|
|
// cmn.Fmt("%v", packet.Sequence),
|
|
|
|
// )
|
|
|
|
// // Make sure packet doesn't already exist
|
|
|
|
// if exists(sm.store, packetKey) {
|
|
|
|
// sm.res.Code = IBCCodePacketAlreadyExists
|
|
|
|
// // TODO: .AppendLog() does not update sm.res
|
|
|
|
// sm.res.Log = "Already exists"
|
|
|
|
// return
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // Execute the payload
|
|
|
|
// switch payload := tx.Packet.Payload.(type) {
|
|
|
|
// case DataPayload:
|
|
|
|
// // do nothing
|
|
|
|
// case CoinsPayload:
|
|
|
|
// // ensure enough coins were sent in tx to cover the payload coins
|
|
|
|
// if !sm.ctx.Coins.IsGTE(payload.Coins) {
|
|
|
|
// sm.res.Code = abci.CodeType_InsufficientFunds
|
|
|
|
// sm.res.Log = fmt.Sprintf("Not enough funds sent in tx (%v) to send %v via IBC", sm.ctx.Coins, payload.Coins)
|
|
|
|
// return
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // deduct coins from context
|
|
|
|
// sm.ctx.Coins = sm.ctx.Coins.Minus(payload.Coins)
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // Save new Packet
|
|
|
|
// save(sm.store, packetKey, packet)
|
|
|
|
|
|
|
|
// // set the sequence number
|
|
|
|
// SetSequenceNumber(sm.store, packet.SrcChainID, packet.DstChainID, packet.Sequence)
|
|
|
|
// }
|
|
|
|
|
|
|
|
// func (sm *IBCStateMachine) runPacketPostTx(tx IBCPacketPostTx) {
|
|
|
|
// packet := tx.Packet
|
|
|
|
// packetKeyEgress := toKey(_IBC, _EGRESS,
|
|
|
|
// packet.SrcChainID,
|
|
|
|
// packet.DstChainID,
|
|
|
|
// cmn.Fmt("%v", packet.Sequence),
|
|
|
|
// )
|
|
|
|
// packetKeyIngress := toKey(_IBC, _INGRESS,
|
|
|
|
// packet.DstChainID,
|
|
|
|
// packet.SrcChainID,
|
|
|
|
// cmn.Fmt("%v", packet.Sequence),
|
|
|
|
// )
|
|
|
|
// headerKey := toKey(_IBC, _BLOCKCHAIN, _HEADER,
|
|
|
|
// tx.FromChainID,
|
|
|
|
// cmn.Fmt("%v", tx.FromChainHeight),
|
|
|
|
// )
|
|
|
|
|
|
|
|
// // Make sure packet doesn't already exist
|
|
|
|
// if exists(sm.store, packetKeyIngress) {
|
|
|
|
// sm.res.Code = IBCCodePacketAlreadyExists
|
|
|
|
// sm.res.Log = "Already exists"
|
|
|
|
// return
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // Save new Packet (just for fun)
|
|
|
|
// save(sm.store, packetKeyIngress, packet)
|
|
|
|
|
|
|
|
// // Load Header and make sure it exists
|
|
|
|
// // If it exists, we already checked a valid commit for it in UpdateChainTx
|
|
|
|
// var header tm.Header
|
|
|
|
// exists, err := load(sm.store, headerKey, &header)
|
|
|
|
// if err != nil {
|
|
|
|
// sm.res = abci.ErrInternalError.AppendLog(cmn.Fmt("Loading Header: %v", err.Error()))
|
|
|
|
// return
|
|
|
|
// }
|
|
|
|
// if !exists {
|
|
|
|
// sm.res.Code = IBCCodeUnknownHeight
|
|
|
|
// sm.res.Log = cmn.Fmt("Loading Header: Unknown height")
|
|
|
|
// return
|
|
|
|
// }
|
|
|
|
|
|
|
|
// proof := tx.Proof
|
|
|
|
// if proof == nil {
|
|
|
|
// sm.res.Code = IBCCodeInvalidProof
|
|
|
|
// sm.res.Log = "Proof is nil"
|
|
|
|
// return
|
|
|
|
// }
|
|
|
|
// packetBytes := wire.BinaryBytes(packet)
|
|
|
|
|
|
|
|
// // Make sure packet's proof matches given (packet, key, blockhash)
|
|
|
|
// ok := proof.Verify(packetKeyEgress, packetBytes, header.AppHash)
|
|
|
|
// if !ok {
|
|
|
|
// sm.res.Code = IBCCodeInvalidProof
|
|
|
|
// sm.res.Log = fmt.Sprintf("Proof is invalid. key: %s; packetByes %X; header %v; proof %v", packetKeyEgress, packetBytes, header, proof)
|
|
|
|
// return
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // Execute payload
|
|
|
|
// switch payload := packet.Payload.(type) {
|
|
|
|
// case DataPayload:
|
|
|
|
// // do nothing
|
|
|
|
// case CoinsPayload:
|
|
|
|
// // Add coins to destination account
|
|
|
|
// acc := types.GetAccount(sm.store, payload.Address)
|
|
|
|
// if acc == nil {
|
|
|
|
// acc = &types.Account{}
|
|
|
|
// }
|
|
|
|
// acc.Balance = acc.Balance.Plus(payload.Coins)
|
|
|
|
// types.SetAccount(sm.store, payload.Address, acc)
|
|
|
|
// }
|
|
|
|
|
|
|
|
// return
|
|
|
|
// }
|
|
|
|
|
2017-07-06 05:23:38 -07:00
|
|
|
// func (ibc *IBCPlugin) InitChain(store state.KVStore, vals []*abci.Validator) {
|
2017-07-06 04:06:58 -07:00
|
|
|
// }
|
|
|
|
|
2017-07-06 05:23:38 -07:00
|
|
|
// func (cp *IBCPlugin) BeginBlock(store state.KVStore, hash []byte, header *abci.Header) {
|
2017-07-06 04:06:58 -07:00
|
|
|
// }
|
|
|
|
|
2017-07-06 05:23:38 -07:00
|
|
|
// func (cp *IBCPlugin) EndBlock(store state.KVStore, height uint64) (res abci.ResponseEndBlock) {
|
2017-07-06 04:06:58 -07:00
|
|
|
// return
|
|
|
|
// }
|
|
|
|
|
|
|
|
// //--------------------------------------------------------------------------------
|
|
|
|
// // TODO: move to utils
|
|
|
|
|
|
|
|
// // Returns true if exists, false if nil.
|
2017-07-06 05:23:38 -07:00
|
|
|
// func exists(store state.KVStore, key []byte) (exists bool) {
|
2017-07-06 04:06:58 -07:00
|
|
|
// value := store.Get(key)
|
|
|
|
// return len(value) > 0
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // Load bytes from store by reading value for key and read into ptr.
|
|
|
|
// // Returns true if exists, false if nil.
|
|
|
|
// // Returns err if decoding error.
|
2017-07-06 05:23:38 -07:00
|
|
|
// func load(store state.KVStore, key []byte, ptr interface{}) (exists bool, err error) {
|
2017-07-06 04:06:58 -07:00
|
|
|
// value := store.Get(key)
|
|
|
|
// if len(value) > 0 {
|
|
|
|
// err = wire.ReadBinaryBytes(value, ptr)
|
|
|
|
// if err != nil {
|
|
|
|
// return true, errors.New(
|
|
|
|
// cmn.Fmt("Error decoding key 0x%X = 0x%X: %v", key, value, err.Error()),
|
|
|
|
// )
|
|
|
|
// }
|
|
|
|
// return true, nil
|
|
|
|
// } else {
|
|
|
|
// return false, nil
|
|
|
|
// }
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // Save bytes to store by writing obj's go-wire binary bytes.
|
2017-07-06 05:23:38 -07:00
|
|
|
// func save(store state.KVStore, key []byte, obj interface{}) {
|
2017-07-06 04:06:58 -07:00
|
|
|
// store.Set(key, wire.BinaryBytes(obj))
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // Key parts are URL escaped and joined with ','
|
|
|
|
// func toKey(parts ...string) []byte {
|
|
|
|
// escParts := make([]string, len(parts))
|
|
|
|
// for i, part := range parts {
|
|
|
|
// escParts[i] = url.QueryEscape(part)
|
|
|
|
// }
|
|
|
|
// return []byte(strings.Join(escParts, ","))
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // NOTE: Commit's votes include ValidatorAddress, so can be matched up
|
|
|
|
// // against chainState.Validators, even if the validator set had changed.
|
|
|
|
// // For the purpose of the demo, we assume that the validator set hadn't changed,
|
|
|
|
// // though we should check that explicitly.
|
|
|
|
// func verifyCommit(chainState BlockchainState, header *tm.Header, commit *tm.Commit) error {
|
|
|
|
|
|
|
|
// // Ensure that chainState and header ChainID match.
|
|
|
|
// if chainState.ChainID != header.ChainID {
|
|
|
|
// return errors.New(cmn.Fmt("Expected header.ChainID %v, got %v", chainState.ChainID, header.ChainID))
|
|
|
|
// }
|
|
|
|
// // Ensure things aren't empty
|
|
|
|
// if len(chainState.Validators) == 0 {
|
|
|
|
// return errors.New(cmn.Fmt("Blockchain has no validators")) // NOTE: Why would this happen?
|
|
|
|
// }
|
|
|
|
// if len(commit.Precommits) == 0 {
|
|
|
|
// return errors.New(cmn.Fmt("Commit has no signatures"))
|
|
|
|
// }
|
|
|
|
// chainID := chainState.ChainID
|
|
|
|
// vals := chainState.Validators
|
|
|
|
// valSet := tm.NewValidatorSet(vals)
|
|
|
|
|
|
|
|
// var blockID tm.BlockID
|
|
|
|
// for _, pc := range commit.Precommits {
|
|
|
|
// // XXX: incorrect. we want the one for +2/3, not just the first one
|
|
|
|
// if pc != nil {
|
|
|
|
// blockID = pc.BlockID
|
|
|
|
// }
|
|
|
|
// }
|
|
|
|
// if blockID.IsZero() {
|
|
|
|
// return errors.New("All precommits are nil!")
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // NOTE: Currently this only works with the exact same validator set.
|
|
|
|
// // Not this, but perhaps "ValidatorSet.VerifyCommitAny" should expose
|
|
|
|
// // the functionality to verify commits even after validator changes.
|
|
|
|
// err := valSet.VerifyCommit(chainID, blockID, header.Height, commit)
|
|
|
|
// if err != nil {
|
|
|
|
// return err
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // Ensure the committed blockID matches the header
|
|
|
|
// if !bytes.Equal(header.Hash(), blockID.Hash) {
|
|
|
|
// return errors.New(cmn.Fmt("blockID.Hash (%X) does not match header.Hash (%X)", blockID.Hash, header.Hash()))
|
|
|
|
// }
|
|
|
|
|
|
|
|
// // All ok!
|
|
|
|
// return nil
|
|
|
|
// }
|