pier-client-ethereum/direct_event.go at master · meshplus/pier-client-ethereum · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
package main

import (
	"bytes"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/crypto"
	"github.com/meshplus/bitxhub-model/pb"
	"github.com/meshplus/pier-client-ethereum/direct"
)

func (c *Client) Convert2DirectIBTP(ev *direct.BrokerDirectThrowInterchainEvent, timeoutHeight int64) (*pb.IBTP, error) {
	fullEv, encrypt, err := c.fillDirectInterchainEvent(ev)
	if err != nil {
		return nil, err
	}
	pd, err := encodeDirectPayload(fullEv, encrypt)
	if err != nil {
		return nil, err
	}

	return &pb.IBTP{
		From:          ev.SrcFullID,
		To:            ev.DstFullID,
		Index:         ev.Index,
		Type:          pb.IBTP_INTERCHAIN,
		TimeoutHeight: timeoutHeight,
		Proof:         []byte("1"),
		Payload:       pd,
	}, nil
}

func (c *Client) Convert2DirectReceipt(ev *direct.BrokerDirectThrowReceiptEvent) (*pb.IBTP, error) {
	fullEv, encrypt, err := c.fillDirectReceiptEvent(ev)
	if err != nil {
		return nil, err
	}

	return generateReceipt(fullEv.SrcFullID, fullEv.DstFullID, fullEv.Index, fullEv.Results, fullEv.Typ, encrypt, fullEv.MultiStatus)
}

func encodeDirectPayload(ev *direct.BrokerDirectThrowInterchainEvent, encrypt bool) ([]byte, error) {
	var args [][]byte
	args = append(args, ev.Args...)
	//for _, arg := range ev.Args {
	//	args = append(args, arg)
	//}
	content := &pb.Content{
		Func: ev.Func,
		Args: args,
	}
	data, err := content.Marshal()
	if err != nil {
		return nil, err
	}

	ibtppd := &pb.Payload{
		Encrypted: encrypt,
		Content:   data,
		Hash:      ev.Hash[:],
	}
	return ibtppd.Marshal()
}

func (c *Client) fillDirectInterchainEvent(ev *direct.BrokerDirectThrowInterchainEvent) (*direct.BrokerDirectThrowInterchainEvent, bool, error) {
	if ev.Func == "" {
		fun, args, encrypt, _, err := c.sessionDirect.GetOutMessage(pb.GenServicePair(ev.SrcFullID, ev.DstFullID), ev.Index)
		if err != nil {
			return nil, false, err
		}

		ev.Func = fun
		ev.Args = args
		emptyHash := common.Hash{}

		if bytes.Equal(ev.Hash[:], emptyHash[:]) {
			var data []byte
			data = append(data, []byte(fun)...)
			for _, arg := range args {
				data = append(data, arg...)
			}

			ev.Hash = common.BytesToHash(crypto.Keccak256(data))
		}

		return ev, encrypt, nil
	}

	return ev, false, nil
}

func (c *Client) fillDirectReceiptEvent(ev *direct.BrokerDirectThrowReceiptEvent) (*direct.BrokerDirectThrowReceiptEvent, bool, error) {
	if ev.Results == nil {
		results, typ, encrypt, multiStatus, err := c.sessionDirect.GetReceiptMessage(pb.GenServicePair(ev.SrcFullID, ev.DstFullID), ev.Index)
		if err != nil {
			return nil, false, err
		}
		ev.Results = results
		ev.Typ = typ
		ev.MultiStatus = multiStatus

		emptyHash := common.Hash{}
		if bytes.Equal(ev.Hash[:], emptyHash[:]) {
			var packed []byte
			for _, ele := range results {
				for _, result := range ele {
					packed = append(packed, result...)
				}
			}
			ev.Hash = common.BytesToHash(crypto.Keccak256(packed))
		}

		return ev, encrypt, nil
	}

	return ev, false, nil
}