immutableData := AttributeMap{
      "name":       NewAtomicAttribute("string", "Testing 123"),
      "uuid":       NewAtomicAttribute("string", "e448d107-ae41-4f44-a1eb-87a0c1b27972"),
      "type":       NewAtomicAttribute("string", "Hello"),
      "attribute":  NewAtomicAttribute("string", "Cool"),
      "identifier": NewAtomicAttribute("string", "1A406030000678A000013372"),
      "something":  NewAtomicAttribute("string", "Testing Testing"),
}

package main

import (
	"context"
	"encoding/json"
	"fmt"

	"github.com/eoscanada/eos-go"
)

var AtomicAttributeVariant = eos.NewVariantDefinition([]eos.VariantType{
	{Name: "int8", Type: int8(0)},
	{Name: "int16", Type: int16(0)},
	{Name: "int32", Type: int32(0)},
	{Name: "int64", Type: int64(0)},
	{Name: "uint8", Type: uint8(0)},
	{Name: "uint16", Type: uint16(0)},
	{Name: "uint32", Type: uint32(0)},
	{Name: "uint64", Type: uint64(0)},
	{Name: "float", Type: float32(0)},
	{Name: "double", Type: float64(0)},
	{Name: "string", Type: ""},
	{Name: "INT8_VEC", Type: []int8{}},
	{Name: "INT16_VEC", Type: []int16{}},
	{Name: "INT32_VEC", Type: []int32{}},
	{Name: "INT64_VEC", Type: []int64{}},
	{Name: "UINT8_VEC", Type: []uint8{}},
	{Name: "UINT16_VEC", Type: []uint16{}},
	{Name: "UINT32_VEC", Type: []uint32{}},
	{Name: "UINT64_VEC", Type: []uint64{}},
	{Name: "FLOAT_VEC", Type: []float32{}},
	{Name: "DOUBLE_VEC", Type: []float64{}},
	{Name: "STRING_VEC", Type: []string{}},
})

type AttributeMap map[string]AtomicAttribute

type AtomicAttribute struct {
	eos.BaseVariant
}

func (a *AtomicAttribute) MarshalJSON() ([]byte, error) {
	return a.BaseVariant.MarshalJSON(AtomicAttributeVariant)
}

func (a *AtomicAttribute) UnmarshalJSON(data []byte) error {
	return a.BaseVariant.UnmarshalJSON(data, AtomicAttributeVariant)
}

func (a *AtomicAttribute) UnmarshalBinary(decoder *eos.Decoder) error {
	return a.BaseVariant.UnmarshalBinaryVariant(decoder, AtomicAttributeVariant)
}

func NewAtomicAttribute(typeId string, value interface{}) AtomicAttribute {
	return AtomicAttribute{
		BaseVariant: eos.BaseVariant{
			TypeID: AtomicAttributeVariant.TypeID(typeId),
			Impl:   value,
		},
	}
}

type mintAssetActionData struct {
	AuthorizedMinter eos.AccountName `json:"authorized_minter"`
	CollectionName   eos.Name        `json:"collection_name"`
	SchemaName       eos.Name        `json:"schema_name"`
	TemplateID       int32           `json:"template_id"`
	NewAssetOwner    eos.AccountName `json:"new_asset_owner"`
	ImmutableData    AttributeMap    `json:"immutable_data"`
	MutableData      AttributeMap    `json:"mutable_data"`
	TokensToBack     []eos.Asset     `json:"tokens_to_back"`
}

var privateKey = ""
var nodeURL = "http://api.waxtest.alohaeos.com"

var templateID int32 = 572080

var minter eos.AccountName = "testvariants"
var wallet eos.AccountName = "testvariants"

var collectionName = eos.Name("testvariants")
var schemaName = eos.Name("testing")

func main() {
	api := eos.New(nodeURL)

	keyBag := &eos.KeyBag{}

	err := keyBag.ImportPrivateKey(context.Background(), privateKey)
	if err != nil {
		panic(fmt.Errorf("error importing private key: %w", err))
	}

	api.SetSigner(keyBag)

	api.Debug = true

	minter := eos.AccountName(minter)

	immutableData := AttributeMap{
		"name":       NewAtomicAttribute("string", "Testing 123"),
		"uuid":       NewAtomicAttribute("string", "e448d107-ae41-4f44-a1eb-87a0c1b27972"),
		"type":       NewAtomicAttribute("string", "Hello"),
		"attribute":  NewAtomicAttribute("string", "Cool"),
		"identifier": NewAtomicAttribute("string", "1A406030000678A000013372"),
		"something":  NewAtomicAttribute("string", "Testing Testing"),
	}

	mintActionData := eos.NewActionData(&mintAssetActionData{
		AuthorizedMinter: minter,
		CollectionName:   collectionName,
		SchemaName:       schemaName,
		TemplateID:       templateID,
		NewAssetOwner:    wallet,
		ImmutableData:    immutableData,
		MutableData:      AttributeMap{},
		TokensToBack:     []eos.Asset{},
	})

	mintAction := &eos.Action{
		Account: eos.AccountName("atomicassets"),
		Name:    eos.ActionName("mintasset"),
		Authorization: []eos.PermissionLevel{
			{
				Actor:      minter,
				Permission: eos.PermissionName("active"),
			},
		},
		ActionData: mintActionData,
	}

	actions := []*eos.Action{
		mintAction,
	}

	txOpts := &eos.TxOptions{}
	if err := txOpts.FillFromChain(context.Background(), api); err != nil {
		panic(fmt.Errorf("error filling tx opts: %w", err))
	}

	tx := eos.NewTransaction(actions, txOpts)

	signedTx, packedTx, err := api.SignTransaction(context.Background(), tx, txOpts.ChainID, eos.CompressionNone)
	if err != nil {
		panic(fmt.Errorf("error signing transaction: %w", err))
	}

	fmt.Println(signedTx)

	content, err := json.MarshalIndent(signedTx, "", "  ")
	if err != nil {
		panic(fmt.Errorf("json marshalling transaction: %w", err))
	}

	fmt.Println(string(content))
	fmt.Println()

	response, err := api.PushTransaction(context.Background(), packedTx)
	if err != nil {
		panic(fmt.Errorf("error pushing transaction: %w", err))
	}

	fmt.Println(response.TransactionID)
}