Function TestTransfer

core/api_test.go:201–338

(t *testing.T)

}

func TestTransfer(t *testing.T) {
	_, db := pgtest.NewDB(t, pgtest.SchemaPath)
	ctx := context.Background()
	c := prottest.NewChain(t)
	g := generator.New(c, nil, db)
	pinStore := pin.NewStore(db)
	coretest.CreatePins(ctx, t, pinStore)
	api := &API{
		chain:     c,
		submitter: g,
		assets:    asset.NewRegistry(db, c, pinStore),
		accounts:  account.NewManager(db, c, pinStore),
		indexer:   query.NewIndexer(db, c, pinStore),
		db:        db,
	}
	api.assets.IndexAssets(api.indexer)
	api.accounts.IndexAccounts(api.indexer)
	go api.accounts.ProcessBlocks(ctx)
	api.indexer.RegisterAnnotator(api.accounts.AnnotateTxs)
	api.indexer.RegisterAnnotator(api.assets.AnnotateTxs)
	api.leader = alwaysLeader{}

	assetAlias := "some-asset"
	account1Alias := "first-account"
	account2Alias := "second-account"

	assetID := coretest.CreateAsset(ctx, t, api.assets, nil, assetAlias, nil)
	account1ID := coretest.CreateAccount(ctx, t, api.accounts, account1Alias, nil)
	account2ID := coretest.CreateAccount(ctx, t, api.accounts, account2Alias, nil)

	assetIDStr := assetID.String()

	// Preface: issue some asset for account1ID to transfer to account2ID
	issueAssetAmount := bc.AssetAmount{
		AssetId: &assetID,
		Amount:  100,
	}
	txTemplate, err := txbuilder.Build(ctx, nil, []txbuilder.Action{
		api.assets.NewIssueAction(issueAssetAmount, nil),
		api.accounts.NewControlAction(issueAssetAmount, account1ID, nil),
	}, time.Now().Add(time.Minute))
	if err != nil {
		testutil.FatalErr(t, err)
	}

	coretest.SignTxTemplate(t, ctx, txTemplate, nil)

	err = txbuilder.FinalizeTx(ctx, c, g, txTemplate.Transaction)
	if err != nil {
		testutil.FatalErr(t, err)
	}

	// Make a block so that UTXOs from the above tx are available to spend.
	prottest.MakeBlock(t, c, g.PendingTxs())
	<-pinStore.PinWaiter(account.PinName, c.Height())

	// Now transfer
	buildReqFmt := `