instructions.go

// Code generated by https://github.com/gagliardetto/anchor-go. DO NOT EDIT.

package nft_candy_machine

import (
	"bytes"
	"fmt"
	ag_spew "github.com/davecgh/go-spew/spew"
	ag_binary "github.com/gagliardetto/binary"
	ag_solanago "github.com/desperatee/solana-go"
	ag_text "github.com/desperatee/solana-go/text"
	ag_treeout "github.com/gagliardetto/treeout"
)

var ProgramID ag_solanago.PublicKey

func SetProgramID(pubkey ag_solanago.PublicKey) {
	ProgramID = pubkey
	ag_solanago.RegisterInstructionDecoder(ProgramID, registryDecodeInstruction)
}

const ProgramName = "NftCandyMachine"

func init() {
	if !ProgramID.IsZero() {
		ag_solanago.RegisterInstructionDecoder(ProgramID, registryDecodeInstruction)
	}
}

var (
	Instruction_MintV4 = ag_binary.TypeID([8]byte{79, 71, 207, 32, 178, 102, 21, 19})
	
	Instruction_MintEmbed = ag_binary.TypeID([8]byte{133, 221, 27, 96, 4, 65, 206, 186})

	Instruction_MintV2 = ag_binary.TypeID([8]byte{120, 121, 23, 146, 173, 110, 199, 205})

	Instruction_UpdateCandyMachine = ag_binary.TypeID([8]byte{243, 251, 124, 156, 211, 211, 118, 239})

	Instruction_EditCmV2 = ag_binary.TypeID([8]byte{12, 115, 248, 70, 118, 97, 136, 163})

	Instruction_EditCmV3 = ag_binary.TypeID([8]byte{85, 87, 21, 33, 241, 184, 109, 132})

	Instruction_BurnSupply = ag_binary.TypeID([8]byte{6, 185, 12, 193, 130, 247, 181, 35})

	Instruction_BurnSupplyV2 = ag_binary.TypeID([8]byte{77, 125, 254, 242, 7, 144, 93, 148})

	Instruction_InitCmV3 = ag_binary.TypeID([8]byte{11, 189, 187, 61, 13, 104, 85, 35})

	Instruction_InitCmV2 = ag_binary.TypeID([8]byte{150, 13, 41, 11, 41, 78, 198, 229})

	Instruction_SetWhitelist = ag_binary.TypeID([8]byte{69, 161, 114, 252, 244, 66, 197, 48})

	Instruction_UpdateAuthority = ag_binary.TypeID([8]byte{32, 46, 64, 28, 149, 75, 243, 88})

	Instruction_CoolCats = ag_binary.TypeID([8]byte{170, 8, 97, 20, 95, 90, 0, 98})
)

// InstructionIDToName returns the name of the instruction given its ID.
func InstructionIDToName(id ag_binary.TypeID) string {
	switch id {
	case Instruction_MintV4:
		return "MintV4"
	case Instruction_MintEmbed:
		return "MintEmbed"
	case Instruction_MintV2:
		return "MintV2"
	case Instruction_UpdateCandyMachine:
		return "UpdateCandyMachine"
	case Instruction_EditCmV2:
		return "EditCmV2"
	case Instruction_EditCmV3:
		return "EditCmV3"
	case Instruction_BurnSupply:
		return "BurnSupply"
	case Instruction_BurnSupplyV2:
		return "BurnSupplyV2"
	case Instruction_InitCmV3:
		return "InitCmV3"
	case Instruction_InitCmV2:
		return "InitCmV2"
	case Instruction_SetWhitelist:
		return "SetWhitelist"
	case Instruction_UpdateAuthority:
		return "UpdateAuthority"
	case Instruction_CoolCats:
		return "CoolCats"
	default:
		return ""
	}
}

type Instruction struct {
	ag_binary.BaseVariant
}

func (inst *Instruction) EncodeToTree(parent ag_treeout.Branches) {
	if enToTree, ok := inst.Impl.(ag_text.EncodableToTree); ok {
		enToTree.EncodeToTree(parent)
	} else {
		parent.Child(ag_spew.Sdump(inst))
	}
}

var InstructionImplDef = ag_binary.NewVariantDefinition(
	ag_binary.AnchorTypeIDEncoding,
	[]ag_binary.VariantType{
		{
			"mint_v4", (*MintV4)(nil),
		},
		{
			"mint_embed", (*MintEmbed)(nil),
		},
		{
			"mint_v2", (*MintV2)(nil),
		},
		{
			"update_candy_machine", (*UpdateCandyMachine)(nil),
		},
		{
			"edit_cm_v2", (*EditCmV2)(nil),
		},
		{
			"edit_cm_v3", (*EditCmV3)(nil),
		},
		{
			"burn_supply", (*BurnSupply)(nil),
		},
		{
			"burn_supply_v2", (*BurnSupplyV2)(nil),
		},
		{
			"init_cm_v3", (*InitCmV3)(nil),
		},
		{
			"init_cm_v2", (*InitCmV2)(nil),
		},
		{
			"set_whitelist", (*SetWhitelist)(nil),
		},
		{
			"update_authority", (*UpdateAuthority)(nil),
		},
		{
			"cool_cats", (*CoolCats)(nil),
		},
	},
)

func (inst *Instruction) ProgramID() ag_solanago.PublicKey {
	return ProgramID
}

func (inst *Instruction) Accounts() (out []*ag_solanago.AccountMeta) {
	return inst.Impl.(ag_solanago.AccountsGettable).GetAccounts()
}

func (inst *Instruction) Data() ([]byte, error) {
	buf := new(bytes.Buffer)
	if err := ag_binary.NewBorshEncoder(buf).Encode(inst); err != nil {
		return nil, fmt.Errorf("unable to encode instruction: %w", err)
	}
	return buf.Bytes(), nil
}

func (inst *Instruction) TextEncode(encoder *ag_text.Encoder, option *ag_text.Option) error {
	return encoder.Encode(inst.Impl, option)
}

func (inst *Instruction) UnmarshalWithDecoder(decoder *ag_binary.Decoder) error {
	return inst.BaseVariant.UnmarshalBinaryVariant(decoder, InstructionImplDef)
}

func (inst *Instruction) MarshalWithEncoder(encoder *ag_binary.Encoder) error {
	err := encoder.WriteBytes(inst.TypeID.Bytes(), false)
	if err != nil {
		return fmt.Errorf("unable to write variant type: %w", err)
	}
	return encoder.Encode(inst.Impl)
}

func registryDecodeInstruction(accounts []*ag_solanago.AccountMeta, data []byte) (interface{}, error) {
	inst, err := DecodeInstruction(accounts, data)
	if err != nil {
		return nil, err
	}
	return inst, nil
}

func DecodeInstruction(accounts []*ag_solanago.AccountMeta, data []byte) (*Instruction, error) {
	inst := new(Instruction)
	if err := ag_binary.NewBorshDecoder(data).Decode(inst); err != nil {
		return nil, fmt.Errorf("unable to decode instruction: %w", err)
	}
	if v, ok := inst.Impl.(ag_solanago.AccountsSettable); ok {
		err := v.SetAccounts(accounts)
		if err != nil {
			return nil, fmt.Errorf("unable to set accounts for instruction: %w", err)
		}
	}
	return inst, nil
}