Implement account transition unit test

pkg/tests/combined_account_transition_test.go

@@ -0,0 +1,261 @@
+package tests
+
+import (
+	"testing"
+
+	"github.com/iotaledger/iota-core/pkg/model"
+	"github.com/iotaledger/iota-core/pkg/protocol/engine/accounts"
+	"github.com/iotaledger/iota-core/pkg/testsuite"
+	"github.com/iotaledger/iota-core/pkg/testsuite/mock"
+	iotago "github.com/iotaledger/iota.go/v4"
+	"github.com/iotaledger/iota.go/v4/tpkg"
+)
+
+// Test_AccountStateTransition follows the account state transition flow described in:
+// https://github.com/iotaledger/iota-core/issues/660#issuecomment-1892596243
+func Test_AccountStateTransition(t *testing.T) {
+	ts := testsuite.NewTestSuite(t,
+		testsuite.WithProtocolParametersOptions(
+			iotago.WithTimeProviderOptions(
+				0,
+				testsuite.GenesisTimeWithOffsetBySlots(200, testsuite.DefaultSlotDurationInSeconds),
+				testsuite.DefaultSlotDurationInSeconds,
+				testsuite.DefaultSlotsPerEpochExponent,
+			),
+		),
+	)
+	defer ts.Shutdown()
+
+	node1 := ts.AddValidatorNode("node1")
+	node2 := ts.AddValidatorNode("node2")
+	wallet := ts.AddDefaultWallet(node1)
+
+	ts.Run(true)
+
+	// split genesis output into 4 outputs for the further usage.
+	tx1 := wallet.CreateBasicOutputsEquallyFromInput("TX1", 4, "Genesis:0")
+	ts.IssueBasicBlockWithOptions("block0", wallet, tx1)
+
+	// Issue some more blocks to make transaction accepted
+	{
+		ts.IssueValidationBlockWithHeaderOptions("vblock0", node2, mock.WithStrongParents(ts.BlockID("block0")))
+		ts.IssueValidationBlockWithHeaderOptions("vblock1", node1, mock.WithStrongParents(ts.BlockID("vblock0")))
+		ts.IssueValidationBlockWithHeaderOptions("vblock2", node2, mock.WithStrongParents(ts.BlockID("vblock1")))
+
+		ts.AssertTransactionsInCacheAccepted(wallet.Transactions("TX1"), true, node1, node2)
+	}
+
+	// create the account1 from TX1:0 with wallet "first"
+	// generated (block1, TX2)
+	ts.AddWallet("first", node1, iotago.EmptyAccountID)
+	createFullAccount(ts)
+
+	// create the account2, from implicit to full account from TX1:1 with wallet "second"
+	// generated (block2, TX3), (block3, TX4)
+	ts.AddWallet("second", node1, iotago.EmptyAccountID)
+	account2ID := createImplicitToFullAccount(ts)
+
+	// send funds to account2, with TX1:2
+	// generated (block4, TX5)
+	sendFunds(ts)
+
+	// allot 1000 mana to account2 with TX1:3
+	// generated (block5, TX6)
+	allotManaTo(ts, account2ID)
+
+	// create native token from "TX5:0" and account2 (TX4:0)
+	// generated (block6, TX7)
+	createNativetoken(ts)
+}
+
+func createFullAccount(ts *testsuite.TestSuite) iotago.AccountID {
+	node1 := ts.Node("node1")
+	newUserWallet := ts.Wallet("first")
+
+	// CREATE NEW ACCOUNT WITH BLOCK ISSUER FROM BASIC UTXO
+	newAccountBlockIssuerKey := tpkg.RandBlockIssuerKey()
+	// set the expiry slot of the transitioned genesis account to the latest committed + MaxCommittableAge
+	newAccountExpirySlot := node1.Protocol.Engines.Main.Get().Storage.Settings().LatestCommitment().Slot() + ts.API.ProtocolParameters().MaxCommittableAge()
+
+	tx1 := ts.DefaultWallet().CreateAccountFromInput(
+		"TX2",
+		"TX1:0",
+		newUserWallet,
+		mock.WithBlockIssuerFeature(iotago.BlockIssuerKeys{newAccountBlockIssuerKey}, newAccountExpirySlot),
+		mock.WithAccountAmount(mock.MinIssuerAccountAmount(ts.API.ProtocolParameters())),
+		mock.WithAccountMana(mock.MaxBlockManaCost(ts.DefaultWallet().Node.Protocol.CommittedAPI().ProtocolParameters())),
+	)
+
+	block1 := ts.IssueBasicBlockWithOptions("block1", ts.DefaultWallet(), tx1)
+	var block1Slot iotago.SlotIndex = block1.ID().Slot()
+
+	ts.CommitUntilSlot(block1Slot, block1.ID())
+
+	newAccount := newUserWallet.AccountOutput("TX2:0")
+	newAccountOutput := newAccount.Output().(*iotago.AccountOutput)
+
+	ts.AssertAccountDiff(newAccountOutput.AccountID, block1Slot, &model.AccountDiff{
+		BICChange:              0,
+		PreviousUpdatedSlot:    0,
+		NewExpirySlot:          newAccountExpirySlot,
+		PreviousExpirySlot:     0,
+		NewOutputID:            newAccount.OutputID(),
+		PreviousOutputID:       iotago.EmptyOutputID,
+		BlockIssuerKeysAdded:   iotago.NewBlockIssuerKeys(newAccountBlockIssuerKey),
+		BlockIssuerKeysRemoved: iotago.NewBlockIssuerKeys(),
+		ValidatorStakeChange:   0,
+		StakeEndEpochChange:    0,
+		FixedCostChange:        0,
+		DelegationStakeChange:  0,
+	}, false, ts.Nodes()...)
+
+	ts.AssertAccountData(&accounts.AccountData{
+		ID:              newAccountOutput.AccountID,
+		Credits:         accounts.NewBlockIssuanceCredits(0, block1Slot),
+		ExpirySlot:      newAccountExpirySlot,
+		OutputID:        newAccount.OutputID(),
+		BlockIssuerKeys: iotago.NewBlockIssuerKeys(newAccountBlockIssuerKey),
+	}, ts.Nodes()...)
+
+	return newAccountOutput.AccountID
+}
+
+func createImplicitToFullAccount(ts *testsuite.TestSuite) iotago.AccountID {
+	node1 := ts.Node("node1")
+	newUserWallet := ts.Wallet("second")
+
+	// CREATE IMPLICIT ACCOUNT FROM GENESIS BASIC UTXO, SENT TO A NEW USER WALLET.
+	// a default wallet, already registered in the ledger, will issue the transaction and block.
+	tx3 := ts.DefaultWallet().CreateImplicitAccountFromInput(
+		"TX3",
+		"TX1:1",
+		newUserWallet,
+	)
+	block2 := ts.IssueBasicBlockWithOptions("block2", ts.DefaultWallet(), tx3)
+	block2Slot := block2.ID().Slot()
+	latestParents := ts.CommitUntilSlot(block2Slot, block2.ID())
+
+	implicitAccountOutput := newUserWallet.Output("TX3:0")
+	implicitAccountOutputID := implicitAccountOutput.OutputID()
+	implicitAccountID := iotago.AccountIDFromOutputID(implicitAccountOutputID)
+	var implicitBlockIssuerKey iotago.BlockIssuerKey = iotago.Ed25519PublicKeyHashBlockIssuerKeyFromImplicitAccountCreationAddress(newUserWallet.ImplicitAccountCreationAddress())
+
+	// the new implicit account should now be registered in the accounts ledger.
+	ts.AssertAccountData(&accounts.AccountData{
+		ID:              implicitAccountID,
+		Credits:         accounts.NewBlockIssuanceCredits(0, block2Slot),
+		ExpirySlot:      iotago.MaxSlotIndex,
+		OutputID:        implicitAccountOutputID,
+		BlockIssuerKeys: iotago.NewBlockIssuerKeys(implicitBlockIssuerKey),
+	}, ts.Nodes()...)
+
+	// TRANSITION IMPLICIT ACCOUNT TO ACCOUNT OUTPUT.
+	block3Slot := ts.CurrentSlot()
+	tx4 := newUserWallet.TransitionImplicitAccountToAccountOutput(
+		"TX4",
+		"TX3:0",
+		mock.WithBlockIssuerFeature(
+			iotago.BlockIssuerKeys{implicitBlockIssuerKey},
+			iotago.MaxSlotIndex,
+		),
+		mock.WithAccountAmount(mock.MinIssuerAccountAmount(ts.API.ProtocolParameters())),
+	)
+	block2Commitment := node1.Protocol.Engines.Main.Get().Storage.Settings().LatestCommitment().Commitment()
+	block3 := ts.IssueBasicBlockWithOptions("block3", newUserWallet, tx4, mock.WithStrongParents(latestParents...))
+	latestParents = ts.CommitUntilSlot(block3Slot, block3.ID())
+
+	fullAccountOutputID := newUserWallet.Output("TX4:0").OutputID()
+	allotted := iotago.BlockIssuanceCredits(tx4.Transaction.Allotments.Get(implicitAccountID))
+	burned := iotago.BlockIssuanceCredits(block3.WorkScore()) * iotago.BlockIssuanceCredits(block2Commitment.ReferenceManaCost)
+	// the implicit account should now have been transitioned to a full account in the accounts ledger.
+	ts.AssertAccountDiff(implicitAccountID, block3Slot, &model.AccountDiff{
+		BICChange:             allotted - burned,
+		PreviousUpdatedSlot:   block2Slot,
+		NewOutputID:           fullAccountOutputID,
+		PreviousOutputID:      implicitAccountOutputID,
+		PreviousExpirySlot:    iotago.MaxSlotIndex,
+		NewExpirySlot:         iotago.MaxSlotIndex,
+		ValidatorStakeChange:  0,
+		StakeEndEpochChange:   0,
+		FixedCostChange:       0,
+		DelegationStakeChange: 0,
+	}, false, ts.Nodes()...)
+
+	ts.AssertAccountData(&accounts.AccountData{
+		ID:              implicitAccountID,
+		Credits:         accounts.NewBlockIssuanceCredits(allotted-burned, block3Slot),
+		ExpirySlot:      iotago.MaxSlotIndex,
+		OutputID:        fullAccountOutputID,
+		BlockIssuerKeys: iotago.NewBlockIssuerKeys(implicitBlockIssuerKey),
+	}, ts.Nodes()...)
+
+	return implicitAccountID
+}
+
+func sendFunds(ts *testsuite.TestSuite) {
+	node1 := ts.Node("node1")
+	node2 := ts.Node("node2")
+	wallet := ts.DefaultWallet()
+	secondWallet := ts.Wallet("second")
+
+	// send funds from defaultWallet to secondWallet
+	tx := wallet.SendFundsToWallet("TX5", secondWallet, "TX1:2")
+	ts.IssueBasicBlockWithOptions("block4", wallet, tx)
+
+	ts.AssertTransactionsExist(wallet.Transactions("TX5"), true, node1)
+	ts.AssertTransactionsInCacheBooked(wallet.Transactions("TX5"), true, node1)
+
+	// Issue some more blocks to make transaction accepted
+	{
+		ts.IssueValidationBlockWithHeaderOptions("vblock9", node2, mock.WithStrongParents(ts.BlockID("block4")))
+		ts.IssueValidationBlockWithHeaderOptions("vblock10", node1, mock.WithStrongParents(ts.BlockID("vblock9")))
+		ts.IssueValidationBlockWithHeaderOptions("vblock11", node2, mock.WithStrongParents(ts.BlockID("vblock10")))
+
+		ts.AssertTransactionsInCacheAccepted(wallet.Transactions("TX5"), true, node1, node2)
+	}
+}
+
+func allotManaTo(ts *testsuite.TestSuite, to iotago.AccountID) {
+	wallet := ts.DefaultWallet()
+	node1 := ts.Node("node1")
+	node2 := ts.Node("node2")
+
+	tx6 := wallet.AllotManaFromInputs("TX6",
+		iotago.Allotments{&iotago.Allotment{
+			AccountID: to,
+			Mana:      iotago.Mana(1000),
+		}}, "TX1:3")
+	commitment := node1.Protocol.Engines.Main.Get().Storage.Settings().LatestCommitment().Commitment()
+	ts.IssueBasicBlockWithOptions("block5", wallet, tx6, mock.WithSlotCommitment(commitment))
+
+	// Issue some more blocks to make transaction accepted
+	{
+		ts.IssueValidationBlockWithHeaderOptions("vblock6", node2, mock.WithStrongParents(ts.BlockID("block5")))
+		ts.IssueValidationBlockWithHeaderOptions("vblock7", node1, mock.WithStrongParents(ts.BlockID("vblock6")))
+		ts.IssueValidationBlockWithHeaderOptions("vblock8", node2, mock.WithStrongParents(ts.BlockID("vblock7")))
+
+		ts.AssertTransactionsInCacheAccepted(wallet.Transactions("TX6"), true, node1, node2)
+	}
+}
+
+// createNativetoken creates a native token from the given input and account.
+func createNativetoken(ts *testsuite.TestSuite) {
+	wallet := ts.Wallet("second")
+	node1 := ts.Node("node1")
+	node2 := ts.Node("node2")
+
+	tx := wallet.CreateNativeTokenFromInput("TX7", "TX5:0", "TX4:0", 5_000_000, 10_000_000_000)
+	ts.IssueBasicBlockWithOptions("block6", wallet, tx)
+
+	ts.AssertTransactionsExist(wallet.Transactions("TX7"), true, node1)
+	ts.AssertTransactionsInCacheBooked(wallet.Transactions("TX7"), true, node1)
+
+	// Issue some more blocks to make transaction accepted
+	{
+		ts.IssueValidationBlockWithHeaderOptions("vblock12", node2, mock.WithStrongParents(ts.BlockID("block6")))
+		ts.IssueValidationBlockWithHeaderOptions("vblock13", node1, mock.WithStrongParents(ts.BlockID("vblock12")))
+		ts.IssueValidationBlockWithHeaderOptions("vblock14", node2, mock.WithStrongParents(ts.BlockID("vblock13")))
+
+		ts.AssertTransactionsInCacheAccepted(wallet.Transactions("TX7"), true, node1, node2)
+	}
+}

pkg/testsuite/accounts.go

@@ -148,11 +148,11 @@ func (t *TestSuite) AssertAccountDiff(accountID iotago.AccountID, index iotago.S
 				return ierrors.Errorf("AssertAccountDiff: %s: expected previous output ID %s but actual %s for account %s at slot %d", node.Name, accountDiff.PreviousOutputID, actualAccountDiff.PreviousOutputID, accountID, index)
 			}
 
-			if !assert.Equal(t.fakeTesting, accountDiff.BlockIssuerKeysAdded, actualAccountDiff.BlockIssuerKeysAdded) {
+			if !assert.True(t.fakeTesting, accountDiff.BlockIssuerKeysAdded.Equal(actualAccountDiff.BlockIssuerKeysAdded)) {
 				return ierrors.Errorf("AssertAccountDiff: %s: expected pub keys added %s but actual %s for account %s at slot %d", node.Name, accountDiff.BlockIssuerKeysAdded, actualAccountDiff.BlockIssuerKeysAdded, accountID, index)
 			}
 
-			if !assert.Equal(t.fakeTesting, accountDiff.BlockIssuerKeysRemoved, actualAccountDiff.BlockIssuerKeysRemoved) {
+			if !assert.True(t.fakeTesting, accountDiff.BlockIssuerKeysRemoved.Equal(actualAccountDiff.BlockIssuerKeysRemoved)) {
 				return ierrors.Errorf("AssertAccountDiff: %s: expected pub keys removed %s but actual %s for account %s at slot %d", node.Name, accountDiff.BlockIssuerKeysRemoved, actualAccountDiff.BlockIssuerKeysRemoved, accountID, index)
 			}
 

pkg/testsuite/mock/utils.go

@@ -46,7 +46,7 @@ func MaxBlockManaCost(protocolParameters iotago.ProtocolParameters) iotago.Mana
 
 // TransactionBuilder options
 
-func WithInputs(inputs utxoledger.Outputs) options.Option[builder.TransactionBuilder] {
+func WithInputs(inputs ...*utxoledger.Output) options.Option[builder.TransactionBuilder] {
 	return func(txBuilder *builder.TransactionBuilder) {
 		for _, input := range inputs {
 			switch input.OutputType() {
@@ -124,7 +124,7 @@ func WithRewardInput(input *iotago.RewardInput, mana iotago.Mana) options.Option
 	}
 }
 
-func WithOutputs(outputs iotago.Outputs[iotago.Output]) options.Option[builder.TransactionBuilder] {
+func WithOutputs(outputs ...iotago.Output) options.Option[builder.TransactionBuilder] {
 	return func(txBuilder *builder.TransactionBuilder) {
 		for _, output := range outputs {
 			txBuilder.AddOutput(output)

pkg/testsuite/mock/wallet.go

@@ -58,7 +58,7 @@ func (w *Wallet) SetBlockIssuer(accountID iotago.AccountID) {
 
 func (w *Wallet) BlockIssuerKey() iotago.BlockIssuerKey {
 	if w.BlockIssuer != nil {
-		return w.BlockIssuerKey()
+		return w.BlockIssuer.BlockIssuerKey()
 	}
 	_, pub := w.keyManager.KeyPair()