types.go

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

package restaking

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

type BatchWithdrawal struct {
	BatchId                    uint64
	NumWithdrawalRequests      uint64
	ReceiptTokenToProcess      uint64
	ReceiptTokenBeingProcessed uint64
	ReceiptTokenProcessed      uint64
	SolReserved                uint64
	ProcessingStartedAt        *int64 `bin:"optional"`
	Reserved                   [32]uint8
}

func (obj BatchWithdrawal) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `BatchId` param:
	err = encoder.Encode(obj.BatchId)
	if err != nil {
		return err
	}
	// Serialize `NumWithdrawalRequests` param:
	err = encoder.Encode(obj.NumWithdrawalRequests)
	if err != nil {
		return err
	}
	// Serialize `ReceiptTokenToProcess` param:
	err = encoder.Encode(obj.ReceiptTokenToProcess)
	if err != nil {
		return err
	}
	// Serialize `ReceiptTokenBeingProcessed` param:
	err = encoder.Encode(obj.ReceiptTokenBeingProcessed)
	if err != nil {
		return err
	}
	// Serialize `ReceiptTokenProcessed` param:
	err = encoder.Encode(obj.ReceiptTokenProcessed)
	if err != nil {
		return err
	}
	// Serialize `SolReserved` param:
	err = encoder.Encode(obj.SolReserved)
	if err != nil {
		return err
	}
	// Serialize `ProcessingStartedAt` param (optional):
	{
		if obj.ProcessingStartedAt == nil {
			err = encoder.WriteBool(false)
			if err != nil {
				return err
			}
		} else {
			err = encoder.WriteBool(true)
			if err != nil {
				return err
			}
			err = encoder.Encode(obj.ProcessingStartedAt)
			if err != nil {
				return err
			}
		}
	}
	// Serialize `Reserved` param:
	err = encoder.Encode(obj.Reserved)
	if err != nil {
		return err
	}
	return nil
}

func (obj *BatchWithdrawal) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `BatchId`:
	err = decoder.Decode(&obj.BatchId)
	if err != nil {
		return err
	}
	// Deserialize `NumWithdrawalRequests`:
	err = decoder.Decode(&obj.NumWithdrawalRequests)
	if err != nil {
		return err
	}
	// Deserialize `ReceiptTokenToProcess`:
	err = decoder.Decode(&obj.ReceiptTokenToProcess)
	if err != nil {
		return err
	}
	// Deserialize `ReceiptTokenBeingProcessed`:
	err = decoder.Decode(&obj.ReceiptTokenBeingProcessed)
	if err != nil {
		return err
	}
	// Deserialize `ReceiptTokenProcessed`:
	err = decoder.Decode(&obj.ReceiptTokenProcessed)
	if err != nil {
		return err
	}
	// Deserialize `SolReserved`:
	err = decoder.Decode(&obj.SolReserved)
	if err != nil {
		return err
	}
	// Deserialize `ProcessingStartedAt` (optional):
	{
		ok, err := decoder.ReadBool()
		if err != nil {
			return err
		}
		if ok {
			err = decoder.Decode(&obj.ProcessingStartedAt)
			if err != nil {
				return err
			}
		}
	}
	// Deserialize `Reserved`:
	err = decoder.Decode(&obj.Reserved)
	if err != nil {
		return err
	}
	return nil
}

type DepositMetadata struct {
	WalletProvider          string
	ContributionAccrualRate uint8
}

func (obj DepositMetadata) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `WalletProvider` param:
	err = encoder.Encode(obj.WalletProvider)
	if err != nil {
		return err
	}
	// Serialize `ContributionAccrualRate` param:
	err = encoder.Encode(obj.ContributionAccrualRate)
	if err != nil {
		return err
	}
	return nil
}

func (obj *DepositMetadata) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `WalletProvider`:
	err = decoder.Decode(&obj.WalletProvider)
	if err != nil {
		return err
	}
	// Deserialize `ContributionAccrualRate`:
	err = decoder.Decode(&obj.ContributionAccrualRate)
	if err != nil {
		return err
	}
	return nil
}

type FundAccount struct {
	DataVersion                 uint8
	Bump                        uint8
	ReceiptTokenMint            ag_solanago.PublicKey
	SupportedTokens             []SupportedTokenInfo
	SolCapacityAmount           uint64
	SolAccumulatedDepositAmount uint64
	SolOperationReservedAmount  uint64
	WithdrawalStatus            WithdrawalStatus
	Reserved                    [1280]uint8
}

func (obj FundAccount) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `DataVersion` param:
	err = encoder.Encode(obj.DataVersion)
	if err != nil {
		return err
	}
	// Serialize `Bump` param:
	err = encoder.Encode(obj.Bump)
	if err != nil {
		return err
	}
	// Serialize `ReceiptTokenMint` param:
	err = encoder.Encode(obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Serialize `SupportedTokens` param:
	err = encoder.Encode(obj.SupportedTokens)
	if err != nil {
		return err
	}
	// Serialize `SolCapacityAmount` param:
	err = encoder.Encode(obj.SolCapacityAmount)
	if err != nil {
		return err
	}
	// Serialize `SolAccumulatedDepositAmount` param:
	err = encoder.Encode(obj.SolAccumulatedDepositAmount)
	if err != nil {
		return err
	}
	// Serialize `SolOperationReservedAmount` param:
	err = encoder.Encode(obj.SolOperationReservedAmount)
	if err != nil {
		return err
	}
	// Serialize `WithdrawalStatus` param:
	err = encoder.Encode(obj.WithdrawalStatus)
	if err != nil {
		return err
	}
	// Serialize `Reserved` param:
	err = encoder.Encode(obj.Reserved)
	if err != nil {
		return err
	}
	return nil
}

func (obj *FundAccount) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `DataVersion`:
	err = decoder.Decode(&obj.DataVersion)
	if err != nil {
		return err
	}
	// Deserialize `Bump`:
	err = decoder.Decode(&obj.Bump)
	if err != nil {
		return err
	}
	// Deserialize `ReceiptTokenMint`:
	err = decoder.Decode(&obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Deserialize `SupportedTokens`:
	err = decoder.Decode(&obj.SupportedTokens)
	if err != nil {
		return err
	}
	// Deserialize `SolCapacityAmount`:
	err = decoder.Decode(&obj.SolCapacityAmount)
	if err != nil {
		return err
	}
	// Deserialize `SolAccumulatedDepositAmount`:
	err = decoder.Decode(&obj.SolAccumulatedDepositAmount)
	if err != nil {
		return err
	}
	// Deserialize `SolOperationReservedAmount`:
	err = decoder.Decode(&obj.SolOperationReservedAmount)
	if err != nil {
		return err
	}
	// Deserialize `WithdrawalStatus`:
	err = decoder.Decode(&obj.WithdrawalStatus)
	if err != nil {
		return err
	}
	// Deserialize `Reserved`:
	err = decoder.Decode(&obj.Reserved)
	if err != nil {
		return err
	}
	return nil
}

type FundAccountInfo struct {
	ReceiptTokenMint               ag_solanago.PublicKey
	ReceiptTokenPrice              uint64
	ReceiptTokenSupplyAmount       uint64
	SupportedTokens                []SupportedTokenInfo
	SolAccumulatedDepositAmount    uint64
	SolOperationReservedAmount     uint64
	SolWithdrawalReservedAmount    uint64
	SolWithdrawalFeeRate           float32
	WithdrawalEnabled              bool
	WithdrawalLastCompletedBatchId uint64
}

func (obj FundAccountInfo) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `ReceiptTokenMint` param:
	err = encoder.Encode(obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Serialize `ReceiptTokenPrice` param:
	err = encoder.Encode(obj.ReceiptTokenPrice)
	if err != nil {
		return err
	}
	// Serialize `ReceiptTokenSupplyAmount` param:
	err = encoder.Encode(obj.ReceiptTokenSupplyAmount)
	if err != nil {
		return err
	}
	// Serialize `SupportedTokens` param:
	err = encoder.Encode(obj.SupportedTokens)
	if err != nil {
		return err
	}
	// Serialize `SolAccumulatedDepositAmount` param:
	err = encoder.Encode(obj.SolAccumulatedDepositAmount)
	if err != nil {
		return err
	}
	// Serialize `SolOperationReservedAmount` param:
	err = encoder.Encode(obj.SolOperationReservedAmount)
	if err != nil {
		return err
	}
	// Serialize `SolWithdrawalReservedAmount` param:
	err = encoder.Encode(obj.SolWithdrawalReservedAmount)
	if err != nil {
		return err
	}
	// Serialize `SolWithdrawalFeeRate` param:
	err = encoder.Encode(obj.SolWithdrawalFeeRate)
	if err != nil {
		return err
	}
	// Serialize `WithdrawalEnabled` param:
	err = encoder.Encode(obj.WithdrawalEnabled)
	if err != nil {
		return err
	}
	// Serialize `WithdrawalLastCompletedBatchId` param:
	err = encoder.Encode(obj.WithdrawalLastCompletedBatchId)
	if err != nil {
		return err
	}
	return nil
}

func (obj *FundAccountInfo) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `ReceiptTokenMint`:
	err = decoder.Decode(&obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Deserialize `ReceiptTokenPrice`:
	err = decoder.Decode(&obj.ReceiptTokenPrice)
	if err != nil {
		return err
	}
	// Deserialize `ReceiptTokenSupplyAmount`:
	err = decoder.Decode(&obj.ReceiptTokenSupplyAmount)
	if err != nil {
		return err
	}
	// Deserialize `SupportedTokens`:
	err = decoder.Decode(&obj.SupportedTokens)
	if err != nil {
		return err
	}
	// Deserialize `SolAccumulatedDepositAmount`:
	err = decoder.Decode(&obj.SolAccumulatedDepositAmount)
	if err != nil {
		return err
	}
	// Deserialize `SolOperationReservedAmount`:
	err = decoder.Decode(&obj.SolOperationReservedAmount)
	if err != nil {
		return err
	}
	// Deserialize `SolWithdrawalReservedAmount`:
	err = decoder.Decode(&obj.SolWithdrawalReservedAmount)
	if err != nil {
		return err
	}
	// Deserialize `SolWithdrawalFeeRate`:
	err = decoder.Decode(&obj.SolWithdrawalFeeRate)
	if err != nil {
		return err
	}
	// Deserialize `WithdrawalEnabled`:
	err = decoder.Decode(&obj.WithdrawalEnabled)
	if err != nil {
		return err
	}
	// Deserialize `WithdrawalLastCompletedBatchId`:
	err = decoder.Decode(&obj.WithdrawalLastCompletedBatchId)
	if err != nil {
		return err
	}
	return nil
}

type FundManagerUpdatedFund struct {
	ReceiptTokenMint ag_solanago.PublicKey
	FundAccount      FundAccountInfo
}

func (obj FundManagerUpdatedFund) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `ReceiptTokenMint` param:
	err = encoder.Encode(obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Serialize `FundAccount` param:
	err = encoder.Encode(obj.FundAccount)
	if err != nil {
		return err
	}
	return nil
}

func (obj *FundManagerUpdatedFund) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `ReceiptTokenMint`:
	err = decoder.Decode(&obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Deserialize `FundAccount`:
	err = decoder.Decode(&obj.FundAccount)
	if err != nil {
		return err
	}
	return nil
}

type FundManagerUpdatedRewardPool struct {
	RewardAccountDataVersion uint16
	ReceiptTokenMint         ag_solanago.PublicKey
	UpdatedRewardPoolIds     []byte
	Holders                  []HolderInfo
	Rewards                  []RewardInfo
}

func (obj FundManagerUpdatedRewardPool) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `RewardAccountDataVersion` param:
	err = encoder.Encode(obj.RewardAccountDataVersion)
	if err != nil {
		return err
	}
	// Serialize `ReceiptTokenMint` param:
	err = encoder.Encode(obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Serialize `UpdatedRewardPoolIds` param:
	err = encoder.Encode(obj.UpdatedRewardPoolIds)
	if err != nil {
		return err
	}
	// Serialize `Holders` param:
	err = encoder.Encode(obj.Holders)
	if err != nil {
		return err
	}
	// Serialize `Rewards` param:
	err = encoder.Encode(obj.Rewards)
	if err != nil {
		return err
	}
	return nil
}

func (obj *FundManagerUpdatedRewardPool) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `RewardAccountDataVersion`:
	err = decoder.Decode(&obj.RewardAccountDataVersion)
	if err != nil {
		return err
	}
	// Deserialize `ReceiptTokenMint`:
	err = decoder.Decode(&obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Deserialize `UpdatedRewardPoolIds`:
	err = decoder.Decode(&obj.UpdatedRewardPoolIds)
	if err != nil {
		return err
	}
	// Deserialize `Holders`:
	err = decoder.Decode(&obj.Holders)
	if err != nil {
		return err
	}
	// Deserialize `Rewards`:
	err = decoder.Decode(&obj.Rewards)
	if err != nil {
		return err
	}
	return nil
}

type Holder struct {
	// ID is determined by reward account.
	Id          uint8
	Name        [14]uint8
	Description [128]uint8
	NumPubkeys  uint8
	Reserved    [32]uint64

	// List of allowed pubkeys for this holder.
	Pubkeys1 [8]ag_solanago.PublicKey
}

func (obj Holder) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `Id` param:
	err = encoder.Encode(obj.Id)
	if err != nil {
		return err
	}
	// Serialize `Name` param:
	err = encoder.Encode(obj.Name)
	if err != nil {
		return err
	}
	// Serialize `Description` param:
	err = encoder.Encode(obj.Description)
	if err != nil {
		return err
	}
	// Serialize `NumPubkeys` param:
	err = encoder.Encode(obj.NumPubkeys)
	if err != nil {
		return err
	}
	// Serialize `Reserved` param:
	err = encoder.Encode(obj.Reserved)
	if err != nil {
		return err
	}
	// Serialize `Pubkeys1` param:
	err = encoder.Encode(obj.Pubkeys1)
	if err != nil {
		return err
	}
	return nil
}

func (obj *Holder) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `Id`:
	err = decoder.Decode(&obj.Id)
	if err != nil {
		return err
	}
	// Deserialize `Name`:
	err = decoder.Decode(&obj.Name)
	if err != nil {
		return err
	}
	// Deserialize `Description`:
	err = decoder.Decode(&obj.Description)
	if err != nil {
		return err
	}
	// Deserialize `NumPubkeys`:
	err = decoder.Decode(&obj.NumPubkeys)
	if err != nil {
		return err
	}
	// Deserialize `Reserved`:
	err = decoder.Decode(&obj.Reserved)
	if err != nil {
		return err
	}
	// Deserialize `Pubkeys1`:
	err = decoder.Decode(&obj.Pubkeys1)
	if err != nil {
		return err
	}
	return nil
}

type HolderInfo struct {
	Id          uint8
	Name        string
	Description string
	Pubkeys     []ag_solanago.PublicKey
}

func (obj HolderInfo) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `Id` param:
	err = encoder.Encode(obj.Id)
	if err != nil {
		return err
	}
	// Serialize `Name` param:
	err = encoder.Encode(obj.Name)
	if err != nil {
		return err
	}
	// Serialize `Description` param:
	err = encoder.Encode(obj.Description)
	if err != nil {
		return err
	}
	// Serialize `Pubkeys` param:
	err = encoder.Encode(obj.Pubkeys)
	if err != nil {
		return err
	}
	return nil
}

func (obj *HolderInfo) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `Id`:
	err = decoder.Decode(&obj.Id)
	if err != nil {
		return err
	}
	// Deserialize `Name`:
	err = decoder.Decode(&obj.Name)
	if err != nil {
		return err
	}
	// Deserialize `Description`:
	err = decoder.Decode(&obj.Description)
	if err != nil {
		return err
	}
	// Deserialize `Pubkeys`:
	err = decoder.Decode(&obj.Pubkeys)
	if err != nil {
		return err
	}
	return nil
}

type OperatorProcessedJob struct {
	ReceiptTokenMint ag_solanago.PublicKey
	FundAccount      FundAccountInfo
}

func (obj OperatorProcessedJob) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `ReceiptTokenMint` param:
	err = encoder.Encode(obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Serialize `FundAccount` param:
	err = encoder.Encode(obj.FundAccount)
	if err != nil {
		return err
	}
	return nil
}

func (obj *OperatorProcessedJob) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `ReceiptTokenMint`:
	err = decoder.Decode(&obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Deserialize `FundAccount`:
	err = decoder.Decode(&obj.FundAccount)
	if err != nil {
		return err
	}
	return nil
}

type OperatorUpdatedFundPrice struct {
	ReceiptTokenMint ag_solanago.PublicKey
	FundAccount      FundAccountInfo
}

func (obj OperatorUpdatedFundPrice) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `ReceiptTokenMint` param:
	err = encoder.Encode(obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Serialize `FundAccount` param:
	err = encoder.Encode(obj.FundAccount)
	if err != nil {
		return err
	}
	return nil
}

func (obj *OperatorUpdatedFundPrice) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `ReceiptTokenMint`:
	err = decoder.Decode(&obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Deserialize `FundAccount`:
	err = decoder.Decode(&obj.FundAccount)
	if err != nil {
		return err
	}
	return nil
}

type ReceiptTokenLockAuthority struct {
	DataVersion      uint8
	Bump             uint8
	ReceiptTokenMint ag_solanago.PublicKey
}

func (obj ReceiptTokenLockAuthority) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `DataVersion` param:
	err = encoder.Encode(obj.DataVersion)
	if err != nil {
		return err
	}
	// Serialize `Bump` param:
	err = encoder.Encode(obj.Bump)
	if err != nil {
		return err
	}
	// Serialize `ReceiptTokenMint` param:
	err = encoder.Encode(obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	return nil
}

func (obj *ReceiptTokenLockAuthority) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `DataVersion`:
	err = decoder.Decode(&obj.DataVersion)
	if err != nil {
		return err
	}
	// Deserialize `Bump`:
	err = decoder.Decode(&obj.Bump)
	if err != nil {
		return err
	}
	// Deserialize `ReceiptTokenMint`:
	err = decoder.Decode(&obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	return nil
}

type ReceiptTokenMintAuthority struct {
	DataVersion      uint8
	Bump             uint8
	ReceiptTokenMint ag_solanago.PublicKey
}

func (obj ReceiptTokenMintAuthority) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `DataVersion` param:
	err = encoder.Encode(obj.DataVersion)
	if err != nil {
		return err
	}
	// Serialize `Bump` param:
	err = encoder.Encode(obj.Bump)
	if err != nil {
		return err
	}
	// Serialize `ReceiptTokenMint` param:
	err = encoder.Encode(obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	return nil
}

func (obj *ReceiptTokenMintAuthority) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `DataVersion`:
	err = decoder.Decode(&obj.DataVersion)
	if err != nil {
		return err
	}
	// Deserialize `Bump`:
	err = decoder.Decode(&obj.Bump)
	if err != nil {
		return err
	}
	// Deserialize `ReceiptTokenMint`:
	err = decoder.Decode(&obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	return nil
}

type ReservedFund struct {
	NumCompletedWithdrawalRequests uint64
	SolRemaining                   uint64
	TotalReceiptTokenProcessed     ag_binary.Uint128
	TotalSolReserved               ag_binary.Uint128
	Reserved                       [64]uint8
}

func (obj ReservedFund) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `NumCompletedWithdrawalRequests` param:
	err = encoder.Encode(obj.NumCompletedWithdrawalRequests)
	if err != nil {
		return err
	}
	// Serialize `SolRemaining` param:
	err = encoder.Encode(obj.SolRemaining)
	if err != nil {
		return err
	}
	// Serialize `TotalReceiptTokenProcessed` param:
	err = encoder.Encode(obj.TotalReceiptTokenProcessed)
	if err != nil {
		return err
	}
	// Serialize `TotalSolReserved` param:
	err = encoder.Encode(obj.TotalSolReserved)
	if err != nil {
		return err
	}
	// Serialize `Reserved` param:
	err = encoder.Encode(obj.Reserved)
	if err != nil {
		return err
	}
	return nil
}

func (obj *ReservedFund) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `NumCompletedWithdrawalRequests`:
	err = decoder.Decode(&obj.NumCompletedWithdrawalRequests)
	if err != nil {
		return err
	}
	// Deserialize `SolRemaining`:
	err = decoder.Decode(&obj.SolRemaining)
	if err != nil {
		return err
	}
	// Deserialize `TotalReceiptTokenProcessed`:
	err = decoder.Decode(&obj.TotalReceiptTokenProcessed)
	if err != nil {
		return err
	}
	// Deserialize `TotalSolReserved`:
	err = decoder.Decode(&obj.TotalSolReserved)
	if err != nil {
		return err
	}
	// Deserialize `Reserved`:
	err = decoder.Decode(&obj.Reserved)
	if err != nil {
		return err
	}
	return nil
}

type Reward struct {
	// ID is determined by reward account.
	Id                     uint16
	Name                   [14]uint8
	Description            [128]uint8
	RewardTypeDiscriminant uint8
	TokenMint              ag_solanago.PublicKey
	TokenProgram           ag_solanago.PublicKey
	Decimals               uint8
	Padding                [14]uint8
	Reserved               [16]uint64
}

func (obj Reward) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `Id` param:
	err = encoder.Encode(obj.Id)
	if err != nil {
		return err
	}
	// Serialize `Name` param:
	err = encoder.Encode(obj.Name)
	if err != nil {
		return err
	}
	// Serialize `Description` param:
	err = encoder.Encode(obj.Description)
	if err != nil {
		return err
	}
	// Serialize `RewardTypeDiscriminant` param:
	err = encoder.Encode(obj.RewardTypeDiscriminant)
	if err != nil {
		return err
	}
	// Serialize `TokenMint` param:
	err = encoder.Encode(obj.TokenMint)
	if err != nil {
		return err
	}
	// Serialize `TokenProgram` param:
	err = encoder.Encode(obj.TokenProgram)
	if err != nil {
		return err
	}
	// Serialize `Decimals` param:
	err = encoder.Encode(obj.Decimals)
	if err != nil {
		return err
	}
	// Serialize `Padding` param:
	err = encoder.Encode(obj.Padding)
	if err != nil {
		return err
	}
	// Serialize `Reserved` param:
	err = encoder.Encode(obj.Reserved)
	if err != nil {
		return err
	}
	return nil
}

func (obj *Reward) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `Id`:
	err = decoder.Decode(&obj.Id)
	if err != nil {
		return err
	}
	// Deserialize `Name`:
	err = decoder.Decode(&obj.Name)
	if err != nil {
		return err
	}
	// Deserialize `Description`:
	err = decoder.Decode(&obj.Description)
	if err != nil {
		return err
	}
	// Deserialize `RewardTypeDiscriminant`:
	err = decoder.Decode(&obj.RewardTypeDiscriminant)
	if err != nil {
		return err
	}
	// Deserialize `TokenMint`:
	err = decoder.Decode(&obj.TokenMint)
	if err != nil {
		return err
	}
	// Deserialize `TokenProgram`:
	err = decoder.Decode(&obj.TokenProgram)
	if err != nil {
		return err
	}
	// Deserialize `Decimals`:
	err = decoder.Decode(&obj.Decimals)
	if err != nil {
		return err
	}
	// Deserialize `Padding`:
	err = decoder.Decode(&obj.Padding)
	if err != nil {
		return err
	}
	// Deserialize `Reserved`:
	err = decoder.Decode(&obj.Reserved)
	if err != nil {
		return err
	}
	return nil
}

type RewardAccount struct {
	DataVersion      uint16
	Bump             uint8
	ReceiptTokenMint ag_solanago.PublicKey
	MaxHolders       uint8
	MaxRewards       uint16
	MaxRewardPools   uint8
	NumHolders       uint8
	NumRewards       uint16
	NumRewardPools   uint8
	Padding          [5]uint8
	Holders1         [4]Holder
	Rewards1         [16]Reward
	RewardPools1     [4]RewardPool
}

func (obj RewardAccount) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `DataVersion` param:
	err = encoder.Encode(obj.DataVersion)
	if err != nil {
		return err
	}
	// Serialize `Bump` param:
	err = encoder.Encode(obj.Bump)
	if err != nil {
		return err
	}
	// Serialize `ReceiptTokenMint` param:
	err = encoder.Encode(obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Serialize `MaxHolders` param:
	err = encoder.Encode(obj.MaxHolders)
	if err != nil {
		return err
	}
	// Serialize `MaxRewards` param:
	err = encoder.Encode(obj.MaxRewards)
	if err != nil {
		return err
	}
	// Serialize `MaxRewardPools` param:
	err = encoder.Encode(obj.MaxRewardPools)
	if err != nil {
		return err
	}
	// Serialize `NumHolders` param:
	err = encoder.Encode(obj.NumHolders)
	if err != nil {
		return err
	}
	// Serialize `NumRewards` param:
	err = encoder.Encode(obj.NumRewards)
	if err != nil {
		return err
	}
	// Serialize `NumRewardPools` param:
	err = encoder.Encode(obj.NumRewardPools)
	if err != nil {
		return err
	}
	// Serialize `Padding` param:
	err = encoder.Encode(obj.Padding)
	if err != nil {
		return err
	}
	// Serialize `Holders1` param:
	err = encoder.Encode(obj.Holders1)
	if err != nil {
		return err
	}
	// Serialize `Rewards1` param:
	err = encoder.Encode(obj.Rewards1)
	if err != nil {
		return err
	}
	// Serialize `RewardPools1` param:
	err = encoder.Encode(obj.RewardPools1)
	if err != nil {
		return err
	}
	return nil
}

func (obj *RewardAccount) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `DataVersion`:
	err = decoder.Decode(&obj.DataVersion)
	if err != nil {
		return err
	}
	// Deserialize `Bump`:
	err = decoder.Decode(&obj.Bump)
	if err != nil {
		return err
	}
	// Deserialize `ReceiptTokenMint`:
	err = decoder.Decode(&obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Deserialize `MaxHolders`:
	err = decoder.Decode(&obj.MaxHolders)
	if err != nil {
		return err
	}
	// Deserialize `MaxRewards`:
	err = decoder.Decode(&obj.MaxRewards)
	if err != nil {
		return err
	}
	// Deserialize `MaxRewardPools`:
	err = decoder.Decode(&obj.MaxRewardPools)
	if err != nil {
		return err
	}
	// Deserialize `NumHolders`:
	err = decoder.Decode(&obj.NumHolders)
	if err != nil {
		return err
	}
	// Deserialize `NumRewards`:
	err = decoder.Decode(&obj.NumRewards)
	if err != nil {
		return err
	}
	// Deserialize `NumRewardPools`:
	err = decoder.Decode(&obj.NumRewardPools)
	if err != nil {
		return err
	}
	// Deserialize `Padding`:
	err = decoder.Decode(&obj.Padding)
	if err != nil {
		return err
	}
	// Deserialize `Holders1`:
	err = decoder.Decode(&obj.Holders1)
	if err != nil {
		return err
	}
	// Deserialize `Rewards1`:
	err = decoder.Decode(&obj.Rewards1)
	if err != nil {
		return err
	}
	// Deserialize `RewardPools1`:
	err = decoder.Decode(&obj.RewardPools1)
	if err != nil {
		return err
	}
	return nil
}

type RewardInfo struct {
	Id          uint16
	Name        string
	Description string
	RewardType  RewardType
}

func (obj RewardInfo) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `Id` param:
	err = encoder.Encode(obj.Id)
	if err != nil {
		return err
	}
	// Serialize `Name` param:
	err = encoder.Encode(obj.Name)
	if err != nil {
		return err
	}
	// Serialize `Description` param:
	err = encoder.Encode(obj.Description)
	if err != nil {
		return err
	}
	// Serialize `RewardType` param:
	{
		tmp := rewardTypeContainer{}
		switch realvalue := obj.RewardType.(type) {
		case *RewardTypePointTuple:
			tmp.Enum = 0
			tmp.Point = *realvalue
		case *RewardTypeTokenTuple:
			tmp.Enum = 1
			tmp.Token = *realvalue
		case *RewardTypeSOLTuple:
			tmp.Enum = 2
			tmp.SOL = *realvalue
		}
		err := encoder.Encode(tmp)
		if err != nil {
			return err
		}
	}
	return nil
}

func (obj *RewardInfo) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `Id`:
	err = decoder.Decode(&obj.Id)
	if err != nil {
		return err
	}
	// Deserialize `Name`:
	err = decoder.Decode(&obj.Name)
	if err != nil {
		return err
	}
	// Deserialize `Description`:
	err = decoder.Decode(&obj.Description)
	if err != nil {
		return err
	}
	// Deserialize `RewardType`:
	{
		tmp := new(rewardTypeContainer)
		err := decoder.Decode(tmp)
		if err != nil {
			return err
		}
		switch tmp.Enum {
		case 0:
			obj.RewardType = &tmp.Point
		case 1:
			obj.RewardType = &tmp.Token
		case 2:
			obj.RewardType = (*RewardTypeSOLTuple)(&tmp.Enum)
		default:
			return fmt.Errorf("unknown enum index: %v", tmp.Enum)
		}
	}
	return nil
}

type RewardPool struct {
	// ID is determined by reward account.
	Id                   uint8
	Name                 [14]uint8
	RewardPoolBitmap     uint8
	TokenAllocatedAmount TokenAllocatedAmount
	Contribution         ag_binary.Uint128
	InitialSlot          uint64
	UpdatedSlot          uint64
	ClosedSlot           uint64
	HolderId             uint8
	NumRewardSettlements uint8
	Padding              [6]uint8
	Reserved             [32]uint64
	RewardSettlements1   [16]RewardSettlement
}

func (obj RewardPool) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `Id` param:
	err = encoder.Encode(obj.Id)
	if err != nil {
		return err
	}
	// Serialize `Name` param:
	err = encoder.Encode(obj.Name)
	if err != nil {
		return err
	}
	// Serialize `RewardPoolBitmap` param:
	err = encoder.Encode(obj.RewardPoolBitmap)
	if err != nil {
		return err
	}
	// Serialize `TokenAllocatedAmount` param:
	err = encoder.Encode(obj.TokenAllocatedAmount)
	if err != nil {
		return err
	}
	// Serialize `Contribution` param:
	err = encoder.Encode(obj.Contribution)
	if err != nil {
		return err
	}
	// Serialize `InitialSlot` param:
	err = encoder.Encode(obj.InitialSlot)
	if err != nil {
		return err
	}
	// Serialize `UpdatedSlot` param:
	err = encoder.Encode(obj.UpdatedSlot)
	if err != nil {
		return err
	}
	// Serialize `ClosedSlot` param:
	err = encoder.Encode(obj.ClosedSlot)
	if err != nil {
		return err
	}
	// Serialize `HolderId` param:
	err = encoder.Encode(obj.HolderId)
	if err != nil {
		return err
	}
	// Serialize `NumRewardSettlements` param:
	err = encoder.Encode(obj.NumRewardSettlements)
	if err != nil {
		return err
	}
	// Serialize `Padding` param:
	err = encoder.Encode(obj.Padding)
	if err != nil {
		return err
	}
	// Serialize `Reserved` param:
	err = encoder.Encode(obj.Reserved)
	if err != nil {
		return err
	}
	// Serialize `RewardSettlements1` param:
	err = encoder.Encode(obj.RewardSettlements1)
	if err != nil {
		return err
	}
	return nil
}

func (obj *RewardPool) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `Id`:
	err = decoder.Decode(&obj.Id)
	if err != nil {
		return err
	}
	// Deserialize `Name`:
	err = decoder.Decode(&obj.Name)
	if err != nil {
		return err
	}
	// Deserialize `RewardPoolBitmap`:
	err = decoder.Decode(&obj.RewardPoolBitmap)
	if err != nil {
		return err
	}
	// Deserialize `TokenAllocatedAmount`:
	err = decoder.Decode(&obj.TokenAllocatedAmount)
	if err != nil {
		return err
	}
	// Deserialize `Contribution`:
	err = decoder.Decode(&obj.Contribution)
	if err != nil {
		return err
	}
	// Deserialize `InitialSlot`:
	err = decoder.Decode(&obj.InitialSlot)
	if err != nil {
		return err
	}
	// Deserialize `UpdatedSlot`:
	err = decoder.Decode(&obj.UpdatedSlot)
	if err != nil {
		return err
	}
	// Deserialize `ClosedSlot`:
	err = decoder.Decode(&obj.ClosedSlot)
	if err != nil {
		return err
	}
	// Deserialize `HolderId`:
	err = decoder.Decode(&obj.HolderId)
	if err != nil {
		return err
	}
	// Deserialize `NumRewardSettlements`:
	err = decoder.Decode(&obj.NumRewardSettlements)
	if err != nil {
		return err
	}
	// Deserialize `Padding`:
	err = decoder.Decode(&obj.Padding)
	if err != nil {
		return err
	}
	// Deserialize `Reserved`:
	err = decoder.Decode(&obj.Reserved)
	if err != nil {
		return err
	}
	// Deserialize `RewardSettlements1`:
	err = decoder.Decode(&obj.RewardSettlements1)
	if err != nil {
		return err
	}
	return nil
}

type RewardSettlement struct {
	RewardId             uint16
	RewardPoolId         uint8
	NumSettlementBlocks  uint8
	SettlementBlocksHead uint8
	SettlementBlocksTail uint8
	Padding              [2]uint8

	// Leftovers from each settlement block when clearing
	RemainingAmount                            uint64
	ClaimedAmount                              uint64
	ClaimedAmountUpdatedSlot                   uint64
	SettledAmount                              uint64
	SettlementBlocksLastSlot                   uint64
	SettlementBlocksLastRewardPoolContribution ag_binary.Uint128
	SettlementBlocks                           [64]RewardSettlementBlock
}

func (obj RewardSettlement) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `RewardId` param:
	err = encoder.Encode(obj.RewardId)
	if err != nil {
		return err
	}
	// Serialize `RewardPoolId` param:
	err = encoder.Encode(obj.RewardPoolId)
	if err != nil {
		return err
	}
	// Serialize `NumSettlementBlocks` param:
	err = encoder.Encode(obj.NumSettlementBlocks)
	if err != nil {
		return err
	}
	// Serialize `SettlementBlocksHead` param:
	err = encoder.Encode(obj.SettlementBlocksHead)
	if err != nil {
		return err
	}
	// Serialize `SettlementBlocksTail` param:
	err = encoder.Encode(obj.SettlementBlocksTail)
	if err != nil {
		return err
	}
	// Serialize `Padding` param:
	err = encoder.Encode(obj.Padding)
	if err != nil {
		return err
	}
	// Serialize `RemainingAmount` param:
	err = encoder.Encode(obj.RemainingAmount)
	if err != nil {
		return err
	}
	// Serialize `ClaimedAmount` param:
	err = encoder.Encode(obj.ClaimedAmount)
	if err != nil {
		return err
	}
	// Serialize `ClaimedAmountUpdatedSlot` param:
	err = encoder.Encode(obj.ClaimedAmountUpdatedSlot)
	if err != nil {
		return err
	}
	// Serialize `SettledAmount` param:
	err = encoder.Encode(obj.SettledAmount)
	if err != nil {
		return err
	}
	// Serialize `SettlementBlocksLastSlot` param:
	err = encoder.Encode(obj.SettlementBlocksLastSlot)
	if err != nil {
		return err
	}
	// Serialize `SettlementBlocksLastRewardPoolContribution` param:
	err = encoder.Encode(obj.SettlementBlocksLastRewardPoolContribution)
	if err != nil {
		return err
	}
	// Serialize `SettlementBlocks` param:
	err = encoder.Encode(obj.SettlementBlocks)
	if err != nil {
		return err
	}
	return nil
}

func (obj *RewardSettlement) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `RewardId`:
	err = decoder.Decode(&obj.RewardId)
	if err != nil {
		return err
	}
	// Deserialize `RewardPoolId`:
	err = decoder.Decode(&obj.RewardPoolId)
	if err != nil {
		return err
	}
	// Deserialize `NumSettlementBlocks`:
	err = decoder.Decode(&obj.NumSettlementBlocks)
	if err != nil {
		return err
	}
	// Deserialize `SettlementBlocksHead`:
	err = decoder.Decode(&obj.SettlementBlocksHead)
	if err != nil {
		return err
	}
	// Deserialize `SettlementBlocksTail`:
	err = decoder.Decode(&obj.SettlementBlocksTail)
	if err != nil {
		return err
	}
	// Deserialize `Padding`:
	err = decoder.Decode(&obj.Padding)
	if err != nil {
		return err
	}
	// Deserialize `RemainingAmount`:
	err = decoder.Decode(&obj.RemainingAmount)
	if err != nil {
		return err
	}
	// Deserialize `ClaimedAmount`:
	err = decoder.Decode(&obj.ClaimedAmount)
	if err != nil {
		return err
	}
	// Deserialize `ClaimedAmountUpdatedSlot`:
	err = decoder.Decode(&obj.ClaimedAmountUpdatedSlot)
	if err != nil {
		return err
	}
	// Deserialize `SettledAmount`:
	err = decoder.Decode(&obj.SettledAmount)
	if err != nil {
		return err
	}
	// Deserialize `SettlementBlocksLastSlot`:
	err = decoder.Decode(&obj.SettlementBlocksLastSlot)
	if err != nil {
		return err
	}
	// Deserialize `SettlementBlocksLastRewardPoolContribution`:
	err = decoder.Decode(&obj.SettlementBlocksLastRewardPoolContribution)
	if err != nil {
		return err
	}
	// Deserialize `SettlementBlocks`:
	err = decoder.Decode(&obj.SettlementBlocks)
	if err != nil {
		return err
	}
	return nil
}

type RewardSettlementBlock struct {
	Amount                         uint64
	StartingSlot                   uint64
	StartingRewardPoolContribution ag_binary.Uint128
	EndingRewardPoolContribution   ag_binary.Uint128
	EndingSlot                     uint64
	UserSettledAmount              uint64
	UserSettledContribution        ag_binary.Uint128
}

func (obj RewardSettlementBlock) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `Amount` param:
	err = encoder.Encode(obj.Amount)
	if err != nil {
		return err
	}
	// Serialize `StartingSlot` param:
	err = encoder.Encode(obj.StartingSlot)
	if err != nil {
		return err
	}
	// Serialize `StartingRewardPoolContribution` param:
	err = encoder.Encode(obj.StartingRewardPoolContribution)
	if err != nil {
		return err
	}
	// Serialize `EndingRewardPoolContribution` param:
	err = encoder.Encode(obj.EndingRewardPoolContribution)
	if err != nil {
		return err
	}
	// Serialize `EndingSlot` param:
	err = encoder.Encode(obj.EndingSlot)
	if err != nil {
		return err
	}
	// Serialize `UserSettledAmount` param:
	err = encoder.Encode(obj.UserSettledAmount)
	if err != nil {
		return err
	}
	// Serialize `UserSettledContribution` param:
	err = encoder.Encode(obj.UserSettledContribution)
	if err != nil {
		return err
	}
	return nil
}

func (obj *RewardSettlementBlock) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `Amount`:
	err = decoder.Decode(&obj.Amount)
	if err != nil {
		return err
	}
	// Deserialize `StartingSlot`:
	err = decoder.Decode(&obj.StartingSlot)
	if err != nil {
		return err
	}
	// Deserialize `StartingRewardPoolContribution`:
	err = decoder.Decode(&obj.StartingRewardPoolContribution)
	if err != nil {
		return err
	}
	// Deserialize `EndingRewardPoolContribution`:
	err = decoder.Decode(&obj.EndingRewardPoolContribution)
	if err != nil {
		return err
	}
	// Deserialize `EndingSlot`:
	err = decoder.Decode(&obj.EndingSlot)
	if err != nil {
		return err
	}
	// Deserialize `UserSettledAmount`:
	err = decoder.Decode(&obj.UserSettledAmount)
	if err != nil {
		return err
	}
	// Deserialize `UserSettledContribution`:
	err = decoder.Decode(&obj.UserSettledContribution)
	if err != nil {
		return err
	}
	return nil
}

type RewardType interface {
	isRewardType()
}

type rewardTypeContainer struct {
	Enum  ag_binary.BorshEnum `borsh_enum:"true"`
	Point RewardTypePointTuple
	Token RewardTypeTokenTuple
	SOL   RewardTypeSOLTuple
}

type RewardTypePointTuple struct {
	Decimals uint8
}

func (obj RewardTypePointTuple) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `Decimals` param:
	err = encoder.Encode(obj.Decimals)
	if err != nil {
		return err
	}
	return nil
}

func (obj *RewardTypePointTuple) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `Decimals`:
	err = decoder.Decode(&obj.Decimals)
	if err != nil {
		return err
	}
	return nil
}

func (_ RewardTypePointTuple) isRewardType() {}

type RewardTypeTokenTuple struct {
	Mint     ag_solanago.PublicKey
	Program  ag_solanago.PublicKey
	Decimals uint8
}

func (obj RewardTypeTokenTuple) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `Mint` param:
	err = encoder.Encode(obj.Mint)
	if err != nil {
		return err
	}
	// Serialize `Program` param:
	err = encoder.Encode(obj.Program)
	if err != nil {
		return err
	}
	// Serialize `Decimals` param:
	err = encoder.Encode(obj.Decimals)
	if err != nil {
		return err
	}
	return nil
}

func (obj *RewardTypeTokenTuple) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `Mint`:
	err = decoder.Decode(&obj.Mint)
	if err != nil {
		return err
	}
	// Deserialize `Program`:
	err = decoder.Decode(&obj.Program)
	if err != nil {
		return err
	}
	// Deserialize `Decimals`:
	err = decoder.Decode(&obj.Decimals)
	if err != nil {
		return err
	}
	return nil
}

func (_ RewardTypeTokenTuple) isRewardType() {}

type RewardTypeSOLTuple uint8

func (obj RewardTypeSOLTuple) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	return nil
}

func (obj *RewardTypeSOLTuple) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	return nil
}

func (_ RewardTypeSOLTuple) isRewardType() {}

type SupportedTokenAuthority struct {
	DataVersion        uint8
	Bump               uint8
	ReceiptTokenMint   ag_solanago.PublicKey
	SupportedTokenMint ag_solanago.PublicKey
}

func (obj SupportedTokenAuthority) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `DataVersion` param:
	err = encoder.Encode(obj.DataVersion)
	if err != nil {
		return err
	}
	// Serialize `Bump` param:
	err = encoder.Encode(obj.Bump)
	if err != nil {
		return err
	}
	// Serialize `ReceiptTokenMint` param:
	err = encoder.Encode(obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Serialize `SupportedTokenMint` param:
	err = encoder.Encode(obj.SupportedTokenMint)
	if err != nil {
		return err
	}
	return nil
}

func (obj *SupportedTokenAuthority) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `DataVersion`:
	err = decoder.Decode(&obj.DataVersion)
	if err != nil {
		return err
	}
	// Deserialize `Bump`:
	err = decoder.Decode(&obj.Bump)
	if err != nil {
		return err
	}
	// Deserialize `ReceiptTokenMint`:
	err = decoder.Decode(&obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Deserialize `SupportedTokenMint`:
	err = decoder.Decode(&obj.SupportedTokenMint)
	if err != nil {
		return err
	}
	return nil
}

type SupportedTokenInfo struct {
	Mint                     ag_solanago.PublicKey
	Program                  ag_solanago.PublicKey
	Decimals                 uint8
	CapacityAmount           uint64
	AccumulatedDepositAmount uint64
	OperationReservedAmount  uint64
	Price                    uint64
	PricingSource            TokenPricingSource
	Reserved                 [128]uint8
}

func (obj SupportedTokenInfo) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `Mint` param:
	err = encoder.Encode(obj.Mint)
	if err != nil {
		return err
	}
	// Serialize `Program` param:
	err = encoder.Encode(obj.Program)
	if err != nil {
		return err
	}
	// Serialize `Decimals` param:
	err = encoder.Encode(obj.Decimals)
	if err != nil {
		return err
	}
	// Serialize `CapacityAmount` param:
	err = encoder.Encode(obj.CapacityAmount)
	if err != nil {
		return err
	}
	// Serialize `AccumulatedDepositAmount` param:
	err = encoder.Encode(obj.AccumulatedDepositAmount)
	if err != nil {
		return err
	}
	// Serialize `OperationReservedAmount` param:
	err = encoder.Encode(obj.OperationReservedAmount)
	if err != nil {
		return err
	}
	// Serialize `Price` param:
	err = encoder.Encode(obj.Price)
	if err != nil {
		return err
	}
	// Serialize `PricingSource` param:
	{
		tmp := tokenPricingSourceContainer{}
		switch realvalue := obj.PricingSource.(type) {
		case *TokenPricingSourceSPLStakePoolTuple:
			tmp.Enum = 0
			tmp.SPLStakePool = *realvalue
		case *TokenPricingSourceMarinadeStakePoolTuple:
			tmp.Enum = 1
			tmp.MarinadeStakePool = *realvalue
		}
		err := encoder.Encode(tmp)
		if err != nil {
			return err
		}
	}
	// Serialize `Reserved` param:
	err = encoder.Encode(obj.Reserved)
	if err != nil {
		return err
	}
	return nil
}

func (obj *SupportedTokenInfo) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `Mint`:
	err = decoder.Decode(&obj.Mint)
	if err != nil {
		return err
	}
	// Deserialize `Program`:
	err = decoder.Decode(&obj.Program)
	if err != nil {
		return err
	}
	// Deserialize `Decimals`:
	err = decoder.Decode(&obj.Decimals)
	if err != nil {
		return err
	}
	// Deserialize `CapacityAmount`:
	err = decoder.Decode(&obj.CapacityAmount)
	if err != nil {
		return err
	}
	// Deserialize `AccumulatedDepositAmount`:
	err = decoder.Decode(&obj.AccumulatedDepositAmount)
	if err != nil {
		return err
	}
	// Deserialize `OperationReservedAmount`:
	err = decoder.Decode(&obj.OperationReservedAmount)
	if err != nil {
		return err
	}
	// Deserialize `Price`:
	err = decoder.Decode(&obj.Price)
	if err != nil {
		return err
	}
	// Deserialize `PricingSource`:
	{
		tmp := new(tokenPricingSourceContainer)
		err := decoder.Decode(tmp)
		if err != nil {
			return err
		}
		switch tmp.Enum {
		case 0:
			obj.PricingSource = &tmp.SPLStakePool
		case 1:
			obj.PricingSource = &tmp.MarinadeStakePool
		default:
			return fmt.Errorf("unknown enum index: %v", tmp.Enum)
		}
	}
	// Deserialize `Reserved`:
	err = decoder.Decode(&obj.Reserved)
	if err != nil {
		return err
	}
	return nil
}

type TokenAllocatedAmount struct {
	TotalAmount uint64
	NumRecords  uint8
	Padding     [7]uint8
	Records     [10]TokenAllocatedAmountRecord
}

func (obj TokenAllocatedAmount) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `TotalAmount` param:
	err = encoder.Encode(obj.TotalAmount)
	if err != nil {
		return err
	}
	// Serialize `NumRecords` param:
	err = encoder.Encode(obj.NumRecords)
	if err != nil {
		return err
	}
	// Serialize `Padding` param:
	err = encoder.Encode(obj.Padding)
	if err != nil {
		return err
	}
	// Serialize `Records` param:
	err = encoder.Encode(obj.Records)
	if err != nil {
		return err
	}
	return nil
}

func (obj *TokenAllocatedAmount) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `TotalAmount`:
	err = decoder.Decode(&obj.TotalAmount)
	if err != nil {
		return err
	}
	// Deserialize `NumRecords`:
	err = decoder.Decode(&obj.NumRecords)
	if err != nil {
		return err
	}
	// Deserialize `Padding`:
	err = decoder.Decode(&obj.Padding)
	if err != nil {
		return err
	}
	// Deserialize `Records`:
	err = decoder.Decode(&obj.Records)
	if err != nil {
		return err
	}
	return nil
}

type TokenAllocatedAmountRecord struct {
	Amount uint64

	// Contribution accrual rate per 1 lamports (decimals = 2)
	// e.g., rate = 135 => actual rate = 1.35
	ContributionAccrualRate uint8
	Padding                 [7]uint8
}

func (obj TokenAllocatedAmountRecord) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `Amount` param:
	err = encoder.Encode(obj.Amount)
	if err != nil {
		return err
	}
	// Serialize `ContributionAccrualRate` param:
	err = encoder.Encode(obj.ContributionAccrualRate)
	if err != nil {
		return err
	}
	// Serialize `Padding` param:
	err = encoder.Encode(obj.Padding)
	if err != nil {
		return err
	}
	return nil
}

func (obj *TokenAllocatedAmountRecord) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `Amount`:
	err = decoder.Decode(&obj.Amount)
	if err != nil {
		return err
	}
	// Deserialize `ContributionAccrualRate`:
	err = decoder.Decode(&obj.ContributionAccrualRate)
	if err != nil {
		return err
	}
	// Deserialize `Padding`:
	err = decoder.Decode(&obj.Padding)
	if err != nil {
		return err
	}
	return nil
}

type TokenPricingSource interface {
	isTokenPricingSource()
}

type tokenPricingSourceContainer struct {
	Enum              ag_binary.BorshEnum `borsh_enum:"true"`
	SPLStakePool      TokenPricingSourceSPLStakePoolTuple
	MarinadeStakePool TokenPricingSourceMarinadeStakePoolTuple
}

type TokenPricingSourceSPLStakePoolTuple struct {
	Address ag_solanago.PublicKey
}

func (obj TokenPricingSourceSPLStakePoolTuple) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `Address` param:
	err = encoder.Encode(obj.Address)
	if err != nil {
		return err
	}
	return nil
}

func (obj *TokenPricingSourceSPLStakePoolTuple) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `Address`:
	err = decoder.Decode(&obj.Address)
	if err != nil {
		return err
	}
	return nil
}

func (_ TokenPricingSourceSPLStakePoolTuple) isTokenPricingSource() {}

type TokenPricingSourceMarinadeStakePoolTuple struct {
	Address ag_solanago.PublicKey
}

func (obj TokenPricingSourceMarinadeStakePoolTuple) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `Address` param:
	err = encoder.Encode(obj.Address)
	if err != nil {
		return err
	}
	return nil
}

func (obj *TokenPricingSourceMarinadeStakePoolTuple) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `Address`:
	err = decoder.Decode(&obj.Address)
	if err != nil {
		return err
	}
	return nil
}

func (_ TokenPricingSourceMarinadeStakePoolTuple) isTokenPricingSource() {}

type UserCanceledWithdrawalRequestFromFund struct {
	ReceiptTokenMint            ag_solanago.PublicKey
	RequestId                   uint64
	User                        ag_solanago.PublicKey
	UserReceiptTokenAccount     ag_solanago.PublicKey
	UserFundAccount             UserFundAccount
	RequestedReceiptTokenAmount uint64
}

func (obj UserCanceledWithdrawalRequestFromFund) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `ReceiptTokenMint` param:
	err = encoder.Encode(obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Serialize `RequestId` param:
	err = encoder.Encode(obj.RequestId)
	if err != nil {
		return err
	}
	// Serialize `User` param:
	err = encoder.Encode(obj.User)
	if err != nil {
		return err
	}
	// Serialize `UserReceiptTokenAccount` param:
	err = encoder.Encode(obj.UserReceiptTokenAccount)
	if err != nil {
		return err
	}
	// Serialize `UserFundAccount` param:
	err = encoder.Encode(obj.UserFundAccount)
	if err != nil {
		return err
	}
	// Serialize `RequestedReceiptTokenAmount` param:
	err = encoder.Encode(obj.RequestedReceiptTokenAmount)
	if err != nil {
		return err
	}
	return nil
}

func (obj *UserCanceledWithdrawalRequestFromFund) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `ReceiptTokenMint`:
	err = decoder.Decode(&obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Deserialize `RequestId`:
	err = decoder.Decode(&obj.RequestId)
	if err != nil {
		return err
	}
	// Deserialize `User`:
	err = decoder.Decode(&obj.User)
	if err != nil {
		return err
	}
	// Deserialize `UserReceiptTokenAccount`:
	err = decoder.Decode(&obj.UserReceiptTokenAccount)
	if err != nil {
		return err
	}
	// Deserialize `UserFundAccount`:
	err = decoder.Decode(&obj.UserFundAccount)
	if err != nil {
		return err
	}
	// Deserialize `RequestedReceiptTokenAmount`:
	err = decoder.Decode(&obj.RequestedReceiptTokenAmount)
	if err != nil {
		return err
	}
	return nil
}

type UserDepositedSOLToFund struct {
	ReceiptTokenMint         ag_solanago.PublicKey
	FundAccount              FundAccountInfo
	User                     ag_solanago.PublicKey
	UserReceiptTokenAccount  ag_solanago.PublicKey
	UserFundAccount          UserFundAccount
	WalletProvider           *string `bin:"optional"`
	ContributionAccrualRate  *uint8  `bin:"optional"`
	DepositedSolAmount       uint64
	MintedReceiptTokenAmount uint64
}

func (obj UserDepositedSOLToFund) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `ReceiptTokenMint` param:
	err = encoder.Encode(obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Serialize `FundAccount` param:
	err = encoder.Encode(obj.FundAccount)
	if err != nil {
		return err
	}
	// Serialize `User` param:
	err = encoder.Encode(obj.User)
	if err != nil {
		return err
	}
	// Serialize `UserReceiptTokenAccount` param:
	err = encoder.Encode(obj.UserReceiptTokenAccount)
	if err != nil {
		return err
	}
	// Serialize `UserFundAccount` param:
	err = encoder.Encode(obj.UserFundAccount)
	if err != nil {
		return err
	}
	// Serialize `WalletProvider` param (optional):
	{
		if obj.WalletProvider == nil {
			err = encoder.WriteBool(false)
			if err != nil {
				return err
			}
		} else {
			err = encoder.WriteBool(true)
			if err != nil {
				return err
			}
			err = encoder.Encode(obj.WalletProvider)
			if err != nil {
				return err
			}
		}
	}
	// Serialize `ContributionAccrualRate` param (optional):
	{
		if obj.ContributionAccrualRate == nil {
			err = encoder.WriteBool(false)
			if err != nil {
				return err
			}
		} else {
			err = encoder.WriteBool(true)
			if err != nil {
				return err
			}
			err = encoder.Encode(obj.ContributionAccrualRate)
			if err != nil {
				return err
			}
		}
	}
	// Serialize `DepositedSolAmount` param:
	err = encoder.Encode(obj.DepositedSolAmount)
	if err != nil {
		return err
	}
	// Serialize `MintedReceiptTokenAmount` param:
	err = encoder.Encode(obj.MintedReceiptTokenAmount)
	if err != nil {
		return err
	}
	return nil
}

func (obj *UserDepositedSOLToFund) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `ReceiptTokenMint`:
	err = decoder.Decode(&obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Deserialize `FundAccount`:
	err = decoder.Decode(&obj.FundAccount)
	if err != nil {
		return err
	}
	// Deserialize `User`:
	err = decoder.Decode(&obj.User)
	if err != nil {
		return err
	}
	// Deserialize `UserReceiptTokenAccount`:
	err = decoder.Decode(&obj.UserReceiptTokenAccount)
	if err != nil {
		return err
	}
	// Deserialize `UserFundAccount`:
	err = decoder.Decode(&obj.UserFundAccount)
	if err != nil {
		return err
	}
	// Deserialize `WalletProvider` (optional):
	{
		ok, err := decoder.ReadBool()
		if err != nil {
			return err
		}
		if ok {
			err = decoder.Decode(&obj.WalletProvider)
			if err != nil {
				return err
			}
		}
	}
	// Deserialize `ContributionAccrualRate` (optional):
	{
		ok, err := decoder.ReadBool()
		if err != nil {
			return err
		}
		if ok {
			err = decoder.Decode(&obj.ContributionAccrualRate)
			if err != nil {
				return err
			}
		}
	}
	// Deserialize `DepositedSolAmount`:
	err = decoder.Decode(&obj.DepositedSolAmount)
	if err != nil {
		return err
	}
	// Deserialize `MintedReceiptTokenAmount`:
	err = decoder.Decode(&obj.MintedReceiptTokenAmount)
	if err != nil {
		return err
	}
	return nil
}

type UserDepositedSupportedTokenToFund struct {
	ReceiptTokenMint              ag_solanago.PublicKey
	FundAccount                   FundAccountInfo
	User                          ag_solanago.PublicKey
	UserReceiptTokenAccount       ag_solanago.PublicKey
	UserFundAccount               UserFundAccount
	SupportedTokenMint            ag_solanago.PublicKey
	SupportedTokenUserAccount     ag_solanago.PublicKey
	WalletProvider                *string `bin:"optional"`
	ContributionAccrualRate       *uint8  `bin:"optional"`
	DepositedSupportedTokenAmount uint64
	MintedReceiptTokenAmount      uint64
}

func (obj UserDepositedSupportedTokenToFund) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `ReceiptTokenMint` param:
	err = encoder.Encode(obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Serialize `FundAccount` param:
	err = encoder.Encode(obj.FundAccount)
	if err != nil {
		return err
	}
	// Serialize `User` param:
	err = encoder.Encode(obj.User)
	if err != nil {
		return err
	}
	// Serialize `UserReceiptTokenAccount` param:
	err = encoder.Encode(obj.UserReceiptTokenAccount)
	if err != nil {
		return err
	}
	// Serialize `UserFundAccount` param:
	err = encoder.Encode(obj.UserFundAccount)
	if err != nil {
		return err
	}
	// Serialize `SupportedTokenMint` param:
	err = encoder.Encode(obj.SupportedTokenMint)
	if err != nil {
		return err
	}
	// Serialize `SupportedTokenUserAccount` param:
	err = encoder.Encode(obj.SupportedTokenUserAccount)
	if err != nil {
		return err
	}
	// Serialize `WalletProvider` param (optional):
	{
		if obj.WalletProvider == nil {
			err = encoder.WriteBool(false)
			if err != nil {
				return err
			}
		} else {
			err = encoder.WriteBool(true)
			if err != nil {
				return err
			}
			err = encoder.Encode(obj.WalletProvider)
			if err != nil {
				return err
			}
		}
	}
	// Serialize `ContributionAccrualRate` param (optional):
	{
		if obj.ContributionAccrualRate == nil {
			err = encoder.WriteBool(false)
			if err != nil {
				return err
			}
		} else {
			err = encoder.WriteBool(true)
			if err != nil {
				return err
			}
			err = encoder.Encode(obj.ContributionAccrualRate)
			if err != nil {
				return err
			}
		}
	}
	// Serialize `DepositedSupportedTokenAmount` param:
	err = encoder.Encode(obj.DepositedSupportedTokenAmount)
	if err != nil {
		return err
	}
	// Serialize `MintedReceiptTokenAmount` param:
	err = encoder.Encode(obj.MintedReceiptTokenAmount)
	if err != nil {
		return err
	}
	return nil
}

func (obj *UserDepositedSupportedTokenToFund) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `ReceiptTokenMint`:
	err = decoder.Decode(&obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Deserialize `FundAccount`:
	err = decoder.Decode(&obj.FundAccount)
	if err != nil {
		return err
	}
	// Deserialize `User`:
	err = decoder.Decode(&obj.User)
	if err != nil {
		return err
	}
	// Deserialize `UserReceiptTokenAccount`:
	err = decoder.Decode(&obj.UserReceiptTokenAccount)
	if err != nil {
		return err
	}
	// Deserialize `UserFundAccount`:
	err = decoder.Decode(&obj.UserFundAccount)
	if err != nil {
		return err
	}
	// Deserialize `SupportedTokenMint`:
	err = decoder.Decode(&obj.SupportedTokenMint)
	if err != nil {
		return err
	}
	// Deserialize `SupportedTokenUserAccount`:
	err = decoder.Decode(&obj.SupportedTokenUserAccount)
	if err != nil {
		return err
	}
	// Deserialize `WalletProvider` (optional):
	{
		ok, err := decoder.ReadBool()
		if err != nil {
			return err
		}
		if ok {
			err = decoder.Decode(&obj.WalletProvider)
			if err != nil {
				return err
			}
		}
	}
	// Deserialize `ContributionAccrualRate` (optional):
	{
		ok, err := decoder.ReadBool()
		if err != nil {
			return err
		}
		if ok {
			err = decoder.Decode(&obj.ContributionAccrualRate)
			if err != nil {
				return err
			}
		}
	}
	// Deserialize `DepositedSupportedTokenAmount`:
	err = decoder.Decode(&obj.DepositedSupportedTokenAmount)
	if err != nil {
		return err
	}
	// Deserialize `MintedReceiptTokenAmount`:
	err = decoder.Decode(&obj.MintedReceiptTokenAmount)
	if err != nil {
		return err
	}
	return nil
}

type UserFundAccount struct {
	DataVersion        uint8
	Bump               uint8
	ReceiptTokenMint   ag_solanago.PublicKey
	User               ag_solanago.PublicKey
	ReceiptTokenAmount uint64
	Reserved           [32]uint8
	WithdrawalRequests []WithdrawalRequest
}

func (obj UserFundAccount) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `DataVersion` param:
	err = encoder.Encode(obj.DataVersion)
	if err != nil {
		return err
	}
	// Serialize `Bump` param:
	err = encoder.Encode(obj.Bump)
	if err != nil {
		return err
	}
	// Serialize `ReceiptTokenMint` param:
	err = encoder.Encode(obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Serialize `User` param:
	err = encoder.Encode(obj.User)
	if err != nil {
		return err
	}
	// Serialize `ReceiptTokenAmount` param:
	err = encoder.Encode(obj.ReceiptTokenAmount)
	if err != nil {
		return err
	}
	// Serialize `Reserved` param:
	err = encoder.Encode(obj.Reserved)
	if err != nil {
		return err
	}
	// Serialize `WithdrawalRequests` param:
	err = encoder.Encode(obj.WithdrawalRequests)
	if err != nil {
		return err
	}
	return nil
}

func (obj *UserFundAccount) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `DataVersion`:
	err = decoder.Decode(&obj.DataVersion)
	if err != nil {
		return err
	}
	// Deserialize `Bump`:
	err = decoder.Decode(&obj.Bump)
	if err != nil {
		return err
	}
	// Deserialize `ReceiptTokenMint`:
	err = decoder.Decode(&obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Deserialize `User`:
	err = decoder.Decode(&obj.User)
	if err != nil {
		return err
	}
	// Deserialize `ReceiptTokenAmount`:
	err = decoder.Decode(&obj.ReceiptTokenAmount)
	if err != nil {
		return err
	}
	// Deserialize `Reserved`:
	err = decoder.Decode(&obj.Reserved)
	if err != nil {
		return err
	}
	// Deserialize `WithdrawalRequests`:
	err = decoder.Decode(&obj.WithdrawalRequests)
	if err != nil {
		return err
	}
	return nil
}

type UserRequestedWithdrawalFromFund struct {
	ReceiptTokenMint            ag_solanago.PublicKey
	BatchId                     uint64
	RequestId                   uint64
	User                        ag_solanago.PublicKey
	UserReceiptTokenAccount     ag_solanago.PublicKey
	UserFundAccount             UserFundAccount
	RequestedReceiptTokenAmount uint64
}

func (obj UserRequestedWithdrawalFromFund) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `ReceiptTokenMint` param:
	err = encoder.Encode(obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Serialize `BatchId` param:
	err = encoder.Encode(obj.BatchId)
	if err != nil {
		return err
	}
	// Serialize `RequestId` param:
	err = encoder.Encode(obj.RequestId)
	if err != nil {
		return err
	}
	// Serialize `User` param:
	err = encoder.Encode(obj.User)
	if err != nil {
		return err
	}
	// Serialize `UserReceiptTokenAccount` param:
	err = encoder.Encode(obj.UserReceiptTokenAccount)
	if err != nil {
		return err
	}
	// Serialize `UserFundAccount` param:
	err = encoder.Encode(obj.UserFundAccount)
	if err != nil {
		return err
	}
	// Serialize `RequestedReceiptTokenAmount` param:
	err = encoder.Encode(obj.RequestedReceiptTokenAmount)
	if err != nil {
		return err
	}
	return nil
}

func (obj *UserRequestedWithdrawalFromFund) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `ReceiptTokenMint`:
	err = decoder.Decode(&obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Deserialize `BatchId`:
	err = decoder.Decode(&obj.BatchId)
	if err != nil {
		return err
	}
	// Deserialize `RequestId`:
	err = decoder.Decode(&obj.RequestId)
	if err != nil {
		return err
	}
	// Deserialize `User`:
	err = decoder.Decode(&obj.User)
	if err != nil {
		return err
	}
	// Deserialize `UserReceiptTokenAccount`:
	err = decoder.Decode(&obj.UserReceiptTokenAccount)
	if err != nil {
		return err
	}
	// Deserialize `UserFundAccount`:
	err = decoder.Decode(&obj.UserFundAccount)
	if err != nil {
		return err
	}
	// Deserialize `RequestedReceiptTokenAmount`:
	err = decoder.Decode(&obj.RequestedReceiptTokenAmount)
	if err != nil {
		return err
	}
	return nil
}

type UserRewardAccount struct {
	DataVersion        uint16
	Bump               uint8
	ReceiptTokenMint   ag_solanago.PublicKey
	User               ag_solanago.PublicKey
	NumUserRewardPools uint8
	MaxUserRewardPools uint8
	Padding            [11]uint8
	UserRewardPools1   [4]UserRewardPool
}

func (obj UserRewardAccount) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `DataVersion` param:
	err = encoder.Encode(obj.DataVersion)
	if err != nil {
		return err
	}
	// Serialize `Bump` param:
	err = encoder.Encode(obj.Bump)
	if err != nil {
		return err
	}
	// Serialize `ReceiptTokenMint` param:
	err = encoder.Encode(obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Serialize `User` param:
	err = encoder.Encode(obj.User)
	if err != nil {
		return err
	}
	// Serialize `NumUserRewardPools` param:
	err = encoder.Encode(obj.NumUserRewardPools)
	if err != nil {
		return err
	}
	// Serialize `MaxUserRewardPools` param:
	err = encoder.Encode(obj.MaxUserRewardPools)
	if err != nil {
		return err
	}
	// Serialize `Padding` param:
	err = encoder.Encode(obj.Padding)
	if err != nil {
		return err
	}
	// Serialize `UserRewardPools1` param:
	err = encoder.Encode(obj.UserRewardPools1)
	if err != nil {
		return err
	}
	return nil
}

func (obj *UserRewardAccount) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `DataVersion`:
	err = decoder.Decode(&obj.DataVersion)
	if err != nil {
		return err
	}
	// Deserialize `Bump`:
	err = decoder.Decode(&obj.Bump)
	if err != nil {
		return err
	}
	// Deserialize `ReceiptTokenMint`:
	err = decoder.Decode(&obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Deserialize `User`:
	err = decoder.Decode(&obj.User)
	if err != nil {
		return err
	}
	// Deserialize `NumUserRewardPools`:
	err = decoder.Decode(&obj.NumUserRewardPools)
	if err != nil {
		return err
	}
	// Deserialize `MaxUserRewardPools`:
	err = decoder.Decode(&obj.MaxUserRewardPools)
	if err != nil {
		return err
	}
	// Deserialize `Padding`:
	err = decoder.Decode(&obj.Padding)
	if err != nil {
		return err
	}
	// Deserialize `UserRewardPools1`:
	err = decoder.Decode(&obj.UserRewardPools1)
	if err != nil {
		return err
	}
	return nil
}

type UserRewardAccountUpdateInfo struct {
	DataVersion            uint16
	User                   ag_solanago.PublicKey
	UpdatedUserRewardPools []UserRewardPoolInfo
}

func (obj UserRewardAccountUpdateInfo) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `DataVersion` param:
	err = encoder.Encode(obj.DataVersion)
	if err != nil {
		return err
	}
	// Serialize `User` param:
	err = encoder.Encode(obj.User)
	if err != nil {
		return err
	}
	// Serialize `UpdatedUserRewardPools` param:
	err = encoder.Encode(obj.UpdatedUserRewardPools)
	if err != nil {
		return err
	}
	return nil
}

func (obj *UserRewardAccountUpdateInfo) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `DataVersion`:
	err = decoder.Decode(&obj.DataVersion)
	if err != nil {
		return err
	}
	// Deserialize `User`:
	err = decoder.Decode(&obj.User)
	if err != nil {
		return err
	}
	// Deserialize `UpdatedUserRewardPools`:
	err = decoder.Decode(&obj.UpdatedUserRewardPools)
	if err != nil {
		return err
	}
	return nil
}

type UserRewardPool struct {
	TokenAllocatedAmount TokenAllocatedAmount
	Contribution         ag_binary.Uint128
	UpdatedSlot          uint64
	RewardPoolId         uint8
	NumRewardSettlements uint8
	Padding              [6]uint8
	Reserved             [8]uint64
	RewardSettlements1   [16]UserRewardSettlement
}

func (obj UserRewardPool) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `TokenAllocatedAmount` param:
	err = encoder.Encode(obj.TokenAllocatedAmount)
	if err != nil {
		return err
	}
	// Serialize `Contribution` param:
	err = encoder.Encode(obj.Contribution)
	if err != nil {
		return err
	}
	// Serialize `UpdatedSlot` param:
	err = encoder.Encode(obj.UpdatedSlot)
	if err != nil {
		return err
	}
	// Serialize `RewardPoolId` param:
	err = encoder.Encode(obj.RewardPoolId)
	if err != nil {
		return err
	}
	// Serialize `NumRewardSettlements` param:
	err = encoder.Encode(obj.NumRewardSettlements)
	if err != nil {
		return err
	}
	// Serialize `Padding` param:
	err = encoder.Encode(obj.Padding)
	if err != nil {
		return err
	}
	// Serialize `Reserved` param:
	err = encoder.Encode(obj.Reserved)
	if err != nil {
		return err
	}
	// Serialize `RewardSettlements1` param:
	err = encoder.Encode(obj.RewardSettlements1)
	if err != nil {
		return err
	}
	return nil
}

func (obj *UserRewardPool) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `TokenAllocatedAmount`:
	err = decoder.Decode(&obj.TokenAllocatedAmount)
	if err != nil {
		return err
	}
	// Deserialize `Contribution`:
	err = decoder.Decode(&obj.Contribution)
	if err != nil {
		return err
	}
	// Deserialize `UpdatedSlot`:
	err = decoder.Decode(&obj.UpdatedSlot)
	if err != nil {
		return err
	}
	// Deserialize `RewardPoolId`:
	err = decoder.Decode(&obj.RewardPoolId)
	if err != nil {
		return err
	}
	// Deserialize `NumRewardSettlements`:
	err = decoder.Decode(&obj.NumRewardSettlements)
	if err != nil {
		return err
	}
	// Deserialize `Padding`:
	err = decoder.Decode(&obj.Padding)
	if err != nil {
		return err
	}
	// Deserialize `Reserved`:
	err = decoder.Decode(&obj.Reserved)
	if err != nil {
		return err
	}
	// Deserialize `RewardSettlements1`:
	err = decoder.Decode(&obj.RewardSettlements1)
	if err != nil {
		return err
	}
	return nil
}

type UserRewardPoolInfo struct {
	TokenAllocatedAmount TokenAllocatedAmount
	Contribution         ag_binary.Uint128
	UpdatedSlot          uint64
	RewardPoolId         uint8
	RewardSettlements    []UserRewardSettlement
}

func (obj UserRewardPoolInfo) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `TokenAllocatedAmount` param:
	err = encoder.Encode(obj.TokenAllocatedAmount)
	if err != nil {
		return err
	}
	// Serialize `Contribution` param:
	err = encoder.Encode(obj.Contribution)
	if err != nil {
		return err
	}
	// Serialize `UpdatedSlot` param:
	err = encoder.Encode(obj.UpdatedSlot)
	if err != nil {
		return err
	}
	// Serialize `RewardPoolId` param:
	err = encoder.Encode(obj.RewardPoolId)
	if err != nil {
		return err
	}
	// Serialize `RewardSettlements` param:
	err = encoder.Encode(obj.RewardSettlements)
	if err != nil {
		return err
	}
	return nil
}

func (obj *UserRewardPoolInfo) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `TokenAllocatedAmount`:
	err = decoder.Decode(&obj.TokenAllocatedAmount)
	if err != nil {
		return err
	}
	// Deserialize `Contribution`:
	err = decoder.Decode(&obj.Contribution)
	if err != nil {
		return err
	}
	// Deserialize `UpdatedSlot`:
	err = decoder.Decode(&obj.UpdatedSlot)
	if err != nil {
		return err
	}
	// Deserialize `RewardPoolId`:
	err = decoder.Decode(&obj.RewardPoolId)
	if err != nil {
		return err
	}
	// Deserialize `RewardSettlements`:
	err = decoder.Decode(&obj.RewardSettlements)
	if err != nil {
		return err
	}
	return nil
}

type UserRewardSettlement struct {
	RewardId            uint16
	Padding             [6]uint8
	SettledAmount       uint64
	SettledContribution ag_binary.Uint128
	SettledSlot         uint64
	ClaimedAmount       uint64
}

func (obj UserRewardSettlement) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `RewardId` param:
	err = encoder.Encode(obj.RewardId)
	if err != nil {
		return err
	}
	// Serialize `Padding` param:
	err = encoder.Encode(obj.Padding)
	if err != nil {
		return err
	}
	// Serialize `SettledAmount` param:
	err = encoder.Encode(obj.SettledAmount)
	if err != nil {
		return err
	}
	// Serialize `SettledContribution` param:
	err = encoder.Encode(obj.SettledContribution)
	if err != nil {
		return err
	}
	// Serialize `SettledSlot` param:
	err = encoder.Encode(obj.SettledSlot)
	if err != nil {
		return err
	}
	// Serialize `ClaimedAmount` param:
	err = encoder.Encode(obj.ClaimedAmount)
	if err != nil {
		return err
	}
	return nil
}

func (obj *UserRewardSettlement) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `RewardId`:
	err = decoder.Decode(&obj.RewardId)
	if err != nil {
		return err
	}
	// Deserialize `Padding`:
	err = decoder.Decode(&obj.Padding)
	if err != nil {
		return err
	}
	// Deserialize `SettledAmount`:
	err = decoder.Decode(&obj.SettledAmount)
	if err != nil {
		return err
	}
	// Deserialize `SettledContribution`:
	err = decoder.Decode(&obj.SettledContribution)
	if err != nil {
		return err
	}
	// Deserialize `SettledSlot`:
	err = decoder.Decode(&obj.SettledSlot)
	if err != nil {
		return err
	}
	// Deserialize `ClaimedAmount`:
	err = decoder.Decode(&obj.ClaimedAmount)
	if err != nil {
		return err
	}
	return nil
}

type UserTransferredReceiptToken struct {
	ReceiptTokenMint               ag_solanago.PublicKey
	SourceReceiptTokenAccount      ag_solanago.PublicKey
	SourceFundAccount              UserFundAccount
	Source                         ag_solanago.PublicKey
	DestinationReceiptTokenAccount ag_solanago.PublicKey
	DestinationFundAccount         UserFundAccount
	Destination                    ag_solanago.PublicKey
	TransferredReceiptTokenAmount  uint64
}

func (obj UserTransferredReceiptToken) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `ReceiptTokenMint` param:
	err = encoder.Encode(obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Serialize `SourceReceiptTokenAccount` param:
	err = encoder.Encode(obj.SourceReceiptTokenAccount)
	if err != nil {
		return err
	}
	// Serialize `SourceFundAccount` param:
	err = encoder.Encode(obj.SourceFundAccount)
	if err != nil {
		return err
	}
	// Serialize `Source` param:
	err = encoder.Encode(obj.Source)
	if err != nil {
		return err
	}
	// Serialize `DestinationReceiptTokenAccount` param:
	err = encoder.Encode(obj.DestinationReceiptTokenAccount)
	if err != nil {
		return err
	}
	// Serialize `DestinationFundAccount` param:
	err = encoder.Encode(obj.DestinationFundAccount)
	if err != nil {
		return err
	}
	// Serialize `Destination` param:
	err = encoder.Encode(obj.Destination)
	if err != nil {
		return err
	}
	// Serialize `TransferredReceiptTokenAmount` param:
	err = encoder.Encode(obj.TransferredReceiptTokenAmount)
	if err != nil {
		return err
	}
	return nil
}

func (obj *UserTransferredReceiptToken) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `ReceiptTokenMint`:
	err = decoder.Decode(&obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Deserialize `SourceReceiptTokenAccount`:
	err = decoder.Decode(&obj.SourceReceiptTokenAccount)
	if err != nil {
		return err
	}
	// Deserialize `SourceFundAccount`:
	err = decoder.Decode(&obj.SourceFundAccount)
	if err != nil {
		return err
	}
	// Deserialize `Source`:
	err = decoder.Decode(&obj.Source)
	if err != nil {
		return err
	}
	// Deserialize `DestinationReceiptTokenAccount`:
	err = decoder.Decode(&obj.DestinationReceiptTokenAccount)
	if err != nil {
		return err
	}
	// Deserialize `DestinationFundAccount`:
	err = decoder.Decode(&obj.DestinationFundAccount)
	if err != nil {
		return err
	}
	// Deserialize `Destination`:
	err = decoder.Decode(&obj.Destination)
	if err != nil {
		return err
	}
	// Deserialize `TransferredReceiptTokenAmount`:
	err = decoder.Decode(&obj.TransferredReceiptTokenAmount)
	if err != nil {
		return err
	}
	return nil
}

type UserUpdatedRewardPool struct {
	ReceiptTokenMint ag_solanago.PublicKey
	Updates          []UserRewardAccountUpdateInfo
}

func (obj UserUpdatedRewardPool) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `ReceiptTokenMint` param:
	err = encoder.Encode(obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Serialize `Updates` param:
	err = encoder.Encode(obj.Updates)
	if err != nil {
		return err
	}
	return nil
}

func (obj *UserUpdatedRewardPool) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `ReceiptTokenMint`:
	err = decoder.Decode(&obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Deserialize `Updates`:
	err = decoder.Decode(&obj.Updates)
	if err != nil {
		return err
	}
	return nil
}

type UserWithdrewSOLFromFund struct {
	ReceiptTokenMint        ag_solanago.PublicKey
	FundAccount             FundAccountInfo
	RequestId               uint64
	UserFundAccount         UserFundAccount
	User                    ag_solanago.PublicKey
	BurntReceiptTokenAmount uint64
	WithdrawnSolAmount      uint64
	DeductedSolFeeAmount    uint64
}

func (obj UserWithdrewSOLFromFund) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `ReceiptTokenMint` param:
	err = encoder.Encode(obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Serialize `FundAccount` param:
	err = encoder.Encode(obj.FundAccount)
	if err != nil {
		return err
	}
	// Serialize `RequestId` param:
	err = encoder.Encode(obj.RequestId)
	if err != nil {
		return err
	}
	// Serialize `UserFundAccount` param:
	err = encoder.Encode(obj.UserFundAccount)
	if err != nil {
		return err
	}
	// Serialize `User` param:
	err = encoder.Encode(obj.User)
	if err != nil {
		return err
	}
	// Serialize `BurntReceiptTokenAmount` param:
	err = encoder.Encode(obj.BurntReceiptTokenAmount)
	if err != nil {
		return err
	}
	// Serialize `WithdrawnSolAmount` param:
	err = encoder.Encode(obj.WithdrawnSolAmount)
	if err != nil {
		return err
	}
	// Serialize `DeductedSolFeeAmount` param:
	err = encoder.Encode(obj.DeductedSolFeeAmount)
	if err != nil {
		return err
	}
	return nil
}

func (obj *UserWithdrewSOLFromFund) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `ReceiptTokenMint`:
	err = decoder.Decode(&obj.ReceiptTokenMint)
	if err != nil {
		return err
	}
	// Deserialize `FundAccount`:
	err = decoder.Decode(&obj.FundAccount)
	if err != nil {
		return err
	}
	// Deserialize `RequestId`:
	err = decoder.Decode(&obj.RequestId)
	if err != nil {
		return err
	}
	// Deserialize `UserFundAccount`:
	err = decoder.Decode(&obj.UserFundAccount)
	if err != nil {
		return err
	}
	// Deserialize `User`:
	err = decoder.Decode(&obj.User)
	if err != nil {
		return err
	}
	// Deserialize `BurntReceiptTokenAmount`:
	err = decoder.Decode(&obj.BurntReceiptTokenAmount)
	if err != nil {
		return err
	}
	// Deserialize `WithdrawnSolAmount`:
	err = decoder.Decode(&obj.WithdrawnSolAmount)
	if err != nil {
		return err
	}
	// Deserialize `DeductedSolFeeAmount`:
	err = decoder.Decode(&obj.DeductedSolFeeAmount)
	if err != nil {
		return err
	}
	return nil
}

type WithdrawalRequest struct {
	BatchId            uint64
	RequestId          uint64
	ReceiptTokenAmount uint64
	CreatedAt          int64
	Reserved           [16]uint8
}

func (obj WithdrawalRequest) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `BatchId` param:
	err = encoder.Encode(obj.BatchId)
	if err != nil {
		return err
	}
	// Serialize `RequestId` param:
	err = encoder.Encode(obj.RequestId)
	if err != nil {
		return err
	}
	// Serialize `ReceiptTokenAmount` param:
	err = encoder.Encode(obj.ReceiptTokenAmount)
	if err != nil {
		return err
	}
	// Serialize `CreatedAt` param:
	err = encoder.Encode(obj.CreatedAt)
	if err != nil {
		return err
	}
	// Serialize `Reserved` param:
	err = encoder.Encode(obj.Reserved)
	if err != nil {
		return err
	}
	return nil
}

func (obj *WithdrawalRequest) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `BatchId`:
	err = decoder.Decode(&obj.BatchId)
	if err != nil {
		return err
	}
	// Deserialize `RequestId`:
	err = decoder.Decode(&obj.RequestId)
	if err != nil {
		return err
	}
	// Deserialize `ReceiptTokenAmount`:
	err = decoder.Decode(&obj.ReceiptTokenAmount)
	if err != nil {
		return err
	}
	// Deserialize `CreatedAt`:
	err = decoder.Decode(&obj.CreatedAt)
	if err != nil {
		return err
	}
	// Deserialize `Reserved`:
	err = decoder.Decode(&obj.Reserved)
	if err != nil {
		return err
	}
	return nil
}

type WithdrawalStatus struct {
	NextBatchId                      uint64
	NextRequestId                    uint64
	NumWithdrawalRequestsInProgress  uint64
	LastCompletedBatchId             uint64
	LastBatchProcessingStartedAt     *int64 `bin:"optional"`
	LastBatchProcessingCompletedAt   *int64 `bin:"optional"`
	SolWithdrawalFeeRate             uint16
	WithdrawalEnabledFlag            bool
	BatchProcessingThresholdAmount   uint64
	BatchProcessingThresholdDuration int64
	PendingBatchWithdrawal           BatchWithdrawal
	BatchWithdrawalsInProgress       []BatchWithdrawal
	ReservedFund                     ReservedFund
}

func (obj WithdrawalStatus) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) {
	// Serialize `NextBatchId` param:
	err = encoder.Encode(obj.NextBatchId)
	if err != nil {
		return err
	}
	// Serialize `NextRequestId` param:
	err = encoder.Encode(obj.NextRequestId)
	if err != nil {
		return err
	}
	// Serialize `NumWithdrawalRequestsInProgress` param:
	err = encoder.Encode(obj.NumWithdrawalRequestsInProgress)
	if err != nil {
		return err
	}
	// Serialize `LastCompletedBatchId` param:
	err = encoder.Encode(obj.LastCompletedBatchId)
	if err != nil {
		return err
	}
	// Serialize `LastBatchProcessingStartedAt` param (optional):
	{
		if obj.LastBatchProcessingStartedAt == nil {
			err = encoder.WriteBool(false)
			if err != nil {
				return err
			}
		} else {
			err = encoder.WriteBool(true)
			if err != nil {
				return err
			}
			err = encoder.Encode(obj.LastBatchProcessingStartedAt)
			if err != nil {
				return err
			}
		}
	}
	// Serialize `LastBatchProcessingCompletedAt` param (optional):
	{
		if obj.LastBatchProcessingCompletedAt == nil {
			err = encoder.WriteBool(false)
			if err != nil {
				return err
			}
		} else {
			err = encoder.WriteBool(true)
			if err != nil {
				return err
			}
			err = encoder.Encode(obj.LastBatchProcessingCompletedAt)
			if err != nil {
				return err
			}
		}
	}
	// Serialize `SolWithdrawalFeeRate` param:
	err = encoder.Encode(obj.SolWithdrawalFeeRate)
	if err != nil {
		return err
	}
	// Serialize `WithdrawalEnabledFlag` param:
	err = encoder.Encode(obj.WithdrawalEnabledFlag)
	if err != nil {
		return err
	}
	// Serialize `BatchProcessingThresholdAmount` param:
	err = encoder.Encode(obj.BatchProcessingThresholdAmount)
	if err != nil {
		return err
	}
	// Serialize `BatchProcessingThresholdDuration` param:
	err = encoder.Encode(obj.BatchProcessingThresholdDuration)
	if err != nil {
		return err
	}
	// Serialize `PendingBatchWithdrawal` param:
	err = encoder.Encode(obj.PendingBatchWithdrawal)
	if err != nil {
		return err
	}
	// Serialize `BatchWithdrawalsInProgress` param:
	err = encoder.Encode(obj.BatchWithdrawalsInProgress)
	if err != nil {
		return err
	}
	// Serialize `ReservedFund` param:
	err = encoder.Encode(obj.ReservedFund)
	if err != nil {
		return err
	}
	return nil
}

func (obj *WithdrawalStatus) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) {
	// Deserialize `NextBatchId`:
	err = decoder.Decode(&obj.NextBatchId)
	if err != nil {
		return err
	}
	// Deserialize `NextRequestId`:
	err = decoder.Decode(&obj.NextRequestId)
	if err != nil {
		return err
	}
	// Deserialize `NumWithdrawalRequestsInProgress`:
	err = decoder.Decode(&obj.NumWithdrawalRequestsInProgress)
	if err != nil {
		return err
	}
	// Deserialize `LastCompletedBatchId`:
	err = decoder.Decode(&obj.LastCompletedBatchId)
	if err != nil {
		return err
	}
	// Deserialize `LastBatchProcessingStartedAt` (optional):
	{
		ok, err := decoder.ReadBool()
		if err != nil {
			return err
		}
		if ok {
			err = decoder.Decode(&obj.LastBatchProcessingStartedAt)
			if err != nil {
				return err
			}
		}
	}
	// Deserialize `LastBatchProcessingCompletedAt` (optional):
	{
		ok, err := decoder.ReadBool()
		if err != nil {
			return err
		}
		if ok {
			err = decoder.Decode(&obj.LastBatchProcessingCompletedAt)
			if err != nil {
				return err
			}
		}
	}
	// Deserialize `SolWithdrawalFeeRate`:
	err = decoder.Decode(&obj.SolWithdrawalFeeRate)
	if err != nil {
		return err
	}
	// Deserialize `WithdrawalEnabledFlag`:
	err = decoder.Decode(&obj.WithdrawalEnabledFlag)
	if err != nil {
		return err
	}
	// Deserialize `BatchProcessingThresholdAmount`:
	err = decoder.Decode(&obj.BatchProcessingThresholdAmount)
	if err != nil {
		return err
	}
	// Deserialize `BatchProcessingThresholdDuration`:
	err = decoder.Decode(&obj.BatchProcessingThresholdDuration)
	if err != nil {
		return err
	}
	// Deserialize `PendingBatchWithdrawal`:
	err = decoder.Decode(&obj.PendingBatchWithdrawal)
	if err != nil {
		return err
	}
	// Deserialize `BatchWithdrawalsInProgress`:
	err = decoder.Decode(&obj.BatchWithdrawalsInProgress)
	if err != nil {
		return err
	}
	// Deserialize `ReservedFund`:
	err = decoder.Decode(&obj.ReservedFund)
	if err != nil {
		return err
	}
	return nil
}