github.com/diadata-org/diadata@v1.4.593/pkg/dia/scraper/exchange-scrapers/orca/whirlpool/instructions.go

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

package whirlpool

import (
	"bytes"
	"fmt"
	ag_spew "github.com/davecgh/go-spew/spew"
	ag_binary "github.com/gagliardetto/binary"
	ag_solanago "github.com/gagliardetto/solana-go"
	ag_text "github.com/gagliardetto/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 = "Whirlpool"

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

var (
	Instruction_InitializeConfig = ag_binary.TypeID([8]byte{208, 127, 21, 1, 194, 190, 196, 70})

	Instruction_InitializePool = ag_binary.TypeID([8]byte{95, 180, 10, 172, 84, 174, 232, 40})

	Instruction_InitializeTickArray = ag_binary.TypeID([8]byte{11, 188, 193, 214, 141, 91, 149, 184})

	Instruction_InitializeFeeTier = ag_binary.TypeID([8]byte{183, 74, 156, 160, 112, 2, 42, 30})

	Instruction_InitializeReward = ag_binary.TypeID([8]byte{95, 135, 192, 196, 242, 129, 230, 68})

	Instruction_SetRewardEmissions = ag_binary.TypeID([8]byte{13, 197, 86, 168, 109, 176, 27, 244})

	Instruction_OpenPosition = ag_binary.TypeID([8]byte{135, 128, 47, 77, 15, 152, 240, 49})

	Instruction_OpenPositionWithMetadata = ag_binary.TypeID([8]byte{242, 29, 134, 48, 58, 110, 14, 60})

	Instruction_IncreaseLiquidity = ag_binary.TypeID([8]byte{46, 156, 243, 118, 13, 205, 251, 178})

	Instruction_DecreaseLiquidity = ag_binary.TypeID([8]byte{160, 38, 208, 111, 104, 91, 44, 1})

	Instruction_UpdateFeesAndRewards = ag_binary.TypeID([8]byte{154, 230, 250, 13, 236, 209, 75, 223})

	Instruction_CollectFees = ag_binary.TypeID([8]byte{164, 152, 207, 99, 30, 186, 19, 182})

	Instruction_CollectReward = ag_binary.TypeID([8]byte{70, 5, 132, 87, 86, 235, 177, 34})

	Instruction_CollectProtocolFees = ag_binary.TypeID([8]byte{22, 67, 23, 98, 150, 178, 70, 220})

	Instruction_Swap = ag_binary.TypeID([8]byte{248, 198, 158, 145, 225, 117, 135, 200})

	Instruction_ClosePosition = ag_binary.TypeID([8]byte{123, 134, 81, 0, 49, 68, 98, 98})

	Instruction_SetDefaultFeeRate = ag_binary.TypeID([8]byte{118, 215, 214, 157, 182, 229, 208, 228})

	Instruction_SetDefaultProtocolFeeRate = ag_binary.TypeID([8]byte{107, 205, 249, 226, 151, 35, 86, 0})

	Instruction_SetFeeRate = ag_binary.TypeID([8]byte{53, 243, 137, 65, 8, 140, 158, 6})

	Instruction_SetProtocolFeeRate = ag_binary.TypeID([8]byte{95, 7, 4, 50, 154, 79, 156, 131})

	Instruction_SetFeeAuthority = ag_binary.TypeID([8]byte{31, 1, 50, 87, 237, 101, 97, 132})

	Instruction_SetCollectProtocolFeesAuthority = ag_binary.TypeID([8]byte{34, 150, 93, 244, 139, 225, 233, 67})

	Instruction_SetRewardAuthority = ag_binary.TypeID([8]byte{34, 39, 183, 252, 83, 28, 85, 127})

	Instruction_SetRewardAuthorityBySuperAuthority = ag_binary.TypeID([8]byte{240, 154, 201, 198, 148, 93, 56, 25})

	Instruction_SetRewardEmissionsSuperAuthority = ag_binary.TypeID([8]byte{207, 5, 200, 209, 122, 56, 82, 183})
)

// InstructionIDToName returns the name of the instruction given its ID.
func InstructionIDToName(id ag_binary.TypeID) string {
	switch id {
	case Instruction_InitializeConfig:
		return "InitializeConfig"
	case Instruction_InitializePool:
		return "InitializePool"
	case Instruction_InitializeTickArray:
		return "InitializeTickArray"
	case Instruction_InitializeFeeTier:
		return "InitializeFeeTier"
	case Instruction_InitializeReward:
		return "InitializeReward"
	case Instruction_SetRewardEmissions:
		return "SetRewardEmissions"
	case Instruction_OpenPosition:
		return "OpenPosition"
	case Instruction_OpenPositionWithMetadata:
		return "OpenPositionWithMetadata"
	case Instruction_IncreaseLiquidity:
		return "IncreaseLiquidity"
	case Instruction_DecreaseLiquidity:
		return "DecreaseLiquidity"
	case Instruction_UpdateFeesAndRewards:
		return "UpdateFeesAndRewards"
	case Instruction_CollectFees:
		return "CollectFees"
	case Instruction_CollectReward:
		return "CollectReward"
	case Instruction_CollectProtocolFees:
		return "CollectProtocolFees"
	case Instruction_Swap:
		return "Swap"
	case Instruction_ClosePosition:
		return "ClosePosition"
	case Instruction_SetDefaultFeeRate:
		return "SetDefaultFeeRate"
	case Instruction_SetDefaultProtocolFeeRate:
		return "SetDefaultProtocolFeeRate"
	case Instruction_SetFeeRate:
		return "SetFeeRate"
	case Instruction_SetProtocolFeeRate:
		return "SetProtocolFeeRate"
	case Instruction_SetFeeAuthority:
		return "SetFeeAuthority"
	case Instruction_SetCollectProtocolFeesAuthority:
		return "SetCollectProtocolFeesAuthority"
	case Instruction_SetRewardAuthority:
		return "SetRewardAuthority"
	case Instruction_SetRewardAuthorityBySuperAuthority:
		return "SetRewardAuthorityBySuperAuthority"
	case Instruction_SetRewardEmissionsSuperAuthority:
		return "SetRewardEmissionsSuperAuthority"
	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{
		{
			Name:"initialize_config", Type: (*InitializeConfig)(nil),
		},
		{
			Name:"initialize_pool", Type:(*InitializePool)(nil),
		},
		{
			Name:"initialize_tick_array", Type:(*InitializeTickArray)(nil),
		},
		{
			Name:"initialize_fee_tier", Type:(*InitializeFeeTier)(nil),
		},
		{
			Name:"initialize_reward", Type:(*InitializeReward)(nil),
		},
		{
			Name:"set_reward_emissions", Type:(*SetRewardEmissions)(nil),
		},
		{
			Name:"open_position", Type:(*OpenPosition)(nil),
		},
		{
			Name:"open_position_with_metadata",Type: (*OpenPositionWithMetadata)(nil),
		},
		{
			Name:"increase_liquidity",Type: (*IncreaseLiquidity)(nil),
		},
		{
			Name:"decrease_liquidity", Type:(*DecreaseLiquidity)(nil),
		},
		{
			Name:"update_fees_and_rewards", Type:(*UpdateFeesAndRewards)(nil),
		},
		{
			Name:"collect_fees",Type: (*CollectFees)(nil),
		},
		{
			Name:"collect_reward",Type: (*CollectReward)(nil),
		},
		{
			Name:"collect_protocol_fees", Type:(*CollectProtocolFees)(nil),
		},
		{
			Name:"swap", Type:(*Swap)(nil),
		},
		{
			Name:"close_position", Type:(*ClosePosition)(nil),
		},
		{
			Name:"set_default_fee_rate", Type:(*SetDefaultFeeRate)(nil),
		},
		{
			Name:"set_default_protocol_fee_rate",Type: (*SetDefaultProtocolFeeRate)(nil),
		},
		{
			Name:"set_fee_rate", Type:(*SetFeeRate)(nil),
		},
		{
			Name:"set_protocol_fee_rate", Type:(*SetProtocolFeeRate)(nil),
		},
		{
			Name:"set_fee_authority", Type:(*SetFeeAuthority)(nil),
		},
		{
			Name:"set_collect_protocol_fees_authority",Type: (*SetCollectProtocolFeesAuthority)(nil),
		},
		{
			Name:"set_reward_authority", Type:(*SetRewardAuthority)(nil),
		},
		{
			Name:"set_reward_authority_by_super_authority", Type:(*SetRewardAuthorityBySuperAuthority)(nil),
		},
		{
			Name:"set_reward_emissions_super_authority", Type:(*SetRewardEmissionsSuperAuthority)(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
}