diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 3720c186..b694fdb2 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -144,4 +144,4 @@ jobs: - name: Run tests run: | set -euo pipefail - go test -json -v $(go list ./... | grep -Ev '/blockchain|/badgerTrie|/consensus|/transport|/testutils') 2>&1 | tee /tmp/gotest.log | gotestfmt + go test -json -v $(go list ./... | grep -Ev '/badgerTrie|/consensus|/transport|/testutils') 2>&1 | tee /tmp/gotest.log | gotestfmt diff --git a/blockchain/cancellation_test.go b/blockchain/cancellation_test.go index ce5fed5e..def61d82 100644 --- a/blockchain/cancellation_test.go +++ b/blockchain/cancellation_test.go @@ -32,7 +32,7 @@ func TestSleepWithContextComplete(t *testing.T) { assert.True(t, completed) } -func TestSleepWithContextInterupted(t *testing.T) { +func TestSleepWithContextInterrupted(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) completed := false @@ -48,10 +48,51 @@ func TestSleepWithContextInterupted(t *testing.T) { } wg.Done() }() - cancel() wg.Wait() assert.False(t, completed) } + +func TestSlowReturn(t *testing.T) { + ctx, _ := context.WithCancel(context.Background()) + + type args struct { + ctx context.Context + delay time.Duration + value bool + } + tests := []struct { + name string + args args + want bool + }{ + { + name: "Test slow Return success", + args: args{ + ctx: ctx, + delay: 5000 * time.Millisecond, + value: true, + }, + want: true, + }, + { + name: "Test slow Return quicker delay", + args: args{ + ctx: ctx, + delay: 500 * time.Millisecond, + value: false, + }, + want: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + start := time.Now() + assert.Equalf(t, tt.want, blockchain.SlowReturn(tt.args.ctx, tt.args.delay, tt.args.value), "SlowReturn(%v, %v, %v)", tt.args.ctx, tt.args.delay, tt.args.value) + elapsed := time.Since(start) + assert.GreaterOrEqual(t, elapsed, tt.args.delay, "Delay time has not been respected") + }) + } +} diff --git a/blockchain/deposit_test.go b/blockchain/deposit_test.go deleted file mode 100644 index 5d0f8db5..00000000 --- a/blockchain/deposit_test.go +++ /dev/null @@ -1,84 +0,0 @@ -package blockchain_test - -/* -import ( - "context" - "math/big" - "testing" - - "github.com/MadBase/MadNet/blockchain/interfaces" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/suite" -) - -type DepositTestSuite struct { - suite.Suite - eth interfaces.Ethereum - callOpts *bind.CallOpts - txnOpts *bind.TransactOpts -} - -func (s *DepositTestSuite) SetupTest() { - t := s.T() - eth, err := setupEthereum(t, 4) - assert.Nil(t, err) - c := eth.Contracts() - - s.eth = eth - ctx := context.TODO() - - testAcct := eth.GetDefaultAccount() - - err = eth.UnlockAccount(testAcct) - if err != nil { - panic(err) - } - - bal, _ := eth.GetBalance(testAcct.Address) - t.Logf("ether balance of %v is %v", testAcct.Address.Hex(), bal) - - // Deployer starts with tokens, so has to transfer - txnOpts, _ := eth.GetTransactionOpts(ctx, testAcct) - _, err = c.UtilityToken().Transfer(txnOpts, testAcct.Address, InitialAllowance) - assert.Nil(t, err) - eth.Commit() - - assert.Nilf(t, err, "Initial transfer of %v to %v failed: %v", InitialAllowance, testAcct.Address.Hex(), err) - if err == nil { - t.Logf("Initial transfer of %v tokens to %v succeeded.", InitialAllowance, testAcct.Address.Hex()) - } - - s.callOpts = eth.GetCallOpts(ctx, eth.GetDefaultAccount()) - s.txnOpts, err = eth.GetTransactionOpts(ctx, eth.GetDefaultAccount()) - assert.Nil(t, err, "Failed to build txnOpts") -} - -func (s *DepositTestSuite) TestDepositEvent() { - t := s.T() - eth := s.eth - c := eth.Contracts() - - bal, _ := c.UtilityToken().BalanceOf(s.callOpts, eth.GetDefaultAccount().Address) - t.Logf("utility token balance of %v is %v", eth.GetDefaultAccount().Address.Hex(), bal) - - bal, _ = eth.GetBalance(eth.GetDefaultAccount().Address) - t.Logf("ether balance of %v is %v", eth.GetDefaultAccount().Address.Hex(), bal) - - // Approve deposit contract to withdrawh.GetDefaultAccount()) - txn, err := c.UtilityToken().Approve(s.txnOpts, c.DepositAddress(), big.NewInt(10000)) - assert.Nilf(t, err, "Approve failed by %v to %v", eth.GetDefaultAccount().Address.Hex(), c.DepositAddress().Hex()) - assert.NotNil(t, txn, "Approve failed: transaction is nil") - s.eth.Commit() - - // Tell deposit contract to withdraw - txn, err = c.Deposit().Deposit(s.txnOpts, big.NewInt(1000)) - assert.Nil(t, err, "Deposit failed") - assert.NotNilf(t, txn, "Deposit failed: transaction is nil") - s.eth.Commit() -} - -func TestDepositTestSuite(t *testing.T) { - suite.Run(t, new(DepositTestSuite)) -} -*/ diff --git a/blockchain/ethdkg_test.go b/blockchain/ethdkg_test.go deleted file mode 100644 index d82e4ba4..00000000 --- a/blockchain/ethdkg_test.go +++ /dev/null @@ -1,10 +0,0 @@ -package blockchain_test - -import ( - "testing" -) - -func TestAccuse(t *testing.T) { - // eth, commit, err := setupEthereum() - -} diff --git a/blockchain/ethereum.go b/blockchain/ethereum.go index 0d96a5a3..87668e1e 100644 --- a/blockchain/ethereum.go +++ b/blockchain/ethereum.go @@ -308,7 +308,7 @@ func NewEthereumEndpoint( defer cancel() rpcClient, rpcErr := rpc.DialContext(ctx, endpoint) if rpcErr != nil { - logger.Errorf("Error in NewEthereumEndpoint at rpc.DialContext: %v", err) + logger.Errorf("Error in NewEthereumEndpoint at rpc.DialContext: %v", rpcErr) return nil, rpcErr } ethClient := ethclient.NewClient(rpcClient) diff --git a/blockchain/ethereum_test.go b/blockchain/ethereum_test.go index 6a3b33c3..49fb78f8 100644 --- a/blockchain/ethereum_test.go +++ b/blockchain/ethereum_test.go @@ -2,8 +2,12 @@ package blockchain_test import ( "context" + "errors" + "fmt" + "io/fs" "math" "math/big" + "net" "testing" "time" @@ -92,3 +96,112 @@ func TestHardhatNode(t *testing.T) { t.Logf("done testing") } + +func TestNewEthereumEndpoint(t *testing.T) { + + eth := setupEthereum(t, 4) + defer eth.Close() + + type args struct { + endpoint string + pathKeystore string + pathPasscodes string + defaultAccount string + timeout time.Duration + retryCount int + retryDelay time.Duration + finalityDelay int + txFeePercentageToIncrease int + txMaxFeeThresholdInGwei uint64 + txCheckFrequency time.Duration + txTimeoutForReplacement time.Duration + } + tests := []struct { + name string + args args + want bool + wantErr assert.ErrorAssertionFunc + }{ + + { + name: "Create new ethereum endpoint failing with passcode file not found", + args: args{"", "", "", "", 0, 0, 0, 0, 0, 0, 0, 0}, + want: false, + wantErr: func(t assert.TestingT, err error, i ...interface{}) bool { + _, ok := err.(*fs.PathError) + if !ok { + t.Errorf("Failing test with an unexpected error") + } + return ok + }, + }, + { + name: "Create new ethereum endpoint failing with specified account not found", + args: args{"", "", "../assets/test/passcodes.txt", "", 0, 0, 0, 0, 0, 0, 0, 0}, + want: false, + wantErr: func(t assert.TestingT, err error, i ...interface{}) bool { + if !errors.Is(err, blockchain.ErrAccountNotFound) { + t.Errorf("Failing test with an unexpected error") + } + return true + }, + }, + { + name: "Create new ethereum endpoint failing on Dial Context", + args: args{ + eth.GetEndpoint(), + "../assets/test/keys", + "../assets/test/passcodes.txt", + eth.GetDefaultAccount().Address.String(), + eth.Timeout(), + eth.RetryCount(), + eth.RetryDelay(), + int(eth.GetFinalityDelay()), + eth.GetTxFeePercentageToIncrease(), + eth.GetTxMaxFeeThresholdInGwei(), + eth.GetTxCheckFrequency(), + eth.GetTxTimeoutForReplacement(), + }, + want: false, + wantErr: func(t assert.TestingT, err error, i ...interface{}) bool { + _, ok := err.(*net.OpError) + if !ok { + t.Errorf("Failing test with an unexpected error") + } + return ok + }, + }, + { + name: "Create new ethereum endpoint returning EthereumDetails", + args: args{ + "http://localhost:8545", + "../assets/test/keys", + "../assets/test/passcodes.txt", + eth.GetDefaultAccount().Address.String(), + eth.Timeout(), + eth.RetryCount(), + eth.RetryDelay(), + int(eth.GetFinalityDelay()), + eth.GetTxFeePercentageToIncrease(), + eth.GetTxMaxFeeThresholdInGwei(), + eth.GetTxCheckFrequency(), + eth.GetTxTimeoutForReplacement(), + }, + want: true, + wantErr: func(t assert.TestingT, err error, i ...interface{}) bool { + return true + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := blockchain.NewEthereumEndpoint(tt.args.endpoint, tt.args.pathKeystore, tt.args.pathPasscodes, tt.args.defaultAccount, tt.args.timeout, tt.args.retryCount, tt.args.retryDelay, tt.args.finalityDelay, tt.args.txFeePercentageToIncrease, tt.args.txMaxFeeThresholdInGwei, tt.args.txCheckFrequency, tt.args.txTimeoutForReplacement) + if !tt.wantErr(t, err, fmt.Sprintf("NewEthereumEndpoint(%v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v)", tt.args.endpoint, tt.args.pathKeystore, tt.args.pathPasscodes, tt.args.defaultAccount, tt.args.timeout, tt.args.retryCount, tt.args.retryDelay, tt.args.finalityDelay, tt.args.txFeePercentageToIncrease, tt.args.txMaxFeeThresholdInGwei, tt.args.txCheckFrequency, tt.args.txTimeoutForReplacement)) { + return + } + if tt.want { + assert.NotNilf(t, got, "Ethereum Details must not be nil") + } + }) + } +} diff --git a/blockchain/objects/dkg_state_test.go b/blockchain/objects/dkg_state_test.go index a3d72c7c..0c871a01 100644 --- a/blockchain/objects/dkg_state_test.go +++ b/blockchain/objects/dkg_state_test.go @@ -2,10 +2,15 @@ package objects_test import ( "bytes" + "encoding/json" "math/big" "testing" + "github.com/MadBase/MadNet/blockchain/dkg/math" "github.com/MadBase/MadNet/blockchain/objects" + "github.com/ethereum/go-ethereum/accounts" + "github.com/ethereum/go-ethereum/common" + "github.com/stretchr/testify/assert" ) func TestParticipantCopy(t *testing.T) { @@ -59,3 +64,116 @@ func TestParticipantListExtractIndices(t *testing.T) { } } } + +func TestMarshalAndUnmarshalBigInt(t *testing.T) { + + // generate transport keys + priv, pub, err := math.GenerateKeys() + assert.Nil(t, err) + + // marshal privkey + rawPrivData, err := json.Marshal(priv) + assert.Nil(t, err) + rawPubData, err := json.Marshal(pub) + assert.Nil(t, err) + + priv2 := &big.Int{} + pub2 := [2]*big.Int{} + + err = json.Unmarshal(rawPrivData, priv2) + assert.Nil(t, err) + err = json.Unmarshal(rawPubData, &pub2) + assert.Nil(t, err) + + assert.Equal(t, priv, priv2) + assert.Equal(t, pub, pub2) +} + +func TestMarshalAndUnmarshalAccount(t *testing.T) { + addr := common.Address{} + addr.SetBytes([]byte("546F99F244b7B58B855330AE0E2BC1b30b41302F")) + + // create a DkgState obj + acct := accounts.Account{ + Address: addr, + URL: accounts.URL{ + Scheme: "http", + Path: "", + }, + } + + // marshal acct + rawData, err := json.Marshal(acct) + assert.Nil(t, err) + + acct2 := &accounts.Account{} + + err = json.Unmarshal(rawData, acct2) + assert.Nil(t, err) + + assert.Equal(t, acct, *acct2) +} + +func TestMarshalAndUnmarshalParticipant(t *testing.T) { + addr := common.Address{} + addr.SetBytes([]byte("546F99F244b7B58B855330AE0E2BC1b30b41302F")) + + // generate transport keys + _, pub, err := math.GenerateKeys() + assert.Nil(t, err) + + // create a Participant obj + participant := objects.Participant{ + Address: addr, + Index: 1, + PublicKey: pub, + Nonce: 1, + Phase: 0, + } + + // marshal + rawData, err := json.Marshal(participant) + assert.Nil(t, err) + + t.Logf("rawData: %s", rawData) + + participant2 := &objects.Participant{} + + err = json.Unmarshal(rawData, participant2) + assert.Nil(t, err) + assert.Equal(t, participant.PublicKey, participant2.PublicKey) + +} + +func TestMarshalAndUnmarshalDkgState(t *testing.T) { + addr := common.Address{} + addr.SetBytes([]byte("546F99F244b7B58B855330AE0E2BC1b30b41302F")) + + // create a DkgState obj + state := objects.NewDkgState(accounts.Account{ + Address: addr, + URL: accounts.URL{ + Scheme: "file", + Path: "", + }, + }) + + // generate transport keys + priv, pub, err := math.GenerateKeys() + assert.Nil(t, err) + state.TransportPrivateKey = priv + state.TransportPublicKey = pub + + // marshal + rawData, err := json.Marshal(state) + assert.Nil(t, err) + + t.Logf("rawData: %s", rawData) + + state2 := &objects.DkgState{} + + err = json.Unmarshal(rawData, state2) + assert.Nil(t, err) + assert.Equal(t, state.TransportPrivateKey, state2.TransportPrivateKey) + assert.Equal(t, state.TransportPublicKey, state2.TransportPublicKey) +} diff --git a/blockchain/staking_test.go b/blockchain/staking_test.go deleted file mode 100644 index e4621d73..00000000 --- a/blockchain/staking_test.go +++ /dev/null @@ -1,162 +0,0 @@ -package blockchain_test - -/* -import ( - "context" - "math/big" - "testing" - - "github.com/MadBase/MadNet/blockchain/interfaces" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/suite" -) - -type StakingTestSuite struct { - suite.Suite - eth interfaces.Ethereum - callOpts *bind.CallOpts - txnOpts *bind.TransactOpts -} - -var InitialAllowance = big.NewInt(1000000000000000000) - -func (s *StakingTestSuite) SetupTest() { - t := s.T() - var err error - s.eth, err = setupEthereum(t, 4) - assert.Nil(t, err) - eth := s.eth - c := s.eth.Contracts() - ctx := context.TODO() - - acct := eth.GetDefaultAccount() - txnOpts, _ := eth.GetTransactionOpts(ctx, eth.GetDefaultAccount()) - _, err = c.StakingToken().Transfer(txnOpts, acct.Address, InitialAllowance) - assert.Nilf(t, err, "Initial transfer of %v to %v failed: %v", InitialAllowance, acct.Address.Hex(), err) - - // Tester needs to approve those for Staking - s.txnOpts, err = eth.GetTransactionOpts(ctx, acct) - assert.Nil(t, err, "Can't build txnOpts") - - _, err = c.StakingToken().Approve(s.txnOpts, c.ValidatorsAddress(), InitialAllowance) - assert.Nilf(t, err, "Initial approval of %v to %v failed: %v", InitialAllowance, c.ValidatorsAddress().Hex(), err) - s.eth.Commit() - - s.callOpts = eth.GetCallOpts(ctx, acct) - - // Tell staking we're in the 1st epoch - _, err = c.Snapshots().SetEpoch(txnOpts, big.NewInt(1)) // Must be deploy account - assert.Nil(t, err) - s.eth.Commit() -} - -func (s *StakingTestSuite) TestStakeEvent() { - t := s.T() - - eth := s.eth - c := eth.Contracts() - - balance, err := c.Staking().BalanceStake(s.callOpts) - assert.Truef(t, err == nil, "Failed to check balance:%v", err) - assert.Truef(t, big.NewInt(10).Cmp(balance) > 0, "Allowance %v insufficient", balance) - - stakeAmount := big.NewInt(1000000) - txn, err := c.Staking().LockStake(s.txnOpts, stakeAmount) - assert.Nil(t, err, "Failed to post stake") - assert.NotNil(t, txn, "Staking transaction is nil") - s.eth.Commit() - - rcpt, err := eth.Queue().QueueAndWait(context.Background(), txn) - assert.True(t, err == nil, "Couldn't parse event log:%v", err) - - events := rcpt.Logs - assert.Equal(t, 2, len(events), "Should be 2 events.") - - foundStakeEvent := false - for _, event := range events { - stakeEvent, err := c.Staking().ParseLockedStake(*event) - if err == nil { - foundStakeEvent = true - assert.Equal(t, stakeAmount, stakeEvent.Amount, "Stake amount incorrect") - } - } - assert.True(t, foundStakeEvent) -} - -func (s *StakingTestSuite) TestUnlocked() { - stakeAmount := big.NewInt(1000000) - - t := s.T() - eth := s.eth - c := eth.Contracts() - ctx := context.TODO() - - // Start by making sure unlocked balance and stake are both 0 - unlocked, err := c.Staking().BalanceUnlocked(s.callOpts) - assert.Truef(t, err == nil, "Failed to get unlocked balance: %v", err) - assert.Truef(t, big.NewInt(0).Cmp(unlocked) == 0, "Initial unlocked balance should be 0 but is %v", unlocked) - s.eth.Commit() - - staked, err := c.Staking().BalanceStake(s.callOpts) - assert.Truef(t, err == nil, "Failed to get stake balance: %v", err) - assert.Truef(t, big.NewInt(0).Cmp(staked) == 0, "Initial stake should be 0 but is %v", staked) - s.eth.Commit() - - // Now we lock some - this pulls from token balance based on approvals - _, err = c.Staking().LockStake(s.txnOpts, stakeAmount) - assert.True(t, err == nil, "Failed to post stake:%v", err) - s.eth.Commit() - - // Make sure stake shows the increase and unlocked balance has no change - staked, err = c.Staking().BalanceStake(s.callOpts) - assert.Truef(t, err == nil, "Failed to get stake balance: %v", err) - assert.Truef(t, stakeAmount.Cmp(staked) == 0, "Stake should be %v but is %v", stakeAmount, staked) - t.Logf("staked balance is %v", staked) - - unlocked, err = c.Staking().BalanceUnlocked(s.callOpts) - assert.Truef(t, err == nil, "Failed to get unlocked balance: %v", err) - assert.Truef(t, big.NewInt(0).Cmp(unlocked) == 0, "Unlocked balance should be 0 but is %v", unlocked) - t.Logf("unlocked balance is %v", unlocked) - - // Request stake be unlockable - _, err = c.Staking().RequestUnlockStake(s.txnOpts) - assert.Truef(t, err == nil, "Failed to request unlock of stake: %v", err) - s.eth.Commit() - - // Set clock ahead - requires privileged account (contract owner/operator) - ownerAuth, _ := eth.GetTransactionOpts(ctx, eth.GetDefaultAccount()) - _, err = c.Snapshots().SetEpoch(ownerAuth, big.NewInt(5)) - assert.Truef(t, err == nil, "Failed to set clock forward: %v", err) - s.eth.Commit() - - // Now we can actually unlock stake - txn, err := c.Staking().UnlockStake(s.txnOpts, stakeAmount) - assert.Truef(t, err == nil, "Failed to unlock stake: %v", err) - s.eth.Commit() - - // Just making sure the unlock completes - _, err = eth.Queue().QueueAndWait(context.Background(), txn) - if err != nil { - t.Fatal(err) - } - // Now unlocked balance contains what was formerly staked - unlocked, err = c.Staking().BalanceUnlocked(s.callOpts) - assert.Truef(t, err == nil, "Failed to get stake balance: %v", err) - assert.Truef(t, stakeAmount.Cmp(unlocked) == 0, "Unlocked balance should be %v but is %v", stakeAmount, unlocked) -} - -func (s *StakingTestSuite) TestBalanceUnlockedFor() { - t := s.T() - eth := s.eth - c := eth.Contracts() - - balance, err := c.Staking().BalanceUnlockedFor(s.callOpts, c.ValidatorsAddress()) - assert.Nilf(t, err, "Failed: balanceUnlockedFor()") - assert.Truef(t, big.NewInt(0).Cmp(balance) == 0, "Allowance initially should be %v but is %v", InitialAllowance, balance) -} - -func TestStakingTestSuite(t *testing.T) { - suite.Run(t, new(StakingTestSuite)) -} -*/ diff --git a/blockchain/validators_test.go b/blockchain/validators_test.go deleted file mode 100644 index c3f1386d..00000000 --- a/blockchain/validators_test.go +++ /dev/null @@ -1,329 +0,0 @@ -package blockchain_test - -/* -import ( - "bufio" - "context" - "encoding/hex" - "fmt" - "os" - "testing" - - "github.com/MadBase/MadNet/consensus/objs" - "github.com/MadBase/MadNet/crypto" - "github.com/MadBase/MadNet/crypto/bn256" - "github.com/MadBase/MadNet/crypto/bn256/cloudflare" - "github.com/stretchr/testify/assert" -) - -const SnapshotTakenSelector string = "0x6d438b6b835d16cdae6efdc0259fdfba17e6aa32dae81863a2467866f85f724a" - -func TestSnapshot(t *testing.T) { - rawBlockHeaderString := "" + - "000000000000030008000000010004005900000002060000b500000002000000" + - "2a000000004000000d0000000201000019000000020100002500000002010000" + - "31000000020100007e06a605256de00205be97e3db46a7179d10baa270991a68" + - "82adff2b3ca99d37c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b" + - "7bfad8045d85a470000000000000000000000000000000000000000000000000" + - "00000000000000007682aa2f2a0cacceb6abbb88b081b76481dd2704ceb42194" + - "bb4d7aa8e41759110a1673b5fb0848a5fea6fb60aa3d013df90d1797f8b5511c" + - "242f1c4060cbf32512443fa842e474f906eb7aedbff7a2a20818b277ef9e9fed" + - "bae4d4012cdd476021b1d4a7f125e9199e945f602942928ccebfe5f76822bce2" + - "c25b05da413cf9431097b5fc8ed39f381362375f1de1680cdd0525c59a76959b" + - "b91deac7590ecdd12686f605b19f284323f20d30a2b1aa5333f7471acc3787a1" + - "c9b24fed41717ba612f6f612c92fdee07fd6636ed067a0262971ace406b1242a" + - "7c41397d34b642ed" - - // Just make sure it unmarshals as expected - rawBlockHeader, err := hex.DecodeString(rawBlockHeaderString) - assert.Nil(t, err) - assert.Equal(t, 392, len(rawBlockHeader)) - - t.Logf("rawBlockHeader: %x", rawBlockHeader) - - blockHeader := &objs.BlockHeader{} - err = blockHeader.UnmarshalBinary(rawBlockHeader) - if err != nil { - t.Fatal(err) - } - assert.Equal(t, uint32(42), blockHeader.BClaims.ChainID) - assert.Equal(t, uint32(16384), blockHeader.BClaims.Height) - assert.Equal(t, uint32(0), blockHeader.BClaims.TxCount) - - // pull out the block claims - bclaims := blockHeader.BClaims - rawBclaims, err := bclaims.MarshalBinary() - assert.Nil(t, err) - t.Logf("rawBclaims: %x", rawBclaims) - - // pull out the sig - rawSigGroup := blockHeader.SigGroup - assert.Equal(t, rawSigGroup, rawSigGroup) - - publicKeyG2, signatureG1, err := cloudflare.UnmarshalSignature(rawSigGroup) - assert.Nil(t, err) - - publicKey, err := bn256.G2ToBigIntArray(publicKeyG2) - assert.Nil(t, err) - - for idx := 0; idx < 4; idx++ { - t.Logf("publicKey[%d]: %x", idx, publicKey[idx]) - } - - signature, err := bn256.G1ToBigIntArray(signatureG1) - assert.Nil(t, err) - - for idx := 0; idx < 2; idx++ { - t.Logf("signature[%d]: %x", idx, signature[idx]) - } - - fmt.Printf("rawBclaims: %x\n", rawBclaims) - bhsh := crypto.Hasher(rawBclaims) - // fmt.Printf("blockHash: %x", ) - assert.Nil(t, err) - - ok, err := cloudflare.Verify(bhsh, signatureG1, publicKeyG2, cloudflare.HashToG1) - assert.Nil(t, err) - assert.True(t, ok) - - // Check validity with Crypto - eth, err := setupEthereum(t, 4) - assert.Nil(t, err) - - c := eth.Contracts() - ctx := context.TODO() - acct := eth.GetDefaultAccount() - callOpts := eth.GetCallOpts(ctx, acct) - txnOpts, err := eth.GetTransactionOpts(ctx, acct) - assert.Nil(t, err) - - good, err := c.Crypto().Verify(callOpts, bhsh, signature, publicKey) - assert.Nil(t, err) - assert.True(t, good) - - txn, err := c.Validators().Snapshot(txnOpts, rawSigGroup, rawBclaims) - assert.Nil(t, err) - assert.NotNil(t, txn) - eth.Commit() - - rcpt, err := eth.Queue().QueueAndWait(context.Background(), txn) - assert.Nil(t, err) - assert.Equal(t, uint64(1), rcpt.Status) - - // Look for the snapshot taken event - foundIt := false - for _, log := range rcpt.Logs { - if log.Topics[0].String() == SnapshotTakenSelector { - snapshotTaken, err := c.Validators().ParseSnapshotTaken(*log) - assert.Nil(t, err) - assert.Equal(t, uint64(1), snapshotTaken.Epoch.Uint64()) - foundIt = true - - // Now see if I can reconstruct the header from what we have - rawEventBclaims, err := c.Validators().GetRawBlockClaimsSnapshot(callOpts, snapshotTaken.Epoch) - assert.Nil(t, err) - - rawEventSigGroup, err := c.Validators().GetRawSignatureSnapshot(callOpts, snapshotTaken.Epoch) - assert.Nil(t, err) - - assert.Equal(t, rawBclaims, rawEventBclaims) - assert.Equal(t, rawSigGroup, rawEventSigGroup) - - bclaims := &objs.BClaims{} - err = bclaims.UnmarshalBinary(rawEventBclaims) - if err != nil { - t.Fatal(err) - } - header := &objs.BlockHeader{} - header.BClaims = bclaims - header.SigGroup = rawEventSigGroup - - assert.Equal(t, uint32(42), header.BClaims.ChainID) - assert.Equal(t, uint32(16384), header.BClaims.Height) - assert.Equal(t, uint32(0), header.BClaims.TxCount) - } - } - assert.True(t, foundIt, "Should have received SnapshotTaken event") -} - -func TestBlockHeaderParsing(t *testing.T) { - rawBlockHeaderString := "" + - "000000000000030008000000010004005900000002060000b500000002000000" + - "2a000000004000000d0000000201000019000000020100002500000002010000" + - "31000000020100007e06a605256de00205be97e3db46a7179d10baa270991a68" + - "82adff2b3ca99d37c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b" + - "7bfad8045d85a470000000000000000000000000000000000000000000000000" + - "00000000000000007682aa2f2a0cacceb6abbb88b081b76481dd2704ceb42194" + - "bb4d7aa8e41759110a1673b5fb0848a5fea6fb60aa3d013df90d1797f8b5511c" + - "242f1c4060cbf32512443fa842e474f906eb7aedbff7a2a20818b277ef9e9fed" + - "bae4d4012cdd476021b1d4a7f125e9199e945f602942928ccebfe5f76822bce2" + - "c25b05da413cf9431097b5fc8ed39f381362375f1de1680cdd0525c59a76959b" + - "b91deac7590ecdd12686f605b19f284323f20d30a2b1aa5333f7471acc3787a1" + - "c9b24fed41717ba612f6f612c92fdee07fd6636ed067a0262971ace406b1242a" + - "7c41397d34b642ed" - - // Convert the string to binary and make a copy for comparison later - rawBlockHeader, err := hex.DecodeString(rawBlockHeaderString) - assert.Nil(t, err) - - clonedRawBlockHeader := make([]byte, len(rawBlockHeader)) - copy(clonedRawBlockHeader, rawBlockHeader) - - // Just make sure it unmarshals as expected - blockHeader := &objs.BlockHeader{} - err = blockHeader.UnmarshalBinary(rawBlockHeader) - if err != nil { - t.Fatal(err) - } - assert.Equal(t, uint32(42), blockHeader.BClaims.ChainID) - assert.Equal(t, uint32(16384), blockHeader.BClaims.Height) - assert.Equal(t, uint32(0), blockHeader.BClaims.TxCount) - - // Make sure unmarshal->marshal is identical - bh, err := blockHeader.MarshalBinary() - assert.Nil(t, err) - for idx := 0; idx < 392; idx++ { - assert.Equal(t, rawBlockHeader[idx], bh[idx]) - } - - // see what changes - blockHeader.BClaims.ChainID = 42 - // blockHeader.BClaims.Height = 0x12345678 - // blockHeader.BClaims.TxCount = 0 - - bh, err = blockHeader.MarshalBinary() - assert.Nil(t, err) - - // what changed? - differences := make(map[int]string) - - for idx := 0; idx < 392; idx++ { - a := clonedRawBlockHeader[idx] - b := bh[idx] - if a != b { - differences[idx] = fmt.Sprintf("{0x%02x -> 0x%02x}", a, b) - } - } - t.Logf("Change count: %v", len(differences)) - t.Logf(" Changes: %v", differences) -} - -func TestBulkProcessBlockHeaders(t *testing.T) { - file, err := os.Open("../assets/test/blockheaders.txt") - assert.Nil(t, err) - - defer file.Close() - - scanner := bufio.NewScanner(file) - - for scanner.Scan() { - - hexText := scanner.Text() - rawBlockHeader, err := hex.DecodeString(hexText) - assert.Nil(t, err) - - processBlockHeader(t, rawBlockHeader) - } -} - -func processBlockHeader(t *testing.T, rawBlockHeader []byte) { - - blockHeader := &objs.BlockHeader{} - err := blockHeader.UnmarshalBinary(rawBlockHeader) - assert.Nil(t, err) - - // pull out the block claims - bclaims := blockHeader.BClaims - rawBclaims, err := bclaims.MarshalBinary() - assert.Nil(t, err) - bclaimsHash := crypto.Hasher(rawBclaims) - - // pull out the sig - rawSigGroup := blockHeader.SigGroup - - publicKeyG2, signatureG1, err := cloudflare.UnmarshalSignature(rawSigGroup) - assert.Nil(t, err) - - ok, err := cloudflare.Verify(bclaimsHash, signatureG1, publicKeyG2, cloudflare.HashToG1) - assert.Nil(t, err) - assert.True(t, ok, "verify should return true") - - // Check validity with Crypto - assert.Nil(t, err) - - eth, err := setupEthereum(t, 5) - assert.Nil(t, err) - c := eth.Contracts() - ctx := context.TODO() - acct := eth.GetDefaultAccount() - callOpts := eth.GetCallOpts(ctx, acct) - txnOpts, err := eth.GetTransactionOpts(ctx, acct) - assert.Nil(t, err) - - // Convert from G1/G2 into []*big.Int's - publicKey, err := bn256.G2ToBigIntArray(publicKeyG2) - assert.Nil(t, err) - - signature, err := bn256.G1ToBigIntArray(signatureG1) - assert.Nil(t, err) - - good, err := c.Crypto().Verify(callOpts, bclaimsHash, signature, publicKey) - assert.Nil(t, err) - assert.True(t, good) - - t.Logf("rawBclaims: 0x%x", rawBclaims) - - txn, err := c.Validators().Snapshot(txnOpts, rawSigGroup, rawBclaims) - assert.Nil(t, err) - assert.NotNil(t, txn) - eth.Commit() - - rcpt, err := eth.Queue().QueueAndWait(context.Background(), txn) - assert.Nil(t, err) - assert.Equal(t, uint64(1), rcpt.Status) - - // Look for the snapshot taken event - foundIt := false - for _, log := range rcpt.Logs { - if log.Topics[0].String() == SnapshotTakenSelector { - snapshotTaken, err := c.Validators().ParseSnapshotTaken(*log) - assert.Nil(t, err) - assert.Equal(t, uint64(1), snapshotTaken.Epoch.Uint64()) - foundIt = true - - // Now see if I can reconstruct the header from what we have - rawEventBclaims, err := c.Validators().GetRawBlockClaimsSnapshot(callOpts, snapshotTaken.Epoch) - assert.Nil(t, err) - - rawEventSigGroup, err := c.Validators().GetRawSignatureSnapshot(callOpts, snapshotTaken.Epoch) - assert.Nil(t, err) - - chainId, err := c.Validators().GetChainIdFromSnapshot(callOpts, snapshotTaken.Epoch) - assert.Nil(t, err) - - height, err := c.Validators().GetMadHeightFromSnapshot(callOpts, snapshotTaken.Epoch) - assert.Nil(t, err) - - assert.Equal(t, rawBclaims, rawEventBclaims) - assert.Equal(t, rawSigGroup, rawEventSigGroup) - - bclaims := &objs.BClaims{} - err = bclaims.UnmarshalBinary(rawEventBclaims) - assert.Nil(t, err) - - header := &objs.BlockHeader{} - header.BClaims = bclaims - header.SigGroup = rawEventSigGroup - - t.Logf("ChainID:%v Height:%v TxCount:%v", bclaims.ChainID, bclaims.Height, bclaims.TxCount) - - assert.Equal(t, blockHeader.BClaims.ChainID, chainId, "ChainID isn't as expected") - assert.Equal(t, blockHeader.BClaims.Height, height, "Height isn't as expected") - assert.Equal(t, blockHeader.BClaims.ChainID, header.BClaims.ChainID) - assert.Equal(t, blockHeader.BClaims.Height, header.BClaims.Height) - assert.Equal(t, blockHeader.BClaims.TxCount, header.BClaims.TxCount) - } - } - assert.True(t, foundIt, "Should have received SnapshotTaken event") -} -*/ diff --git a/docker/generate-bridge/Dockerfile b/docker/generate-bridge/Dockerfile index da8b6de0..3dc5409f 100644 --- a/docker/generate-bridge/Dockerfile +++ b/docker/generate-bridge/Dockerfile @@ -22,4 +22,4 @@ ADD --chown=$BUILDER_UID bridge/package.json bridge/package-lock.json /app/ RUN npm ci COPY --from=go_deps /go/bin/ /usr/local/bin/ -CMD npm run build \ No newline at end of file +CMD npm run build