Skip to content

Commit

Permalink
Merge branch 'main' into tofnd-rotation
Browse files Browse the repository at this point in the history
  • Loading branch information
@milapsheth
milapsheth committed Apr 6, 2022
2 parents 5f85cd3 + 1973c49 commit 40c14d8
Show file tree
Hide file tree
Showing 4 changed files with 137 additions and 33 deletions.
2 changes: 1 addition & 1 deletion contract-artifacts/version-config.json
View file
Original file line number Diff line number Diff line change
@@ -1,3 +1,3 @@
{
"gateway": "v3.0.0"
"gateway": "v3.1.0"
}
9 changes: 8 additions & 1 deletion x/evm/abci.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -149,7 +149,8 @@ func handleContractCallWithToken(ctx sdk.Context, event types.Event, bk types.Ba
}

asset := token.GetAsset()
if token := destinationCk.GetERC20TokenByAsset(ctx, asset); !token.Is(types.Confirmed) {
destinationToken := destinationCk.GetERC20TokenByAsset(ctx, asset)
if !destinationToken.Is(types.Confirmed) {
bk.Logger(ctx).Info(fmt.Sprintf("%s token with asset %s is not confirmed yet", e.DestinationChain, asset))
return false
}
Expand Down Expand Up @@ -190,6 +191,7 @@ func handleContractCallWithToken(ctx sdk.Context, event types.Event, bk types.Ba
event.Index,
*e,
amount,
destinationToken.GetDetails().Symbol,
)
if err != nil {
panic(err)
Expand Down Expand Up @@ -228,6 +230,11 @@ func handleConfirmedEvents(ctx sdk.Context, bk types.BaseKeeper, n types.Nexus,
continue
}

// skip if secondary key rotation is in progress
if _, nextSecondaryKeyAssigned := s.GetNextKeyID(ctx, chain, tss.SecondaryKey); nextSecondaryKeyAssigned {
continue
}

queue := ck.GetConfirmedEventQueue(ctx)
// skip if confirmed event queue is empty
if queue.IsEmpty() {
Expand Down
145 changes: 120 additions & 25 deletions x/evm/types/types.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -539,20 +539,20 @@ func CreateApproveContractCallCommand(
chainID sdk.Int,
keyID tss.KeyID,
sourceChain string,
txID Hash,
index uint64,
sourceTxID Hash,
sourceEventIndex uint64,
event EventContractCall,
) (Command, error) {
params, err := createApproveContractCallParams(sourceChain, event)
params, err := createApproveContractCallParams(sourceChain, sourceTxID, sourceEventIndex, event)
if err != nil {
return Command{}, err
}

eventIndexBz := make([]byte, 8)
binary.LittleEndian.PutUint64(eventIndexBz, index)
sourceEventIndexBz := make([]byte, 8)
binary.LittleEndian.PutUint64(sourceEventIndexBz, sourceEventIndex)

return Command{
ID: NewCommandID(append(txID.Bytes(), eventIndexBz...), chainID),
ID: NewCommandID(append(sourceTxID.Bytes(), sourceEventIndexBz...), chainID),
Command: AxelarGatewayCommandApproveContractCall,
Params: params,
KeyID: keyID,
Expand All @@ -565,21 +565,22 @@ func CreateApproveContractCallWithMintCommand(
chainID sdk.Int,
keyID tss.KeyID,
sourceChain string,
txID Hash,
index uint64,
sourceTxID Hash,
sourceEventIndex uint64,
event EventContractCallWithToken,
amount sdk.Uint,
symbol string,
) (Command, error) {
params, err := createApproveContractCallWithMintParams(sourceChain, event, amount)
params, err := createApproveContractCallWithMintParams(sourceChain, sourceTxID, sourceEventIndex, event, amount, symbol)
if err != nil {
return Command{}, err
}

eventIndexBz := make([]byte, 8)
binary.LittleEndian.PutUint64(eventIndexBz, index)
sourceEventIndexBz := make([]byte, 8)
binary.LittleEndian.PutUint64(sourceEventIndexBz, sourceEventIndex)

return Command{
ID: NewCommandID(append(txID.Bytes(), eventIndexBz...), chainID),
ID: NewCommandID(append(sourceTxID.Bytes(), sourceEventIndexBz...), chainID),
Command: AxelarGatewayCommandApproveContractCallWithMint,
Params: params,
KeyID: keyID,
Expand All @@ -588,25 +589,25 @@ func CreateApproveContractCallWithMintCommand(
}

// decodeApproveContractCallWithMintParams unpacks the parameters of a approve contract call with mint command
func decodeApproveContractCallWithMintParams(bz []byte) (string, string, common.Address, common.Hash, string, *big.Int, error) {
func decodeApproveContractCallWithMintParams(bz []byte) (string, string, common.Address, common.Hash, string, *big.Int, common.Hash, *big.Int, error) {
stringType, err := abi.NewType("string", "string", nil)
if err != nil {
return "", "", common.Address{}, common.Hash{}, "", nil, err
return "", "", common.Address{}, common.Hash{}, "", nil, common.Hash{}, nil, err
}

addressType, err := abi.NewType("address", "address", nil)
if err != nil {
return "", "", common.Address{}, common.Hash{}, "", nil, err
return "", "", common.Address{}, common.Hash{}, "", nil, common.Hash{}, nil, err
}

bytes32Type, err := abi.NewType("bytes32", "bytes32", nil)
if err != nil {
return "", "", common.Address{}, common.Hash{}, "", nil, err
return "", "", common.Address{}, common.Hash{}, "", nil, common.Hash{}, nil, err
}

uint256Type, err := abi.NewType("uint256", "uint256", nil)
if err != nil {
return "", "", common.Address{}, common.Hash{}, "", nil, err
return "", "", common.Address{}, common.Hash{}, "", nil, common.Hash{}, nil, err
}

arguments := abi.Arguments{
Expand All @@ -616,18 +617,80 @@ func decodeApproveContractCallWithMintParams(bz []byte) (string, string, common.
{Type: bytes32Type},
{Type: stringType},
{Type: uint256Type},
{Type: bytes32Type},
{Type: uint256Type},
}
params, err := StrictDecode(arguments, bz)
if err != nil {
return "", "", common.Address{}, common.Hash{}, "", nil, common.Hash{}, nil, err
}

payloadHash := params[3].([common.HashLength]byte)
sourceTxID := params[6].([common.HashLength]byte)

return params[0].(string),
params[1].(string),
params[2].(common.Address),
common.BytesToHash(payloadHash[:]),
params[4].(string),
params[5].(*big.Int),
common.BytesToHash(sourceTxID[:]),
params[7].(*big.Int),
nil
}

// decodeApproveContractCallParams unpacks the parameters of a approve contract call command
func decodeApproveContractCallParams(bz []byte) (string, string, common.Address, common.Hash, common.Hash, *big.Int, error) {
stringType, err := abi.NewType("string", "string", nil)
if err != nil {
return "", "", common.Address{}, common.Hash{}, common.Hash{}, nil, err
}

addressType, err := abi.NewType("address", "address", nil)
if err != nil {
return "", "", common.Address{}, common.Hash{}, common.Hash{}, nil, err
}

bytes32Type, err := abi.NewType("bytes32", "bytes32", nil)
if err != nil {
return "", "", common.Address{}, common.Hash{}, common.Hash{}, nil, err
}

uint256Type, err := abi.NewType("uint256", "uint256", nil)
if err != nil {
return "", "", common.Address{}, common.Hash{}, common.Hash{}, nil, err
}

arguments := abi.Arguments{
{Type: stringType},
{Type: stringType},
{Type: addressType},
{Type: bytes32Type},
{Type: bytes32Type},
{Type: uint256Type},
}
params, err := StrictDecode(arguments, bz)
if err != nil {
return "", "", common.Address{}, common.Hash{}, "", nil, err
return "", "", common.Address{}, common.Hash{}, common.Hash{}, nil, err
}

payloadHash := params[3].([32]byte)
payloadHash := params[3].([common.HashLength]byte)
sourceTxID := params[4].([common.HashLength]byte)

return params[0].(string), params[1].(string), params[2].(common.Address), common.BytesToHash(payloadHash[:]), params[4].(string), params[5].(*big.Int), nil
return params[0].(string),
params[1].(string),
params[2].(common.Address),
common.BytesToHash(payloadHash[:]),
common.BytesToHash(sourceTxID[:]),
params[5].(*big.Int),
nil
}

func createApproveContractCallParams(sourceChain string, event EventContractCall) ([]byte, error) {
func createApproveContractCallParams(
sourceChain string,
sourceTxID Hash,
sourceEventIndex uint64,
event EventContractCall) ([]byte, error) {
stringType, err := abi.NewType("string", "string", nil)
if err != nil {
return nil, err
Expand All @@ -643,18 +706,27 @@ func createApproveContractCallParams(sourceChain string, event EventContractCall
return nil, err
}

uint256Type, err := abi.NewType("uint256", "uint256", nil)
if err != nil {
return nil, err
}

arguments := abi.Arguments{
{Type: stringType},
{Type: stringType},
{Type: addressType},
{Type: bytes32Type},
{Type: bytes32Type},
{Type: uint256Type},
}

result, err := arguments.Pack(
sourceChain,
event.Sender.Hex(),
common.HexToAddress(event.ContractAddress),
common.Hash(event.PayloadHash),
common.Hash(sourceTxID),
new(big.Int).SetUint64(sourceEventIndex),
)
if err != nil {
return nil, err
Expand All @@ -663,7 +735,13 @@ func createApproveContractCallParams(sourceChain string, event EventContractCall
return result, nil
}

func createApproveContractCallWithMintParams(sourceChain string, event EventContractCallWithToken, amount sdk.Uint) ([]byte, error) {
func createApproveContractCallWithMintParams(
sourceChain string,
sourceTxID Hash,
sourceEventIndex uint64,
event EventContractCallWithToken,
amount sdk.Uint,
symbol string) ([]byte, error) {
stringType, err := abi.NewType("string", "string", nil)
if err != nil {
return nil, err
Expand Down Expand Up @@ -691,14 +769,18 @@ func createApproveContractCallWithMintParams(sourceChain string, event EventCont
{Type: bytes32Type},
{Type: stringType},
{Type: uint256Type},
{Type: bytes32Type},
{Type: uint256Type},
}
result, err := arguments.Pack(
sourceChain,
event.Sender.Hex(),
common.HexToAddress(event.ContractAddress),
common.Hash(event.PayloadHash),
event.Symbol,
symbol,
amount.BigInt(),
common.Hash(sourceTxID),
new(big.Int).SetUint64(sourceEventIndex),
)
if err != nil {
return nil, err
Expand Down Expand Up @@ -1562,8 +1644,7 @@ func (c Command) DecodeParams() (map[string]string, error) {

switch c.Command {
case AxelarGatewayCommandApproveContractCallWithMint:
sourceChain, sourceAddress, contractAddress, payloadHash, symbol, amount, err := decodeApproveContractCallWithMintParams(c.Params)

sourceChain, sourceAddress, contractAddress, payloadHash, symbol, amount, sourceTxID, sourceEventIndex, err := decodeApproveContractCallWithMintParams(c.Params)
if err != nil {
return nil, err
}
Expand All @@ -1574,6 +1655,20 @@ func (c Command) DecodeParams() (map[string]string, error) {
params["payloadHash"] = payloadHash.Hex()
params["symbol"] = symbol
params["amount"] = amount.String()
params["sourceTxHash"] = sourceTxID.Hex()
params["sourceEventIndex"] = sourceEventIndex.String()
case AxelarGatewayCommandApproveContractCall:
sourceChain, sourceAddress, contractAddress, payloadHash, sourceTxID, sourceEventIndex, err := decodeApproveContractCallParams(c.Params)
if err != nil {
return nil, err
}

params["sourceChain"] = sourceChain
params["sourceAddress"] = sourceAddress
params["contractAddress"] = contractAddress.Hex()
params["payloadHash"] = payloadHash.Hex()
params["sourceTxHash"] = sourceTxID.Hex()
params["sourceEventIndex"] = sourceEventIndex.String()
case AxelarGatewayCommandDeployToken:
name, symbol, decs, cap, tokenAddress, err := decodeDeployTokenParams(c.Params)
if err != nil {
Expand Down
14 changes: 8 additions & 6 deletions x/evm/types/types_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -22,8 +22,8 @@ func TestCreateApproveContractCallWithMintCommand(t *testing.T) {
chainID := sdk.NewInt(1)
keyID := tssTestUtils.RandKeyID()
sourceChain := "polygon"
txID := Hash(common.BytesToHash(rand.Bytes(common.HashLength)))
index := uint64(rand.I64Between(1, 100))
txID := Hash(common.HexToHash("0x5bb45dc24ddd6b90fa37f26eecfcf203328427c3226db29d1c01051b965ca93b"))
index := uint64(99)
sourceAddress := "0x68B93045fe7D8794a7cAF327e7f855CD6Cd03BB8"
contractAddress := common.HexToAddress("0x956dA338C1518a7FB213042b70c60c021aeBd554")
payloadHash := common.HexToHash("0x7c6498469c4e2d466b6fc9af3c910587f6c0bdade714a16ab279a08a759a5c14")
Expand All @@ -33,10 +33,10 @@ func TestCreateApproveContractCallWithMintCommand(t *testing.T) {
Sender: Address(common.HexToAddress(sourceAddress)),
ContractAddress: contractAddress.Hex(),
PayloadHash: Hash(payloadHash),
Symbol: symbol,
Symbol: rand.NormalizedStrBetween(1, 5),
}

expectedParams := "00000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000100000000000000000000000000956da338c1518a7fb213042b70c60c021aebd5547c6498469c4e2d466b6fc9af3c910587f6c0bdade714a16ab279a08a759a5c1400000000000000000000000000000000000000000000000000000000000001600000000000000000000000000000000000000000000000000000000000004e200000000000000000000000000000000000000000000000000000000000000007706f6c79676f6e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002a3078363842393330343566653744383739346137634146333237653766383535434436436430334242380000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000057465737441000000000000000000000000000000000000000000000000000000"
expectedParams := "00000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000140000000000000000000000000956da338c1518a7fb213042b70c60c021aebd5547c6498469c4e2d466b6fc9af3c910587f6c0bdade714a16ab279a08a759a5c1400000000000000000000000000000000000000000000000000000000000001a00000000000000000000000000000000000000000000000000000000000004e205bb45dc24ddd6b90fa37f26eecfcf203328427c3226db29d1c01051b965ca93b00000000000000000000000000000000000000000000000000000000000000630000000000000000000000000000000000000000000000000000000000000007706f6c79676f6e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002a3078363842393330343566653744383739346137634146333237653766383535434436436430334242380000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000057465737441000000000000000000000000000000000000000000000000000000"
actual, err := CreateApproveContractCallWithMintCommand(
chainID,
keyID,
Expand All @@ -45,20 +45,22 @@ func TestCreateApproveContractCallWithMintCommand(t *testing.T) {
index,
event,
amount,
symbol,
)

assert.NoError(t, err)
assert.Equal(t, expectedParams, hex.EncodeToString(actual.Params))

actualSourceChain, actualSourceAddress, actualContractAddress, actualPayloadHash, actualSymbol, actualAmount, err := decodeApproveContractCallWithMintParams(actual.Params)
actualSourceChain, actualSourceAddress, actualContractAddress, actualPayloadHash, actualSymbol, actualAmount, actualSourceTxID, actualSourceEventIndex, err := decodeApproveContractCallWithMintParams(actual.Params)
assert.NoError(t, err)
assert.Equal(t, sourceChain, actualSourceChain)
assert.Equal(t, sourceAddress, actualSourceAddress)
assert.Equal(t, contractAddress, actualContractAddress)
assert.Equal(t, payloadHash, actualPayloadHash)
assert.Equal(t, symbol, actualSymbol)
assert.Equal(t, amount.BigInt(), actualAmount)

assert.Equal(t, txID, Hash(actualSourceTxID))
assert.Equal(t, index, actualSourceEventIndex.Uint64())
}

func TestNewCommandBatchMetadata(t *testing.T) {
Expand Down

0 comments on commit 40c14d8

Please sign in to comment.