accounts.go

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

package nft_candy_machine

import (
	"fmt"
	ag_binary "github.com/gagliardetto/binary"
	ag_solanago "github.com/desperatee/solana-go"
)

type CandyMachine struct {
	Authority              ag_solanago.PublicKey
	WalletAuthority        ag_solanago.PublicKey
	Config                 ag_solanago.PublicKey
	ItemsRedeemedNormal    uint64
	ItemsRedeemedRaffle    uint64
	RaffleTicketsPurchased uint64
	Uuid                   string
	ItemsAvailable         uint64
	RaffleSeed             uint64
	Bump                   uint8
	Notary                 *ag_solanago.PublicKey `bin:"optional"`
	OrderInfo              ag_solanago.PublicKey
	IsLite                 bool
	NotaryRequired         []bool
}

var CandyMachineDiscriminator = [8]byte{51, 173, 177, 113, 25, 241, 109, 189}

func (obj CandyMachine) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Write account discriminator:
	err = encoder.WriteBytes(CandyMachineDiscriminator[:], false)
	if err != nil {
		return err
	}
	// Serialize `Authority` param:
	err = encoder.Encode(obj.Authority)
	if err != nil {
		return err
	}
	// Serialize `WalletAuthority` param:
	err = encoder.Encode(obj.WalletAuthority)
	if err != nil {
		return err
	}
	// Serialize `Config` param:
	err = encoder.Encode(obj.Config)
	if err != nil {
		return err
	}
	// Serialize `ItemsRedeemedNormal` param:
	err = encoder.Encode(obj.ItemsRedeemedNormal)
	if err != nil {
		return err
	}
	// Serialize `ItemsRedeemedRaffle` param:
	err = encoder.Encode(obj.ItemsRedeemedRaffle)
	if err != nil {
		return err
	}
	// Serialize `RaffleTicketsPurchased` param:
	err = encoder.Encode(obj.RaffleTicketsPurchased)
	if err != nil {
		return err
	}
	// Serialize `Uuid` param:
	err = encoder.Encode(obj.Uuid)
	if err != nil {
		return err
	}
	// Serialize `ItemsAvailable` param:
	err = encoder.Encode(obj.ItemsAvailable)
	if err != nil {
		return err
	}
	// Serialize `RaffleSeed` param:
	err = encoder.Encode(obj.RaffleSeed)
	if err != nil {
		return err
	}
	// Serialize `Bump` param:
	err = encoder.Encode(obj.Bump)
	if err != nil {
		return err
	}
	// Serialize `Notary` param (optional):
	{
		if obj.Notary == nil {
			err = encoder.WriteBool(false)
			if err != nil {
				return err
			}
		} else {
			err = encoder.WriteBool(true)
			if err != nil {
				return err
			}
			err = encoder.Encode(obj.Notary)
			if err != nil {
				return err
			}
		}
	}
	// Serialize `OrderInfo` param:
	err = encoder.Encode(obj.OrderInfo)
	if err != nil {
		return err
	}
	// Serialize `IsLite` param:
	err = encoder.Encode(obj.IsLite)
	if err != nil {
		return err
	}
	// Serialize `NotaryRequired` param:
	err = encoder.Encode(obj.NotaryRequired)
	if err != nil {
		return err
	}
	return nil
}

func (obj *CandyMachine) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Read and check account discriminator:
	{
		discriminator, err := decoder.ReadTypeID()
		if err != nil {
			return err
		}
		if !discriminator.Equal(CandyMachineDiscriminator[:]) {
			return fmt.Errorf(
				"wrong discriminator: wanted %s, got %s",
				"[51 173 177 113 25 241 109 189]",
				fmt.Sprint(discriminator[:]))
		}
	}
	// Deserialize `Authority`:
	err = decoder.Decode(&obj.Authority)
	if err != nil {
		return err
	}
	// Deserialize `WalletAuthority`:
	err = decoder.Decode(&obj.WalletAuthority)
	if err != nil {
		return err
	}
	// Deserialize `Config`:
	err = decoder.Decode(&obj.Config)
	if err != nil {
		return err
	}
	// Deserialize `ItemsRedeemedNormal`:
	err = decoder.Decode(&obj.ItemsRedeemedNormal)
	if err != nil {
		return err
	}
	// Deserialize `ItemsRedeemedRaffle`:
	err = decoder.Decode(&obj.ItemsRedeemedRaffle)
	if err != nil {
		return err
	}
	// Deserialize `RaffleTicketsPurchased`:
	err = decoder.Decode(&obj.RaffleTicketsPurchased)
	if err != nil {
		return err
	}
	// Deserialize `Uuid`:
	err = decoder.Decode(&obj.Uuid)
	if err != nil {
		return err
	}
	// Deserialize `ItemsAvailable`:
	err = decoder.Decode(&obj.ItemsAvailable)
	if err != nil {
		return err
	}
	// Deserialize `RaffleSeed`:
	err = decoder.Decode(&obj.RaffleSeed)
	if err != nil {
		return err
	}
	// Deserialize `Bump`:
	err = decoder.Decode(&obj.Bump)
	if err != nil {
		return err
	}
	// Deserialize `Notary` (optional):
	{
		ok, err := decoder.ReadBool()
		if err != nil {
			return err
		}
		if ok {
			err = decoder.Decode(&obj.Notary)
			if err != nil {
				return err
			}
		}
	}
	// Deserialize `OrderInfo`:
	err = decoder.Decode(&obj.OrderInfo)
	if err != nil {
		return err
	}
	// Deserialize `IsLite`:
	err = decoder.Decode(&obj.IsLite)
	if err != nil {
		return err
	}
	// Deserialize `NotaryRequired`:
	err = decoder.Decode(&obj.NotaryRequired)
	if err != nil {
		return err
	}
	return nil
}

type WalletLimitInfo struct {
	RedeemedNormal        uint8
	RedeemedRaffleTickets uint8
}

var WalletLimitInfoDiscriminator = [8]byte{46, 250, 5, 143, 39, 123, 104, 115}

func (obj WalletLimitInfo) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Write account discriminator:
	err = encoder.WriteBytes(WalletLimitInfoDiscriminator[:], false)
	if err != nil {
		return err
	}
	// Serialize `RedeemedNormal` param:
	err = encoder.Encode(obj.RedeemedNormal)
	if err != nil {
		return err
	}
	// Serialize `RedeemedRaffleTickets` param:
	err = encoder.Encode(obj.RedeemedRaffleTickets)
	if err != nil {
		return err
	}
	return nil
}

func (obj *WalletLimitInfo) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Read and check account discriminator:
	{
		discriminator, err := decoder.ReadTypeID()
		if err != nil {
			return err
		}
		if !discriminator.Equal(WalletLimitInfoDiscriminator[:]) {
			return fmt.Errorf(
				"wrong discriminator: wanted %s, got %s",
				"[46 250 5 143 39 123 104 115]",
				fmt.Sprint(discriminator[:]))
		}
	}
	// Deserialize `RedeemedNormal`:
	err = decoder.Decode(&obj.RedeemedNormal)
	if err != nil {
		return err
	}
	// Deserialize `RedeemedRaffleTickets`:
	err = decoder.Decode(&obj.RedeemedRaffleTickets)
	if err != nil {
		return err
	}
	return nil
}

type WalletLimitInfoPerStage struct {
	Redeemed [10]RedeemedDuringStage
}

var WalletLimitInfoPerStageDiscriminator = [8]byte{109, 39, 175, 252, 165, 11, 210, 251}

func (obj WalletLimitInfoPerStage) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Write account discriminator:
	err = encoder.WriteBytes(WalletLimitInfoPerStageDiscriminator[:], false)
	if err != nil {
		return err
	}
	// Serialize `Redeemed` param:
	err = encoder.Encode(obj.Redeemed)
	if err != nil {
		return err
	}
	return nil
}

func (obj *WalletLimitInfoPerStage) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Read and check account discriminator:
	{
		discriminator, err := decoder.ReadTypeID()
		if err != nil {
			return err
		}
		if !discriminator.Equal(WalletLimitInfoPerStageDiscriminator[:]) {
			return fmt.Errorf(
				"wrong discriminator: wanted %s, got %s",
				"[109 39 175 252 165 11 210 251]",
				fmt.Sprint(discriminator[:]))
		}
	}
	// Deserialize `Redeemed`:
	err = decoder.Decode(&obj.Redeemed)
	if err != nil {
		return err
	}
	return nil
}

type RaffleTicket struct {
	Ids          []uint32
	CandyMachine ag_solanago.PublicKey
	TicketBump   uint8
	EscrowBump   uint8
	RafflePayer  ag_solanago.PublicKey
}

var RaffleTicketDiscriminator = [8]byte{190, 224, 155, 165, 115, 94, 246, 119}

func (obj RaffleTicket) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Write account discriminator:
	err = encoder.WriteBytes(RaffleTicketDiscriminator[:], false)
	if err != nil {
		return err
	}
	// Serialize `Ids` param:
	err = encoder.Encode(obj.Ids)
	if err != nil {
		return err
	}
	// Serialize `CandyMachine` param:
	err = encoder.Encode(obj.CandyMachine)
	if err != nil {
		return err
	}
	// Serialize `TicketBump` param:
	err = encoder.Encode(obj.TicketBump)
	if err != nil {
		return err
	}
	// Serialize `EscrowBump` param:
	err = encoder.Encode(obj.EscrowBump)
	if err != nil {
		return err
	}
	// Serialize `RafflePayer` param:
	err = encoder.Encode(obj.RafflePayer)
	if err != nil {
		return err
	}
	return nil
}

func (obj *RaffleTicket) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Read and check account discriminator:
	{
		discriminator, err := decoder.ReadTypeID()
		if err != nil {
			return err
		}
		if !discriminator.Equal(RaffleTicketDiscriminator[:]) {
			return fmt.Errorf(
				"wrong discriminator: wanted %s, got %s",
				"[190 224 155 165 115 94 246 119]",
				fmt.Sprint(discriminator[:]))
		}
	}
	// Deserialize `Ids`:
	err = decoder.Decode(&obj.Ids)
	if err != nil {
		return err
	}
	// Deserialize `CandyMachine`:
	err = decoder.Decode(&obj.CandyMachine)
	if err != nil {
		return err
	}
	// Deserialize `TicketBump`:
	err = decoder.Decode(&obj.TicketBump)
	if err != nil {
		return err
	}
	// Deserialize `EscrowBump`:
	err = decoder.Decode(&obj.EscrowBump)
	if err != nil {
		return err
	}
	// Deserialize `RafflePayer`:
	err = decoder.Decode(&obj.RafflePayer)
	if err != nil {
		return err
	}
	return nil
}

type LaunchStagesInfo struct {
	Bump         uint8
	Authority    ag_solanago.PublicKey
	CandyMachine ag_solanago.PublicKey
	Stages       []LaunchStage
}

var LaunchStagesInfoDiscriminator = [8]byte{240, 136, 220, 246, 160, 33, 234, 253}

func (obj LaunchStagesInfo) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Write account discriminator:
	err = encoder.WriteBytes(LaunchStagesInfoDiscriminator[:], false)
	if err != nil {
		return err
	}
	// Serialize `Bump` param:
	err = encoder.Encode(obj.Bump)
	if err != nil {
		return err
	}
	// Serialize `Authority` param:
	err = encoder.Encode(obj.Authority)
	if err != nil {
		return err
	}
	// Serialize `CandyMachine` param:
	err = encoder.Encode(obj.CandyMachine)
	if err != nil {
		return err
	}
	// Serialize `Stages` param:
	err = encoder.Encode(obj.Stages)
	if err != nil {
		return err
	}
	return nil
}

func (obj *LaunchStagesInfo) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Read and check account discriminator:
	{
		discriminator, err := decoder.ReadTypeID()
		if err != nil {
			return err
		}
		if !discriminator.Equal(LaunchStagesInfoDiscriminator[:]) {
			return fmt.Errorf(
				"wrong discriminator: wanted %s, got %s",
				"[240 136 220 246 160 33 234 253]",
				fmt.Sprint(discriminator[:]))
		}
	}
	// Deserialize `Bump`:
	err = decoder.Decode(&obj.Bump)
	if err != nil {
		return err
	}
	// Deserialize `Authority`:
	err = decoder.Decode(&obj.Authority)
	if err != nil {
		return err
	}
	// Deserialize `CandyMachine`:
	err = decoder.Decode(&obj.CandyMachine)
	if err != nil {
		return err
	}
	// Deserialize `Stages`:
	err = decoder.Decode(&obj.Stages)
	if err != nil {
		return err
	}
	return nil
}

type Config struct {
	Authority      ag_solanago.PublicKey
	Gateway        string
	Cid            string
	Uuid           string
	CollectionName string
	Symbol         string

	// Royalty basis points that goes to creators in secondary sales (0-10000)
	SellerFeeBasisPoints uint16
	Creators             []Creator
	IsMutable            bool
	RetainAuthority      bool
}

var ConfigDiscriminator = [8]byte{155, 12, 170, 224, 30, 250, 204, 130}

func (obj Config) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Write account discriminator:
	err = encoder.WriteBytes(ConfigDiscriminator[:], false)
	if err != nil {
		return err
	}
	// Serialize `Authority` param:
	err = encoder.Encode(obj.Authority)
	if err != nil {
		return err
	}
	// Serialize `Gateway` param:
	err = encoder.Encode(obj.Gateway)
	if err != nil {
		return err
	}
	// Serialize `Cid` param:
	err = encoder.Encode(obj.Cid)
	if err != nil {
		return err
	}
	// Serialize `Uuid` param:
	err = encoder.Encode(obj.Uuid)
	if err != nil {
		return err
	}
	// Serialize `CollectionName` param:
	err = encoder.Encode(obj.CollectionName)
	if err != nil {
		return err
	}
	// Serialize `Symbol` param:
	err = encoder.Encode(obj.Symbol)
	if err != nil {
		return err
	}
	// Serialize `SellerFeeBasisPoints` param:
	err = encoder.Encode(obj.SellerFeeBasisPoints)
	if err != nil {
		return err
	}
	// Serialize `Creators` param:
	err = encoder.Encode(obj.Creators)
	if err != nil {
		return err
	}
	// Serialize `IsMutable` param:
	err = encoder.Encode(obj.IsMutable)
	if err != nil {
		return err
	}
	// Serialize `RetainAuthority` param:
	err = encoder.Encode(obj.RetainAuthority)
	if err != nil {
		return err
	}
	return nil
}

func (obj *Config) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Read and check account discriminator:
	{
		discriminator, err := decoder.ReadTypeID()
		if err != nil {
			return err
		}
		if !discriminator.Equal(ConfigDiscriminator[:]) {
			return fmt.Errorf(
				"wrong discriminator: wanted %s, got %s",
				"[155 12 170 224 30 250 204 130]",
				fmt.Sprint(discriminator[:]))
		}
	}
	// Deserialize `Authority`:
	err = decoder.Decode(&obj.Authority)
	if err != nil {
		return err
	}
	// Deserialize `Gateway`:
	err = decoder.Decode(&obj.Gateway)
	if err != nil {
		return err
	}
	// Deserialize `Cid`:
	err = decoder.Decode(&obj.Cid)
	if err != nil {
		return err
	}
	// Deserialize `Uuid`:
	err = decoder.Decode(&obj.Uuid)
	if err != nil {
		return err
	}
	// Deserialize `CollectionName`:
	err = decoder.Decode(&obj.CollectionName)
	if err != nil {
		return err
	}
	// Deserialize `Symbol`:
	err = decoder.Decode(&obj.Symbol)
	if err != nil {
		return err
	}
	// Deserialize `SellerFeeBasisPoints`:
	err = decoder.Decode(&obj.SellerFeeBasisPoints)
	if err != nil {
		return err
	}
	// Deserialize `Creators`:
	err = decoder.Decode(&obj.Creators)
	if err != nil {
		return err
	}
	// Deserialize `IsMutable`:
	err = decoder.Decode(&obj.IsMutable)
	if err != nil {
		return err
	}
	// Deserialize `RetainAuthority`:
	err = decoder.Decode(&obj.RetainAuthority)
	if err != nil {
		return err
	}
	return nil
}

type Order struct {
	Filled       uint32
	CandyMachine ag_solanago.PublicKey
	Indices      [50000]uint32
}

var OrderDiscriminator = [8]byte{134, 173, 223, 185, 77, 86, 28, 51}

func (obj Order) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Write account discriminator:
	err = encoder.WriteBytes(OrderDiscriminator[:], false)
	if err != nil {
		return err
	}
	// Serialize `Filled` param:
	err = encoder.Encode(obj.Filled)
	if err != nil {
		return err
	}
	// Serialize `CandyMachine` param:
	err = encoder.Encode(obj.CandyMachine)
	if err != nil {
		return err
	}
	// Serialize `Indices` param:
	err = encoder.Encode(obj.Indices)
	if err != nil {
		return err
	}
	return nil
}

func (obj *Order) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Read and check account discriminator:
	{
		discriminator, err := decoder.ReadTypeID()
		if err != nil {
			return err
		}
		if !discriminator.Equal(OrderDiscriminator[:]) {
			return fmt.Errorf(
				"wrong discriminator: wanted %s, got %s",
				"[134 173 223 185 77 86 28 51]",
				fmt.Sprint(discriminator[:]))
		}
	}
	// Deserialize `Filled`:
	err = decoder.Decode(&obj.Filled)
	if err != nil {
		return err
	}
	// Deserialize `CandyMachine`:
	err = decoder.Decode(&obj.CandyMachine)
	if err != nil {
		return err
	}
	// Deserialize `Indices`:
	err = decoder.Decode(&obj.Indices)
	if err != nil {
		return err
	}
	return nil
}