593 lines
16 KiB
Go
593 lines
16 KiB
Go
package chains
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/wormhole-foundation/wormhole-explorer/common/domain"
|
|
sdk "github.com/wormhole-foundation/wormhole/sdk/vaa"
|
|
)
|
|
|
|
type apiWormchain struct {
|
|
osmosisUrl string
|
|
osmosisRateLimiter *time.Ticker
|
|
kujiraUrl string
|
|
kujiraRateLimiter *time.Ticker
|
|
evmosUrl string
|
|
evmosRateLimiter *time.Ticker
|
|
cosmoshubUrl string
|
|
cosmoshubRateLimiter *time.Ticker
|
|
p2pNetwork string
|
|
}
|
|
|
|
type wormchainTxDetail struct {
|
|
Jsonrpc string `json:"jsonrpc"`
|
|
ID int `json:"id"`
|
|
Result struct {
|
|
Hash string `json:"hash"`
|
|
Height string `json:"height"`
|
|
Index int `json:"index"`
|
|
TxResult struct {
|
|
Code int `json:"code"`
|
|
Data string `json:"data"`
|
|
Log string `json:"log"`
|
|
Info string `json:"info"`
|
|
GasWanted string `json:"gas_wanted"`
|
|
GasUsed string `json:"gas_used"`
|
|
Events []struct {
|
|
Type string `json:"type"`
|
|
Attributes []struct {
|
|
Key string `json:"key"`
|
|
Value string `json:"value"`
|
|
Index bool `json:"index"`
|
|
} `json:"attributes"`
|
|
} `json:"events"`
|
|
Codespace string `json:"codespace"`
|
|
} `json:"tx_result"`
|
|
Tx string `json:"tx"`
|
|
} `json:"result"`
|
|
}
|
|
|
|
type event struct {
|
|
Type string `json:"type"`
|
|
Attributes []struct {
|
|
Key string `json:"key"`
|
|
Value string `json:"value"`
|
|
} `json:"attributes"`
|
|
}
|
|
|
|
type packetData struct {
|
|
Sender string `json:"sender"`
|
|
Receiver string `json:"receiver"`
|
|
}
|
|
|
|
type logWrapper struct {
|
|
Events []event `json:"events"`
|
|
}
|
|
|
|
type worchainTx struct {
|
|
srcChannel, dstChannel, sender, receiver, timestamp, sequence string
|
|
}
|
|
|
|
func fetchWormchainDetail(ctx context.Context, baseUrl string, rateLimiter *time.Ticker, txHash string) (*worchainTx, error) {
|
|
uri := fmt.Sprintf("%s/tx?hash=%s", baseUrl, txHash)
|
|
body, err := httpGet(ctx, rateLimiter, uri)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var tx wormchainTxDetail
|
|
err = json.Unmarshal(body, &tx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var log []logWrapper
|
|
err = json.Unmarshal([]byte(tx.Result.TxResult.Log), &log)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var srcChannel, dstChannel, sender, receiver, timestamp, sequence string
|
|
for _, l := range log {
|
|
for _, e := range l.Events {
|
|
if e.Type == "recv_packet" {
|
|
for _, attr := range e.Attributes {
|
|
if attr.Key == "packet_src_channel" {
|
|
srcChannel = attr.Value
|
|
}
|
|
if attr.Key == "packet_dst_channel" {
|
|
dstChannel = attr.Value
|
|
}
|
|
if attr.Key == "packet_timeout_timestamp" {
|
|
timestamp = attr.Value
|
|
}
|
|
|
|
if attr.Key == "packet_sequence" {
|
|
sequence = attr.Value
|
|
}
|
|
|
|
if attr.Key == "packet_data" {
|
|
var pd packetData
|
|
err = json.Unmarshal([]byte(attr.Value), &pd)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
sender = pd.Sender
|
|
receiver = pd.Receiver
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return &worchainTx{
|
|
srcChannel: srcChannel,
|
|
dstChannel: dstChannel,
|
|
sender: sender,
|
|
receiver: receiver,
|
|
timestamp: timestamp,
|
|
sequence: sequence,
|
|
}, nil
|
|
|
|
}
|
|
|
|
type osmosisRequest struct {
|
|
Jsonrpc string `json:"jsonrpc"`
|
|
ID int `json:"id"`
|
|
Method string `json:"method"`
|
|
Params struct {
|
|
Query string `json:"query"`
|
|
Page string `json:"page"`
|
|
} `json:"params"`
|
|
}
|
|
|
|
type osmosisResponse struct {
|
|
Jsonrpc string `json:"jsonrpc"`
|
|
ID int `json:"id"`
|
|
Result struct {
|
|
Txs []struct {
|
|
Hash string `json:"hash"`
|
|
Height string `json:"height"`
|
|
Index int `json:"index"`
|
|
TxResult struct {
|
|
Code int `json:"code"`
|
|
Data string `json:"data"`
|
|
Log string `json:"log"`
|
|
Info string `json:"info"`
|
|
GasWanted string `json:"gas_wanted"`
|
|
GasUsed string `json:"gas_used"`
|
|
Events []struct {
|
|
Type string `json:"type"`
|
|
Attributes []struct {
|
|
Key string `json:"key"`
|
|
Value string `json:"value"`
|
|
Index bool `json:"index"`
|
|
} `json:"attributes"`
|
|
} `json:"events"`
|
|
Codespace string `json:"codespace"`
|
|
} `json:"tx_result"`
|
|
Tx string `json:"tx"`
|
|
} `json:"txs"`
|
|
TotalCount string `json:"total_count"`
|
|
} `json:"result"`
|
|
}
|
|
|
|
type osmosisTx struct {
|
|
txHash string
|
|
}
|
|
|
|
func fetchOsmosisDetail(ctx context.Context, baseUrl string, rateLimiter *time.Ticker, sequence, timestamp, srcChannel, dstChannel string) (*osmosisTx, error) {
|
|
queryTemplate := `send_packet.packet_sequence='%s' AND send_packet.packet_timeout_timestamp='%s' AND send_packet.packet_src_channel='%s' AND send_packet.packet_dst_channel='%s'`
|
|
query := fmt.Sprintf(queryTemplate, sequence, timestamp, srcChannel, dstChannel)
|
|
q := osmosisRequest{
|
|
Jsonrpc: "2.0",
|
|
ID: 1,
|
|
Method: "tx_search",
|
|
Params: struct {
|
|
Query string `json:"query"`
|
|
Page string `json:"page"`
|
|
}{
|
|
Query: query,
|
|
Page: "1",
|
|
},
|
|
}
|
|
|
|
response, err := httpPost(ctx, rateLimiter, baseUrl, q)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var oReponse osmosisResponse
|
|
err = json.Unmarshal(response, &oReponse)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if len(oReponse.Result.Txs) == 0 {
|
|
return nil, fmt.Errorf("can not found hash for sequence %s, timestamp %s, srcChannel %s, dstChannel %s", sequence, timestamp, srcChannel, dstChannel)
|
|
}
|
|
return &osmosisTx{txHash: strings.ToLower(oReponse.Result.Txs[0].Hash)}, nil
|
|
}
|
|
|
|
type evmosRequest struct {
|
|
Jsonrpc string `json:"jsonrpc"`
|
|
ID int `json:"id"`
|
|
Method string `json:"method"`
|
|
Params struct {
|
|
Query string `json:"query"`
|
|
Page string `json:"page"`
|
|
} `json:"params"`
|
|
}
|
|
|
|
type evmosResponse struct {
|
|
Jsonrpc string `json:"jsonrpc"`
|
|
ID int `json:"id"`
|
|
Result struct {
|
|
Txs []struct {
|
|
Hash string `json:"hash"`
|
|
Height string `json:"height"`
|
|
Index int `json:"index"`
|
|
TxResult struct {
|
|
Code int `json:"code"`
|
|
Data string `json:"data"`
|
|
Log string `json:"log"`
|
|
Info string `json:"info"`
|
|
GasWanted string `json:"gas_wanted"`
|
|
GasUsed string `json:"gas_used"`
|
|
Events []struct {
|
|
Type string `json:"type"`
|
|
Attributes []struct {
|
|
Key string `json:"key"`
|
|
Value string `json:"value"`
|
|
Index bool `json:"index"`
|
|
} `json:"attributes"`
|
|
} `json:"events"`
|
|
Codespace string `json:"codespace"`
|
|
} `json:"tx_result"`
|
|
Tx string `json:"tx"`
|
|
} `json:"txs"`
|
|
TotalCount string `json:"total_count"`
|
|
} `json:"result"`
|
|
}
|
|
|
|
type evmosTx struct {
|
|
txHash string
|
|
}
|
|
|
|
func fetchEvmosDetail(ctx context.Context, baseUrl string, rateLimiter *time.Ticker, sequence, timestamp, srcChannel, dstChannel string) (*evmosTx, error) {
|
|
queryTemplate := `send_packet.packet_sequence='%s' AND send_packet.packet_timeout_timestamp='%s' AND send_packet.packet_src_channel='%s' AND send_packet.packet_dst_channel='%s'`
|
|
query := fmt.Sprintf(queryTemplate, sequence, timestamp, srcChannel, dstChannel)
|
|
q := evmosRequest{
|
|
Jsonrpc: "2.0",
|
|
ID: 1,
|
|
Method: "tx_search",
|
|
Params: struct {
|
|
Query string `json:"query"`
|
|
Page string `json:"page"`
|
|
}{
|
|
Query: query,
|
|
Page: "1",
|
|
},
|
|
}
|
|
|
|
response, err := httpPost(ctx, rateLimiter, baseUrl, q)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var eReponse evmosResponse
|
|
err = json.Unmarshal(response, &eReponse)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if len(eReponse.Result.Txs) == 0 {
|
|
return nil, fmt.Errorf("can not found hash for sequence %s, timestamp %s, srcChannel %s, dstChannel %s", sequence, timestamp, srcChannel, dstChannel)
|
|
}
|
|
return &evmosTx{txHash: strings.ToLower(eReponse.Result.Txs[0].Hash)}, nil
|
|
}
|
|
|
|
type kujiraRequest struct {
|
|
Jsonrpc string `json:"jsonrpc"`
|
|
ID int `json:"id"`
|
|
Method string `json:"method"`
|
|
Params struct {
|
|
Query string `json:"query"`
|
|
Page string `json:"page"`
|
|
} `json:"params"`
|
|
}
|
|
|
|
type kujiraResponse struct {
|
|
Jsonrpc string `json:"jsonrpc"`
|
|
ID int `json:"id"`
|
|
Result struct {
|
|
Txs []struct {
|
|
Hash string `json:"hash"`
|
|
Height string `json:"height"`
|
|
Index int `json:"index"`
|
|
TxResult struct {
|
|
Code int `json:"code"`
|
|
Data string `json:"data"`
|
|
Log string `json:"log"`
|
|
Info string `json:"info"`
|
|
GasWanted string `json:"gas_wanted"`
|
|
GasUsed string `json:"gas_used"`
|
|
Events []struct {
|
|
Type string `json:"type"`
|
|
Attributes []struct {
|
|
Key string `json:"key"`
|
|
Value string `json:"value"`
|
|
Index bool `json:"index"`
|
|
} `json:"attributes"`
|
|
} `json:"events"`
|
|
Codespace string `json:"codespace"`
|
|
} `json:"tx_result"`
|
|
Tx string `json:"tx"`
|
|
} `json:"txs"`
|
|
TotalCount string `json:"total_count"`
|
|
} `json:"result"`
|
|
}
|
|
|
|
type kujiraTx struct {
|
|
txHash string
|
|
}
|
|
|
|
func fetchKujiraDetail(ctx context.Context, baseUrl string, rateLimiter *time.Ticker, sequence, timestamp, srcChannel, dstChannel string) (*kujiraTx, error) {
|
|
queryTemplate := `send_packet.packet_sequence='%s' AND send_packet.packet_timeout_timestamp='%s' AND send_packet.packet_src_channel='%s' AND send_packet.packet_dst_channel='%s'`
|
|
query := fmt.Sprintf(queryTemplate, sequence, timestamp, srcChannel, dstChannel)
|
|
q := kujiraRequest{
|
|
Jsonrpc: "2.0",
|
|
ID: 1,
|
|
Method: "tx_search",
|
|
Params: struct {
|
|
Query string `json:"query"`
|
|
Page string `json:"page"`
|
|
}{
|
|
Query: query,
|
|
Page: "1",
|
|
},
|
|
}
|
|
|
|
response, err := httpPost(ctx, rateLimiter, baseUrl, q)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var kReponse kujiraResponse
|
|
err = json.Unmarshal(response, &kReponse)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if len(kReponse.Result.Txs) == 0 {
|
|
return nil, fmt.Errorf("can not found hash for sequence %s, timestamp %s, srcChannel %s, dstChannel %s", sequence, timestamp, srcChannel, dstChannel)
|
|
}
|
|
return &kujiraTx{txHash: strings.ToLower(kReponse.Result.Txs[0].Hash)}, nil
|
|
}
|
|
|
|
type cosmoshubRequest struct {
|
|
Jsonrpc string `json:"jsonrpc"`
|
|
ID int `json:"id"`
|
|
Method string `json:"method"`
|
|
Params struct {
|
|
Query string `json:"query"`
|
|
Page string `json:"page"`
|
|
} `json:"params"`
|
|
}
|
|
|
|
type cosmoshubResponse struct {
|
|
Jsonrpc string `json:"jsonrpc"`
|
|
ID int `json:"id"`
|
|
Result struct {
|
|
Txs []struct {
|
|
Hash string `json:"hash"`
|
|
Height string `json:"height"`
|
|
Index int `json:"index"`
|
|
TxResult struct {
|
|
Code int `json:"code"`
|
|
Data string `json:"data"`
|
|
Log string `json:"log"`
|
|
Info string `json:"info"`
|
|
GasWanted string `json:"gas_wanted"`
|
|
GasUsed string `json:"gas_used"`
|
|
Events []struct {
|
|
Type string `json:"type"`
|
|
Attributes []struct {
|
|
Key string `json:"key"`
|
|
Value string `json:"value"`
|
|
Index bool `json:"index"`
|
|
} `json:"attributes"`
|
|
} `json:"events"`
|
|
Codespace string `json:"codespace"`
|
|
} `json:"tx_result"`
|
|
Tx string `json:"tx"`
|
|
} `json:"txs"`
|
|
TotalCount string `json:"total_count"`
|
|
} `json:"result"`
|
|
}
|
|
|
|
type cosmoshubTx struct {
|
|
txHash string
|
|
}
|
|
|
|
func fetchCosmoshubDetail(ctx context.Context, baseUrl string, rateLimiter *time.Ticker, sequence, timestamp, srcChannel, dstChannel string) (*cosmoshubTx, error) {
|
|
queryTemplate := `send_packet.packet_sequence='%s' AND send_packet.packet_timeout_timestamp='%s' AND send_packet.packet_src_channel='%s' AND send_packet.packet_dst_channel='%s'`
|
|
query := fmt.Sprintf(queryTemplate, sequence, timestamp, srcChannel, dstChannel)
|
|
q := osmosisRequest{
|
|
Jsonrpc: "2.0",
|
|
ID: 1,
|
|
Method: "tx_search",
|
|
Params: struct {
|
|
Query string `json:"query"`
|
|
Page string `json:"page"`
|
|
}{
|
|
Query: query,
|
|
Page: "1",
|
|
},
|
|
}
|
|
|
|
response, err := httpPost(ctx, rateLimiter, baseUrl, q)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var cReponse cosmoshubResponse
|
|
err = json.Unmarshal(response, &cReponse)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if len(cReponse.Result.Txs) == 0 {
|
|
return nil, fmt.Errorf("can not found hash for sequence %s, timestamp %s, srcChannel %s, dstChannel %s", sequence, timestamp, srcChannel, dstChannel)
|
|
}
|
|
return &cosmoshubTx{txHash: strings.ToLower(cReponse.Result.Txs[0].Hash)}, nil
|
|
}
|
|
|
|
type WorchainAttributeTxDetail struct {
|
|
OriginChainID sdk.ChainID `bson:"originChainId"`
|
|
OriginTxHash string `bson:"originTxHash"`
|
|
OriginAddress string `bson:"originAddress"`
|
|
}
|
|
|
|
func (a *apiWormchain) fetchWormchainTx(
|
|
ctx context.Context,
|
|
rateLimiter *time.Ticker,
|
|
baseUrl string,
|
|
txHash string,
|
|
) (*TxDetail, error) {
|
|
|
|
txHash = txHashLowerCaseWith0x(txHash)
|
|
|
|
wormchainTx, err := fetchWormchainDetail(ctx, baseUrl, rateLimiter, txHash)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Verify if this transaction is from osmosis by wormchain
|
|
if a.isOsmosisTx(wormchainTx) {
|
|
osmosisTx, err := fetchOsmosisDetail(ctx, a.osmosisUrl, a.osmosisRateLimiter, wormchainTx.sequence, wormchainTx.timestamp, wormchainTx.srcChannel, wormchainTx.dstChannel)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &TxDetail{
|
|
NativeTxHash: txHash,
|
|
From: wormchainTx.receiver,
|
|
Attribute: &AttributeTxDetail{
|
|
Type: "wormchain-gateway",
|
|
Value: &WorchainAttributeTxDetail{
|
|
OriginChainID: ChainIDOsmosis,
|
|
OriginTxHash: osmosisTx.txHash,
|
|
OriginAddress: wormchainTx.sender,
|
|
},
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
// Verify if this transaction is from kujira by wormchain
|
|
if a.isKujiraTx(wormchainTx) {
|
|
kujiraTx, err := fetchKujiraDetail(ctx, a.kujiraUrl, a.kujiraRateLimiter, wormchainTx.sequence, wormchainTx.timestamp, wormchainTx.srcChannel, wormchainTx.dstChannel)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &TxDetail{
|
|
NativeTxHash: txHash,
|
|
From: wormchainTx.receiver,
|
|
Attribute: &AttributeTxDetail{
|
|
Type: "wormchain-gateway",
|
|
Value: &WorchainAttributeTxDetail{
|
|
OriginChainID: ChainIDKujira,
|
|
OriginTxHash: kujiraTx.txHash,
|
|
OriginAddress: wormchainTx.sender,
|
|
},
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
// Verify if this transaction is from evmos by wormchain
|
|
if a.isEvmosTx(wormchainTx) {
|
|
evmosTx, err := fetchEvmosDetail(ctx, a.evmosUrl, a.evmosRateLimiter, wormchainTx.sequence, wormchainTx.timestamp, wormchainTx.srcChannel, wormchainTx.dstChannel)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &TxDetail{
|
|
NativeTxHash: txHash,
|
|
From: wormchainTx.receiver,
|
|
Attribute: &AttributeTxDetail{
|
|
Type: "wormchain-gateway",
|
|
Value: &WorchainAttributeTxDetail{
|
|
OriginChainID: ChainIDEvmos,
|
|
OriginTxHash: evmosTx.txHash,
|
|
OriginAddress: wormchainTx.sender,
|
|
},
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
if a.isCosmoshubTx(wormchainTx) {
|
|
cosmoshubTx, err := fetchCosmoshubDetail(ctx, a.evmosUrl, a.evmosRateLimiter, wormchainTx.sequence, wormchainTx.timestamp, wormchainTx.srcChannel, wormchainTx.dstChannel)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &TxDetail{
|
|
NativeTxHash: txHash,
|
|
From: wormchainTx.receiver,
|
|
Attribute: &AttributeTxDetail{
|
|
Type: "wormchain-gateway",
|
|
Value: &WorchainAttributeTxDetail{
|
|
OriginChainID: ChainIDCosmoshub,
|
|
OriginTxHash: cosmoshubTx.txHash,
|
|
OriginAddress: wormchainTx.sender,
|
|
},
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
// Verify if this transaction is from cosmoshub by wormchain
|
|
return &TxDetail{
|
|
NativeTxHash: txHash,
|
|
From: wormchainTx.receiver,
|
|
}, nil
|
|
}
|
|
|
|
func (a *apiWormchain) isOsmosisTx(tx *worchainTx) bool {
|
|
if a.p2pNetwork == domain.P2pMainNet {
|
|
return tx.srcChannel == "channel-2186" && tx.dstChannel == "channel-3"
|
|
}
|
|
if a.p2pNetwork == domain.P2pTestNet {
|
|
return tx.srcChannel == "channel-3086" && tx.dstChannel == "channel-5"
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (a *apiWormchain) isKujiraTx(tx *worchainTx) bool {
|
|
if a.p2pNetwork == domain.P2pMainNet {
|
|
return tx.srcChannel == "channel-113" && tx.dstChannel == "channel-9"
|
|
}
|
|
// Pending get channels for testnet
|
|
// if a.p2pNetwork == domain.P2pTestNet {
|
|
// return tx.srcChannel == "" && tx.dstChannel == ""
|
|
// }
|
|
return false
|
|
}
|
|
|
|
func (a *apiWormchain) isEvmosTx(tx *worchainTx) bool {
|
|
if a.p2pNetwork == domain.P2pMainNet {
|
|
return tx.srcChannel == "channel-94" && tx.dstChannel == "channel-5"
|
|
}
|
|
// Pending get channels for testnet
|
|
// if a.p2pNetwork == domain.P2pTestNet {
|
|
// return tx.srcChannel == "" && tx.dstChannel == ""
|
|
// }
|
|
return false
|
|
}
|
|
|
|
func (a *apiWormchain) isCosmoshubTx(tx *worchainTx) bool {
|
|
if a.p2pNetwork == domain.P2pTestNet {
|
|
return tx.srcChannel == "channel-3086" && tx.dstChannel == "channel-5"
|
|
}
|
|
return false
|
|
}
|