metaplex

package
v0.1.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 16, 2022 License: MIT Imports: 9 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// Initializes an Auction Manager V1
	Instruction_DeprecatedInitAuctionManagerV1 uint8 = iota

	// Validates that a given safety deposit box has in it contents that match the expected WinningConfig in the auction manager.
	// A stateful call, this will error out if you call it a second time after validation has occurred.
	Instruction_DeprecatedValidateSafetyDepositBoxV1

	// NOTE: Requires an AuctionManagerV1.
	// Note: This requires that auction manager be in a Running state.
	//
	// If an auction is complete, you can redeem your bid for a specific item here. If you are the first to do this,
	// The auction manager will switch from Running state to Disbursing state. If you are the last, this may change
	// the auction manager state to Finished provided that no authorities remain to be delegated for Master Edition tokens.
	//
	// NOTE: Please note that it is totally possible to redeem a bid 2x - once for a prize you won and once at the RedeemParticipationBid point for an open edition
	// that comes as a 'token of appreciation' for bidding. They are not mutually exclusive unless explicitly set to be that way.
	Instruction_RedeemBid

	// Note: This requires that auction manager be in a Running state.
	//
	// If an auction is complete, you can redeem your bid for the actual Master Edition itself if it's for that prize here.
	// If you are the first to do this, the auction manager will switch from Running state to Disbursing state.
	// If you are the last, this may change the auction manager state to Finished provided that no authorities remain to be delegated for Master Edition tokens.
	//
	// NOTE: Please note that it is totally possible to redeem a bid 2x - once for a prize you won and once at the RedeemParticipationBid point for an open edition
	// that comes as a 'token of appreciation' for bidding. They are not mutually exclusive unless explicitly set to be that way.
	Instruction_RedeemFullRightsTransferBid

	// Note: This requires that auction manager be in a Running state.
	//
	// If an auction is complete, you can redeem your bid for an Open Edition token if it is eligible. If you are the first to do this,
	// The auction manager will switch from Running state to Disbursing state. If you are the last, this may change
	// the auction manager state to Finished provided that no authorities remain to be delegated for Master Edition tokens.
	//
	// NOTE: Please note that it is totally possible to redeem a bid 2x - once for a prize you won and once at this end point for a open edition
	// that comes as a 'token of appreciation' for bidding. They are not mutually exclusive unless explicitly set to be that way.
	//
	// NOTE: If you are redeeming a newly minted Open Edition, you must actually supply a destination account containing a token from a brand new
	// mint. We do not provide the token to you. Our job with this action is to christen this mint + token combo as an official Open Edition.
	Instruction_DeprecatedRedeemParticipationBid

	// If the auction manager is in Validated state, it can invoke the start command via calling this command here.
	Instruction_StartAuction

	// If the auction manager is in a Disbursing or Finished state, then this means Auction must be in Ended state.
	// Then this end point can be used as a signed proxy to use auction manager's authority over the auction to claim bid funds
	// into the accept payment account on the auction manager for a given bid. Auction has no opinions on how bids are redeemed,
	// only that they exist, have been paid, and have a winning place. It is up to the implementer of the auction to determine redemption,
	// and auction manager does this via bid redemption tickets and the vault contract which ensure the user always
	// can get their NFT once they have paid. Therefore, once they have paid, and the auction is over, the artist can claim
	// funds at any time without any danger to the user of losing out on their NFT, because the AM will honor their bid with an NFT
	// at ANY time.
	Instruction_ClaimBid

	// At any time, the auction manager authority may empty whatever funds are in the accept payment account
	// on the auction manager. Funds come here from fixed price payments for partipation nfts, and from draining bid payments
	// from the auction.
	//
	// This action specifically takes a given safety deposit box, winning config, and creator on a metadata for the token inside that safety deposit box
	// and pumps the requisite monies out to that creator as required by the royalties formula.
	//
	// It's up to the UI to iterate through all winning configs, all safety deposit boxes in a given winning config tier, and all creators for
	// each metadata attached to each safety deposit box, to get all the money. Note that one safety deposit box can be used in multiple different winning configs,
	// but this shouldn't make any difference to this function.
	//
	// We designed this function to be called in this loop-like manner because there is a limit to the number of accounts that can
	// be passed up at once (32) and there may be many more than that easily in a given auction, so it's easier for the implementer to just
	// loop through and call it, and there is an incentive for them to do so (to get paid.) It's permissionless as well as it
	// will empty into any destination account owned by the creator that has the proper mint, so anybody can call it.
	//
	// For the participation NFT, there is no winning config, but the total is figured by summing the winning bids and subtracting
	// from the total escrow amount present.
	Instruction_EmptyPaymentAccount

	// Given a signer wallet, create a store with pda ['metaplex', wallet] (if it does not exist) and/or update it
	// (if it already exists). Stores can be set to open (anybody can publish) or closed (publish only via whitelist).
	Instruction_SetStore

	// Given an existing store, add or update an existing whitelisted creator for the store. This creates
	// a PDA with seed ['metaplex', store key, creator key] if it does not already exist to store attributes there.
	Instruction_SetWhitelistedCreator

	// NOTE: Requires an AuctionManagerV1.
	// Validates an participation nft (if present) on the Auction Manager. Because of the differing mechanics of an open
	// edition (required for participation nft), it needs to be validated at a different endpoint than a normal safety deposit box.
	Instruction_DeprecatedValidateParticipation

	// NOTE: Requires an AuctionManagerV1.
	// Needs to be called by someone at the end of the auction - will use the one time authorization token
	// to fire up a bunch of printing tokens for use in participation redemptions.
	Instruction_DeprecatedPopulateParticipationPrintingAccount

	// If you are an auctioneer, redeem an unused winning config entry. You provide the winning index, and if the winning
	// index has no winner, then the correct redemption method is called with a special flag set to ignore bidder_metadata checks
	// and a hardcoded winner index to empty this win to you.
	//
	// All the keys, in exact sequence, should follow the expected call you wish to proxy to, because these will be passed
	// to the process_ method of the next call. This method exists primarily to pass in an additional
	// argument to the other redemption methods that subtly changes their behavior. We made this additional call so that if the auctioneer
	// calls those methods directly, they still act the same as if the auctioneer were a normal bidder, which is be desirable behavior.
	//
	// An auctioneer should never be in the position where the auction can never work the same for them simply because they are an auctioneer.
	// This special endpoint exists to give them the "out" to unload items via a proxy call once the auction is over.
	Instruction_RedeemUnusedWinningConfigItemsAsAuctioneer

	// If you have an auction manager in an Initialized state and for some reason you can't validate it, you want to retrieve
	// The items inside of it. This will allow you to move it straight to Disbursing, and then you can, as Auctioneer,
	// Redeem those items using the RedeemUnusedWinningConfigItemsAsAuctioneer endpoint.
	//
	// If you pass the vault program account, authority over the vault will be returned to you, so you can unwind the vault
	// to get your items back that way instead.
	//
	// Be WARNED: Because the boxes have not been validated, the logic for redemptions may not work quite right. For instance,
	// if your validation step failed because you provided an empty box but said there was a token in it, when you go
	// and try to redeem it, you yourself will experience quite the explosion. It will be up to you to tactfully
	// request the bids that can be properly redeemed from the ones that cannot.
	//
	// If you had a FullRightsTransfer token, and you never validated (and thus transferred) ownership, when the redemption happens
	// it will skip trying to transfer it to you, so that should work fine.
	Instruction_DecommissionAuctionManager

	// Note: This requires that auction manager be in a Running state and that be of the V1 type.
	//
	// If an auction is complete, you can redeem your printing v2 bid for a specific item here. If you are the first to do this,
	// The auction manager will switch from Running state to Disbursing state. If you are the last, this may change
	// the auction manager state to Finished provided that no authorities remain to be delegated for Master Edition tokens.
	//
	// NOTE: Please note that it is totally possible to redeem a bid 2x - once for a prize you won and once at the RedeemParticipationBid point for an open edition
	// that comes as a 'token of appreciation' for bidding. They are not mutually exclusive unless explicitly set to be that way.
	Instruction_RedeemPrintingV2Bid

	// Permissionless call to redeem the master edition in a given safety deposit for a PrintingV2 winning config to the
	// ATA of the Auctioneer. Can only be called once all redemptions have been met.
	Instruction_WithdrawMasterEdition

	// Note: This requires that auction manager be in a Running state.
	//
	// Second note: Unlike it's predecessor, V2 is permissionless.
	// You can in theory pay for someone else's participation NFT and gift it to them.
	//
	// If an auction is complete, you can redeem your bid for an Open Edition token if it is eligible. If you are the first to do this,
	// The auction manager will switch from Running state to Disbursing state. If you are the last, this may change
	// the auction manager state to Finished provided that no authorities remain to be delegated for Master Edition tokens.
	//
	// NOTE: Please note that it is totally possible to redeem a bid 2x - once for a prize you won and once at this end point for a open edition
	// that comes as a 'token of appreciation' for bidding. They are not mutually exclusive unless explicitly set to be that way.
	//
	// NOTE: If you are redeeming a newly minted Open Edition, you must actually supply a destination account containing a token from a brand new
	// mint. We do not provide the token to you. Our job with this action is to christen this mint + token combo as an official Open Edition.
	Instruction_DeprecatedRedeemParticipationBidV2

	// Initializes an Auction Manager V2
	//
	// NOTE: It is not possible to use MasterEditionV1s for participation nfts with these managers.
	Instruction_InitAuctionManagerV2

	// NOTE: Requires an AuctionManagerV2.
	//
	// Validates that a given safety deposit box has in it contents that match the given SafetyDepositConfig, and creates said config.
	// A stateful call, this will error out if you call it a second time after validation has occurred.
	Instruction_ValidateSafetyDepositBoxV2

	// Note: This requires that auction manager be in a Running state.
	//
	// Second note: V3 is the same as V2, but it requires an additional argument because it is intended to be used with AuctionManagerV2s,
	// not V1s, which use BidRedemptionTicketV2s, which require this additional argument (the user_provided_win_index).
	// You can in theory pay for someone else's participation NFT and gift it to them.
	//
	// If an auction is complete, you can redeem your bid for an Open Edition token if it is eligible. If you are the first to do this,
	// The auction manager will switch from Running state to Disbursing state. If you are the last, this may change
	// the auction manager state to Finished provided that no authorities remain to be delegated for Master Edition tokens.
	//
	// NOTE: Please note that it is totally possible to redeem a bid 2x - once for a prize you won and once at this end point for a open edition
	// that comes as a 'token of appreciation' for bidding. They are not mutually exclusive unless explicitly set to be that way.
	//
	// NOTE: If you are redeeming a newly minted Open Edition, you must actually supply a destination account containing a token from a brand new
	// mint. We do not provide the token to you. Our job with this action is to christen this mint + token combo as an official Open Edition.
	Instruction_RedeemParticipationBidV3
)
View Source 
const AMOUNT_POSITION = 42
View Source 
const AMOUNT_RANGE_FIRST_EL_POSITION = 48
View Source 
const AMOUNT_RANGE_SIZE_POSITION = 44
View Source 
const AUCTION_MANAGER_PADDING = 149
View Source 
const AUCTION_MANAGER_POSITION = 1
View Source 
const BASE_SAFETY_CONFIG_SIZE = 1 + 32 + 8 + 1 + 1 + 1 + 4 + 1 + 1 + 1 + 9 + 1 + 8 + 20
View Source 
const BASE_TRACKER_SIZE = 1 + 1 + 1 + 4
View Source 
const LENGTH_POSITION = 43
View Source 
const MAX_AUCTION_MANAGER_V1_SIZE = 1 +
	32 +
	32 +
	32 +
	32 +
	32 +
	1 +
	1 +
	8 +
	8 +
	MAX_WINNER_SIZE +
	1 +
	8 +
	1 +
	1 +
	32 +
	8 +
	8 +
	1 +
	1 +
	1 +
	1 +
	9 +
	1 +
	AUCTION_MANAGER_PADDING
View Source 
const MAX_AUCTION_MANAGER_V2_SIZE = 1 + 32 + 32 + 32 + 32 + 32 + 1 + 1 + 8 + 200
View Source 
const MAX_AUTHORITY_LOOKUP_SIZE = 33
View Source 
const MAX_BID_REDEMPTION_TICKET_SIZE = 3
View Source 
const MAX_PAYOUT_TICKET_SIZE = 1 + 32 + 8
View Source 
const MAX_PRIZE_TRACKING_TICKET_SIZE = 1 + 32 + 8 + 8 + 8 + 50
View Source 
const MAX_STORE_SIZE = 2 + 32 + 32 + 32 + 32 + 100
View Source 
const MAX_VALIDATION_TICKET_SIZE = 1 + 32 + 10
View Source 
const MAX_WHITELISTED_CREATOR_SIZE = 2 + 32 + 10
View Source 
const MAX_WINNERS = 200
View Source 
const MAX_WINNER_SIZE = 6 * MAX_WINNERS
View Source 
const MAX_WINNING_CONFIG_STATE_ITEM_SIZE = 2
View Source 
const ORDER_POSITION = 33
View Source 
const PREFIX = "metaplex"

/ prefix used for PDAs to avoid certain collision attacks (https://en.wikipedia.org/wiki/Collision_attack#Chosen-prefix_collision_attack)

View Source 
const ProgramName = "Metaplex"
View Source 
const TOTALS = "totals"
View Source 
const WINNING_CONFIG_POSITION = 41

Variables

View Source 
var InstructionImplDef = ag_binary.NewVariantDefinition(
	ag_binary.Uint8TypeIDEncoding,
	[]ag_binary.VariantType{
		{
			"DeprecatedInitAuctionManagerV1", (*DeprecatedInitAuctionManagerV1)(nil),
		},
		{
			"DeprecatedValidateSafetyDepositBoxV1", (*DeprecatedValidateSafetyDepositBoxV1)(nil),
		},
		{
			"RedeemBid", (*RedeemBid)(nil),
		},
		{
			"RedeemFullRightsTransferBid", (*RedeemFullRightsTransferBid)(nil),
		},
		{
			"DeprecatedRedeemParticipationBid", (*DeprecatedRedeemParticipationBid)(nil),
		},
		{
			"StartAuction", (*StartAuction)(nil),
		},
		{
			"ClaimBid", (*ClaimBid)(nil),
		},
		{
			"EmptyPaymentAccount", (*EmptyPaymentAccount)(nil),
		},
		{
			"SetStore", (*SetStore)(nil),
		},
		{
			"SetWhitelistedCreator", (*SetWhitelistedCreator)(nil),
		},
		{
			"DeprecatedValidateParticipation", (*DeprecatedValidateParticipation)(nil),
		},
		{
			"DeprecatedPopulateParticipationPrintingAccount", (*DeprecatedPopulateParticipationPrintingAccount)(nil),
		},
		{
			"RedeemUnusedWinningConfigItemsAsAuctioneer", (*RedeemUnusedWinningConfigItemsAsAuctioneer)(nil),
		},
		{
			"DecommissionAuctionManager", (*DecommissionAuctionManager)(nil),
		},
		{
			"RedeemPrintingV2Bid", (*RedeemPrintingV2Bid)(nil),
		},
		{
			"WithdrawMasterEdition", (*WithdrawMasterEdition)(nil),
		},
		{
			"DeprecatedRedeemParticipationBidV2", (*DeprecatedRedeemParticipationBidV2)(nil),
		},
		{
			"InitAuctionManagerV2", (*InitAuctionManagerV2)(nil),
		},
		{
			"ValidateSafetyDepositBoxV2", (*ValidateSafetyDepositBoxV2)(nil),
		},
		{
			"RedeemParticipationBidV3", (*RedeemParticipationBidV3)(nil),
		},
	},
)
View Source 
var ProgramID ag_solanago.PublicKey = ag_solanago.MustPublicKeyFromBase58("p1exdMJcjVao65QdewkaZRUnU6VPSXhus9n2GzWfh98")

Functions

func InstructionIDToName 

func InstructionIDToName(id uint8) string

InstructionIDToName returns the name of the instruction given its ID.

func SetProgramID 

func SetProgramID(pubkey ag_solanago.PublicKey)

Types

type AmountCumulativeReturn 

type AmountCumulativeReturn struct {
	Amount           uint64
	CumulativeAmount uint64
	TotalAmount      uint64
}

func (AmountCumulativeReturn) MarshalWithEncoder 

func (obj AmountCumulativeReturn) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*AmountCumulativeReturn) UnmarshalWithDecoder 

func (obj *AmountCumulativeReturn) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type AmountRange 

type AmountRange struct {
	F0 uint64
	F1 uint64
}

func (AmountRange) MarshalWithEncoder 

func (obj AmountRange) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*AmountRange) UnmarshalWithDecoder 

func (obj *AmountRange) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type AuctionManagerSettings 

type AuctionManagerSettings struct {
	// The safety deposit box index in the vault containing the winning items, in order of place
	// The same index can appear multiple times if that index contains n tokens for n appearances (this will be checked)
	WinningConfigs []WinningConfig

	// The participation config is separated because it is structurally a bit different,
	// having different options and also because it has no real "winning place" in the array.
	ParticipationConfig *ParticipationConfig `bin:"optional"`
}

func (AuctionManagerSettings) MarshalWithEncoder 

func (obj AuctionManagerSettings) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*AuctionManagerSettings) UnmarshalWithDecoder 

func (obj *AuctionManagerSettings) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type AuctionManagerSettingsV1 

type AuctionManagerSettingsV1 struct {
	// The safety deposit box index in the vault containing the winning items, in order of place
	// The same index can appear multiple times if that index contains n tokens for n appearances (this will be checked)
	WinningConfigs []WinningConfig

	// The participation config is separated because it is structurally a bit different,
	// having different options and also because it has no real "winning place" in the array.
	ParticipationConfig *ParticipationConfigV1 `bin:"optional"`
}

func (AuctionManagerSettingsV1) MarshalWithEncoder 

func (obj AuctionManagerSettingsV1) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*AuctionManagerSettingsV1) UnmarshalWithDecoder 

func (obj *AuctionManagerSettingsV1) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type AuctionManagerStateV1 

type AuctionManagerStateV1 struct {
	Status AuctionManagerStatus

	// When all configs are validated the auction is started and auction manager moves to Running
	WinningConfigItemsValidated uint8
	WinningConfigStates         []WinningConfigState
	ParticipationState          *ParticipationStateV1 `bin:"optional"`
}

func (AuctionManagerStateV1) MarshalWithEncoder 

func (obj AuctionManagerStateV1) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*AuctionManagerStateV1) UnmarshalWithDecoder 

func (obj *AuctionManagerStateV1) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type AuctionManagerStateV2 

type AuctionManagerStateV2 struct {
	Status AuctionManagerStatus

	// When all configs are validated the auction is started and auction manager moves to Running
	SafetyConfigItemsValidated uint64

	// how many bids have been pushed to accept payment
	BidsPushedToAcceptPayment uint64
	HasParticipation          bool
}

func (AuctionManagerStateV2) MarshalWithEncoder 

func (obj AuctionManagerStateV2) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*AuctionManagerStateV2) UnmarshalWithDecoder 

func (obj *AuctionManagerStateV2) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type AuctionManagerStatus 

type AuctionManagerStatus ag_binary.BorshEnum
const (
	Initialized_AuctionManagerStatus AuctionManagerStatus = iota
	Validated_AuctionManagerStatus
	Running_AuctionManagerStatus
	Disbursing_AuctionManagerStatus
	Finished_AuctionManagerStatus
)

func (AuctionManagerStatus) String added in v0.1.2 

func (value AuctionManagerStatus) String() string

type AuctionManagerV1 

type AuctionManagerV1 struct {
	Key           Key
	Store         ag_solanago.PublicKey
	Authority     ag_solanago.PublicKey
	Auction       ag_solanago.PublicKey
	Vault         ag_solanago.PublicKey
	AcceptPayment ag_solanago.PublicKey
	State         AuctionManagerStateV1
	Settings      AuctionManagerSettingsV1

	// True if this is only winning configs of one item each, used for optimization in saving.
	StraightShotOptimization bool
}

func (AuctionManagerV1) MarshalWithEncoder 

func (obj AuctionManagerV1) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*AuctionManagerV1) UnmarshalWithDecoder 

func (obj *AuctionManagerV1) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type AuctionManagerV2 

type AuctionManagerV2 struct {
	Key           Key
	Store         ag_solanago.PublicKey
	Authority     ag_solanago.PublicKey
	Auction       ag_solanago.PublicKey
	Vault         ag_solanago.PublicKey
	AcceptPayment ag_solanago.PublicKey
	State         AuctionManagerStateV2
}

func (AuctionManagerV2) MarshalWithEncoder 

func (obj AuctionManagerV2) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*AuctionManagerV2) UnmarshalWithDecoder 

func (obj *AuctionManagerV2) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type AuctionWinnerTokenTypeTracker 

type AuctionWinnerTokenTypeTracker struct {
	Key        Key
	AmountType TupleNumericType
	LengthType TupleNumericType

	// Tuple is (amount of editions or tokens given to people in this range, length of range)
	AmountRanges []AmountRange
}

func (AuctionWinnerTokenTypeTracker) MarshalWithEncoder 

func (obj AuctionWinnerTokenTypeTracker) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*AuctionWinnerTokenTypeTracker) UnmarshalWithDecoder 

func (obj *AuctionWinnerTokenTypeTracker) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type BidRedemptionTicket 

type BidRedemptionTicket struct {
	Key Key
}

func (BidRedemptionTicket) MarshalWithEncoder 

func (obj BidRedemptionTicket) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*BidRedemptionTicket) UnmarshalWithDecoder 

func (obj *BidRedemptionTicket) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type ClaimBid 

type ClaimBid struct {

	// [0] = [WRITE] acceptPayment
	// ··········· The accept payment account on the auction manager
	//
	// [1] = [WRITE] bidderPotToken
	// ··········· The bidder pot token account
	//
	// [2] = [WRITE] bidderPotPDA
	// ··········· The bidder pot pda account [seed of ['auction', program_id, auction key, bidder key] -
	// ··········· relative to the auction program, not auction manager
	//
	// [3] = [WRITE] auctionManager
	// ··········· Auction manager
	//
	// [4] = [] auction
	// ··········· The auction
	//
	// [5] = [] bidderWallet
	// ··········· The bidder wallet
	//
	// [6] = [] tokenMint
	// ··········· Token mint of the auction
	//
	// [7] = [] vault
	// ··········· Vault
	//
	// [8] = [] store
	// ··········· Store
	//
	// [9] = [] auctionProgram
	// ··········· Auction program
	//
	// [10] = [] clockSysvar
	// ··········· Clock sysvar
	//
	// [11] = [] tokenProgram
	// ··········· Token program
	ag_solanago.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

If the auction manager is in a Disbursing or Finished state, then this means Auction must be in Ended state. Then this end point can be used as a signed proxy to use auction manager's authority over the auction to claim bid funds into the accept payment account on the auction manager for a given bid. Auction has no opinions on how bids are redeemed, only that they exist, have been paid, and have a winning place. It is up to the implementer of the auction to determine redemption, and auction manager does this via bid redemption tickets and the vault contract which ensure the user always can get their NFT once they have paid. Therefore, once they have paid, and the auction is over, the artist can claim funds at any time without any danger to the user of losing out on their NFT, because the AM will honor their bid with an NFT at ANY time.

func NewClaimBidInstruction 

func NewClaimBidInstruction(

	acceptPayment ag_solanago.PublicKey,
	bidderPotToken ag_solanago.PublicKey,
	bidderPotPDA ag_solanago.PublicKey,
	auctionManager ag_solanago.PublicKey,
	auction ag_solanago.PublicKey,
	bidderWallet ag_solanago.PublicKey,
	tokenMint ag_solanago.PublicKey,
	vault ag_solanago.PublicKey,
	store ag_solanago.PublicKey,
	auctionProgram ag_solanago.PublicKey,
	clockSysvar ag_solanago.PublicKey,
	tokenProgram ag_solanago.PublicKey) *ClaimBid

NewClaimBidInstruction declares a new ClaimBid instruction with the provided parameters and accounts.

func NewClaimBidInstructionBuilder 

func NewClaimBidInstructionBuilder() *ClaimBid

NewClaimBidInstructionBuilder creates a new `ClaimBid` instruction builder.

func (ClaimBid) Build 

func (inst ClaimBid) Build() *Instruction

func (*ClaimBid) EncodeToTree 

func (inst *ClaimBid) EncodeToTree(parent ag_treeout.Branches)

func (*ClaimBid) GetAcceptPaymentAccount 

func (inst *ClaimBid) GetAcceptPaymentAccount() *ag_solanago.AccountMeta

GetAcceptPaymentAccount gets the "acceptPayment" account. The accept payment account on the auction manager

func (*ClaimBid) GetAuctionAccount 

func (inst *ClaimBid) GetAuctionAccount() *ag_solanago.AccountMeta

GetAuctionAccount gets the "auction" account. The auction

func (*ClaimBid) GetAuctionManagerAccount 

func (inst *ClaimBid) GetAuctionManagerAccount() *ag_solanago.AccountMeta

GetAuctionManagerAccount gets the "auctionManager" account. Auction manager

func (*ClaimBid) GetAuctionProgramAccount 

func (inst *ClaimBid) GetAuctionProgramAccount() *ag_solanago.AccountMeta

GetAuctionProgramAccount gets the "auctionProgram" account. Auction program

func (*ClaimBid) GetBidderPotPDAAccount 

func (inst *ClaimBid) GetBidderPotPDAAccount() *ag_solanago.AccountMeta

GetBidderPotPDAAccount gets the "bidderPotPDA" account. The bidder pot pda account [seed of ['auction', program_id, auction key, bidder key] - relative to the auction program, not auction manager

func (*ClaimBid) GetBidderPotTokenAccount 

func (inst *ClaimBid) GetBidderPotTokenAccount() *ag_solanago.AccountMeta

GetBidderPotTokenAccount gets the "bidderPotToken" account. The bidder pot token account

func (*ClaimBid) GetBidderWalletAccount 

func (inst *ClaimBid) GetBidderWalletAccount() *ag_solanago.AccountMeta

GetBidderWalletAccount gets the "bidderWallet" account. The bidder wallet

func (*ClaimBid) GetClockSysvarAccount 

func (inst *ClaimBid) GetClockSysvarAccount() *ag_solanago.AccountMeta

GetClockSysvarAccount gets the "clockSysvar" account. Clock sysvar

func (*ClaimBid) GetStoreAccount 

func (inst *ClaimBid) GetStoreAccount() *ag_solanago.AccountMeta

GetStoreAccount gets the "store" account. Store

func (*ClaimBid) GetTokenMintAccount 

func (inst *ClaimBid) GetTokenMintAccount() *ag_solanago.AccountMeta

GetTokenMintAccount gets the "tokenMint" account. Token mint of the auction

func (*ClaimBid) GetTokenProgramAccount 

func (inst *ClaimBid) GetTokenProgramAccount() *ag_solanago.AccountMeta

GetTokenProgramAccount gets the "tokenProgram" account. Token program

func (*ClaimBid) GetVaultAccount 

func (inst *ClaimBid) GetVaultAccount() *ag_solanago.AccountMeta

GetVaultAccount gets the "vault" account. Vault

func (ClaimBid) MarshalWithEncoder 

func (obj ClaimBid) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*ClaimBid) SetAcceptPaymentAccount 

func (inst *ClaimBid) SetAcceptPaymentAccount(acceptPayment ag_solanago.PublicKey) *ClaimBid

SetAcceptPaymentAccount sets the "acceptPayment" account. The accept payment account on the auction manager

func (*ClaimBid) SetAuctionAccount 

func (inst *ClaimBid) SetAuctionAccount(auction ag_solanago.PublicKey) *ClaimBid

SetAuctionAccount sets the "auction" account. The auction

func (*ClaimBid) SetAuctionManagerAccount 

func (inst *ClaimBid) SetAuctionManagerAccount(auctionManager ag_solanago.PublicKey) *ClaimBid

SetAuctionManagerAccount sets the "auctionManager" account. Auction manager

func (*ClaimBid) SetAuctionProgramAccount 

func (inst *ClaimBid) SetAuctionProgramAccount(auctionProgram ag_solanago.PublicKey) *ClaimBid

SetAuctionProgramAccount sets the "auctionProgram" account. Auction program

func (*ClaimBid) SetBidderPotPDAAccount 

func (inst *ClaimBid) SetBidderPotPDAAccount(bidderPotPDA ag_solanago.PublicKey) *ClaimBid

SetBidderPotPDAAccount sets the "bidderPotPDA" account. The bidder pot pda account [seed of ['auction', program_id, auction key, bidder key] - relative to the auction program, not auction manager

func (*ClaimBid) SetBidderPotTokenAccount 

func (inst *ClaimBid) SetBidderPotTokenAccount(bidderPotToken ag_solanago.PublicKey) *ClaimBid

SetBidderPotTokenAccount sets the "bidderPotToken" account. The bidder pot token account

func (*ClaimBid) SetBidderWalletAccount 

func (inst *ClaimBid) SetBidderWalletAccount(bidderWallet ag_solanago.PublicKey) *ClaimBid

SetBidderWalletAccount sets the "bidderWallet" account. The bidder wallet

func (*ClaimBid) SetClockSysvarAccount 

func (inst *ClaimBid) SetClockSysvarAccount(clockSysvar ag_solanago.PublicKey) *ClaimBid

SetClockSysvarAccount sets the "clockSysvar" account. Clock sysvar

func (*ClaimBid) SetStoreAccount 

func (inst *ClaimBid) SetStoreAccount(store ag_solanago.PublicKey) *ClaimBid

SetStoreAccount sets the "store" account. Store

func (*ClaimBid) SetTokenMintAccount 

func (inst *ClaimBid) SetTokenMintAccount(tokenMint ag_solanago.PublicKey) *ClaimBid

SetTokenMintAccount sets the "tokenMint" account. Token mint of the auction

func (*ClaimBid) SetTokenProgramAccount 

func (inst *ClaimBid) SetTokenProgramAccount(tokenProgram ag_solanago.PublicKey) *ClaimBid

SetTokenProgramAccount sets the "tokenProgram" account. Token program

func (*ClaimBid) SetVaultAccount 

func (inst *ClaimBid) SetVaultAccount(vault ag_solanago.PublicKey) *ClaimBid

SetVaultAccount sets the "vault" account. Vault

func (*ClaimBid) UnmarshalWithDecoder 

func (obj *ClaimBid) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

func (*ClaimBid) Validate 

func (inst *ClaimBid) Validate() error

func (ClaimBid) ValidateAndBuild 

func (inst ClaimBid) ValidateAndBuild() (*Instruction, error)

ValidateAndBuild validates the instruction parameters and accounts; if there is a validation error, it returns the error. Otherwise, it builds and returns the instruction.

type CommonWinningIndexReturn 

type CommonWinningIndexReturn struct {
	Amount                 uint64
	WinningConfigType      WinningConfigType
	WinningConfigItemIndex *uint8 `bin:"optional"`
}

func (CommonWinningIndexReturn) MarshalWithEncoder 

func (obj CommonWinningIndexReturn) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*CommonWinningIndexReturn) UnmarshalWithDecoder 

func (obj *CommonWinningIndexReturn) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type DecommissionAuctionManager 

type DecommissionAuctionManager struct {

	// [0] = [WRITE] auctionManager
	// ··········· Auction Manager
	//
	// [1] = [WRITE] auction
	// ··········· Auction
	//
	// [2] = [SIGNER] auctionManagerAuthority
	// ··········· Authority of the Auction Manager
	//
	// [3] = [WRITE] vault
	// ··········· Vault
	//
	// [4] = [] store
	// ··········· Store
	//
	// [5] = [] auctionProgram
	// ··········· Auction program
	//
	// [6] = [] clockSysvar
	// ··········· Clock sysvar
	//
	// [7] = [] vaultProgram
	// ··········· Vault program (Optional)
	ag_solanago.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

If you have an auction manager in an Initialized state and for some reason you can't validate it, you want to retrieve The items inside of it. This will allow you to move it straight to Disbursing, and then you can, as Auctioneer, Redeem those items using the RedeemUnusedWinningConfigItemsAsAuctioneer endpoint.

If you pass the vault program account, authority over the vault will be returned to you, so you can unwind the vault to get your items back that way instead.

Be WARNED: Because the boxes have not been validated, the logic for redemptions may not work quite right. For instance, if your validation step failed because you provided an empty box but said there was a token in it, when you go and try to redeem it, you yourself will experience quite the explosion. It will be up to you to tactfully request the bids that can be properly redeemed from the ones that cannot.

If you had a FullRightsTransfer token, and you never validated (and thus transferred) ownership, when the redemption happens it will skip trying to transfer it to you, so that should work fine.

func NewDecommissionAuctionManagerInstruction 

func NewDecommissionAuctionManagerInstruction(

	auctionManager ag_solanago.PublicKey,
	auction ag_solanago.PublicKey,
	auctionManagerAuthority ag_solanago.PublicKey,
	vault ag_solanago.PublicKey,
	store ag_solanago.PublicKey,
	auctionProgram ag_solanago.PublicKey,
	clockSysvar ag_solanago.PublicKey,
	vaultProgram ag_solanago.PublicKey) *DecommissionAuctionManager

NewDecommissionAuctionManagerInstruction declares a new DecommissionAuctionManager instruction with the provided parameters and accounts.

func NewDecommissionAuctionManagerInstructionBuilder 

func NewDecommissionAuctionManagerInstructionBuilder() *DecommissionAuctionManager

NewDecommissionAuctionManagerInstructionBuilder creates a new `DecommissionAuctionManager` instruction builder.

func (DecommissionAuctionManager) Build 

func (inst DecommissionAuctionManager) Build() *Instruction

func (*DecommissionAuctionManager) EncodeToTree 

func (inst *DecommissionAuctionManager) EncodeToTree(parent ag_treeout.Branches)

func (*DecommissionAuctionManager) GetAuctionAccount 

func (inst *DecommissionAuctionManager) GetAuctionAccount() *ag_solanago.AccountMeta

GetAuctionAccount gets the "auction" account. Auction

func (*DecommissionAuctionManager) GetAuctionManagerAccount 

func (inst *DecommissionAuctionManager) GetAuctionManagerAccount() *ag_solanago.AccountMeta

GetAuctionManagerAccount gets the "auctionManager" account. Auction Manager

func (*DecommissionAuctionManager) GetAuctionManagerAuthorityAccount 

func (inst *DecommissionAuctionManager) GetAuctionManagerAuthorityAccount() *ag_solanago.AccountMeta

GetAuctionManagerAuthorityAccount gets the "auctionManagerAuthority" account. Authority of the Auction Manager

func (*DecommissionAuctionManager) GetAuctionProgramAccount 

func (inst *DecommissionAuctionManager) GetAuctionProgramAccount() *ag_solanago.AccountMeta

GetAuctionProgramAccount gets the "auctionProgram" account. Auction program

func (*DecommissionAuctionManager) GetClockSysvarAccount 

func (inst *DecommissionAuctionManager) GetClockSysvarAccount() *ag_solanago.AccountMeta

GetClockSysvarAccount gets the "clockSysvar" account. Clock sysvar

func (*DecommissionAuctionManager) GetStoreAccount 

func (inst *DecommissionAuctionManager) GetStoreAccount() *ag_solanago.AccountMeta

GetStoreAccount gets the "store" account. Store

func (*DecommissionAuctionManager) GetVaultAccount 

func (inst *DecommissionAuctionManager) GetVaultAccount() *ag_solanago.AccountMeta

GetVaultAccount gets the "vault" account. Vault

func (*DecommissionAuctionManager) GetVaultProgramAccount 

func (inst *DecommissionAuctionManager) GetVaultProgramAccount() *ag_solanago.AccountMeta

GetVaultProgramAccount gets the "vaultProgram" account. Vault program (Optional)

func (DecommissionAuctionManager) MarshalWithEncoder 

func (obj DecommissionAuctionManager) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*DecommissionAuctionManager) SetAuctionAccount 

func (inst *DecommissionAuctionManager) SetAuctionAccount(auction ag_solanago.PublicKey) *DecommissionAuctionManager

SetAuctionAccount sets the "auction" account. Auction

func (*DecommissionAuctionManager) SetAuctionManagerAccount 

func (inst *DecommissionAuctionManager) SetAuctionManagerAccount(auctionManager ag_solanago.PublicKey) *DecommissionAuctionManager

SetAuctionManagerAccount sets the "auctionManager" account. Auction Manager

func (*DecommissionAuctionManager) SetAuctionManagerAuthorityAccount 

func (inst *DecommissionAuctionManager) SetAuctionManagerAuthorityAccount(auctionManagerAuthority ag_solanago.PublicKey) *DecommissionAuctionManager

SetAuctionManagerAuthorityAccount sets the "auctionManagerAuthority" account. Authority of the Auction Manager

func (*DecommissionAuctionManager) SetAuctionProgramAccount 

func (inst *DecommissionAuctionManager) SetAuctionProgramAccount(auctionProgram ag_solanago.PublicKey) *DecommissionAuctionManager

SetAuctionProgramAccount sets the "auctionProgram" account. Auction program

func (*DecommissionAuctionManager) SetClockSysvarAccount 

func (inst *DecommissionAuctionManager) SetClockSysvarAccount(clockSysvar ag_solanago.PublicKey) *DecommissionAuctionManager

SetClockSysvarAccount sets the "clockSysvar" account. Clock sysvar

func (*DecommissionAuctionManager) SetStoreAccount 

func (inst *DecommissionAuctionManager) SetStoreAccount(store ag_solanago.PublicKey) *DecommissionAuctionManager

SetStoreAccount sets the "store" account. Store

func (*DecommissionAuctionManager) SetVaultAccount 

func (inst *DecommissionAuctionManager) SetVaultAccount(vault ag_solanago.PublicKey) *DecommissionAuctionManager

SetVaultAccount sets the "vault" account. Vault

func (*DecommissionAuctionManager) SetVaultProgramAccount 

func (inst *DecommissionAuctionManager) SetVaultProgramAccount(vaultProgram ag_solanago.PublicKey) *DecommissionAuctionManager

SetVaultProgramAccount sets the "vaultProgram" account. Vault program (Optional)

func (*DecommissionAuctionManager) UnmarshalWithDecoder 

func (obj *DecommissionAuctionManager) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

func (*DecommissionAuctionManager) Validate 

func (inst *DecommissionAuctionManager) Validate() error

func (DecommissionAuctionManager) ValidateAndBuild 

func (inst DecommissionAuctionManager) ValidateAndBuild() (*Instruction, error)

ValidateAndBuild validates the instruction parameters and accounts; if there is a validation error, it returns the error. Otherwise, it builds and returns the instruction.

type DeprecatedInitAuctionManagerV1 

type DeprecatedInitAuctionManagerV1 struct {
	Args *AuctionManagerSettingsV1

	// [0] = [WRITE] uninitializedUnallocatedAuctionManager
	// ··········· Uninitialized, unallocated auction manager account with pda of ['metaplex', auction_key from auction referenced below]
	//
	// [1] = [] combinedVault
	// ··········· Combined vault account with authority set to auction manager account (this will be checked)
	// ··········· Note in addition that this vault account should have authority set to this program's pda of ['metaplex', auction_key]
	//
	// [2] = [] auction
	// ··········· Auction with auctioned item being set to the vault given and authority set to this program's pda of ['metaplex', auction_key]
	//
	// [3] = [] authority
	// ··········· Authority for the Auction Manager
	//
	// [4] = [SIGNER] payer
	// ··········· Payer
	//
	// [5] = [] acceptPayment
	// ··········· Accept payment account of same token mint as the auction for taking payment for open editions, owner should be auction manager key
	//
	// [6] = [] store
	// ··········· Store that this auction manager will belong to
	//
	// [7] = [] systemSysvar
	// ··········· System sysvar
	//
	// [8] = [] rentSysvar
	// ··········· Rent sysvar
	ag_solanago.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

Initializes an Auction Manager V1

func NewDeprecatedInitAuctionManagerV1Instruction 

func NewDeprecatedInitAuctionManagerV1Instruction(

	args AuctionManagerSettingsV1,

	uninitializedUnallocatedAuctionManager ag_solanago.PublicKey,
	combinedVault ag_solanago.PublicKey,
	auction ag_solanago.PublicKey,
	authority ag_solanago.PublicKey,
	payer ag_solanago.PublicKey,
	acceptPayment ag_solanago.PublicKey,
	store ag_solanago.PublicKey,
	systemSysvar ag_solanago.PublicKey,
	rentSysvar ag_solanago.PublicKey) *DeprecatedInitAuctionManagerV1

NewDeprecatedInitAuctionManagerV1Instruction declares a new DeprecatedInitAuctionManagerV1 instruction with the provided parameters and accounts.

func NewDeprecatedInitAuctionManagerV1InstructionBuilder 

func NewDeprecatedInitAuctionManagerV1InstructionBuilder() *DeprecatedInitAuctionManagerV1

NewDeprecatedInitAuctionManagerV1InstructionBuilder creates a new `DeprecatedInitAuctionManagerV1` instruction builder.

func (DeprecatedInitAuctionManagerV1) Build 

func (inst DeprecatedInitAuctionManagerV1) Build() *Instruction

func (*DeprecatedInitAuctionManagerV1) EncodeToTree 

func (inst *DeprecatedInitAuctionManagerV1) EncodeToTree(parent ag_treeout.Branches)

func (*DeprecatedInitAuctionManagerV1) GetAcceptPaymentAccount 

func (inst *DeprecatedInitAuctionManagerV1) GetAcceptPaymentAccount() *ag_solanago.AccountMeta

GetAcceptPaymentAccount gets the "acceptPayment" account. Accept payment account of same token mint as the auction for taking payment for open editions, owner should be auction manager key

func (*DeprecatedInitAuctionManagerV1) GetAuctionAccount 

func (inst *DeprecatedInitAuctionManagerV1) GetAuctionAccount() *ag_solanago.AccountMeta

GetAuctionAccount gets the "auction" account. Auction with auctioned item being set to the vault given and authority set to this program's pda of ['metaplex', auction_key]

func (*DeprecatedInitAuctionManagerV1) GetAuthorityAccount 

func (inst *DeprecatedInitAuctionManagerV1) GetAuthorityAccount() *ag_solanago.AccountMeta

GetAuthorityAccount gets the "authority" account. Authority for the Auction Manager

func (*DeprecatedInitAuctionManagerV1) GetCombinedVaultAccount 

func (inst *DeprecatedInitAuctionManagerV1) GetCombinedVaultAccount() *ag_solanago.AccountMeta

GetCombinedVaultAccount gets the "combinedVault" account. Combined vault account with authority set to auction manager account (this will be checked) Note in addition that this vault account should have authority set to this program's pda of ['metaplex', auction_key]

func (*DeprecatedInitAuctionManagerV1) GetPayerAccount 

func (inst *DeprecatedInitAuctionManagerV1) GetPayerAccount() *ag_solanago.AccountMeta

GetPayerAccount gets the "payer" account. Payer

func (*DeprecatedInitAuctionManagerV1) GetRentSysvarAccount 

func (inst *DeprecatedInitAuctionManagerV1) GetRentSysvarAccount() *ag_solanago.AccountMeta

GetRentSysvarAccount gets the "rentSysvar" account. Rent sysvar

func (*DeprecatedInitAuctionManagerV1) GetStoreAccount 

func (inst *DeprecatedInitAuctionManagerV1) GetStoreAccount() *ag_solanago.AccountMeta

GetStoreAccount gets the "store" account. Store that this auction manager will belong to

func (*DeprecatedInitAuctionManagerV1) GetSystemSysvarAccount 

func (inst *DeprecatedInitAuctionManagerV1) GetSystemSysvarAccount() *ag_solanago.AccountMeta

GetSystemSysvarAccount gets the "systemSysvar" account. System sysvar

func (*DeprecatedInitAuctionManagerV1) GetUninitializedUnallocatedAuctionManagerAccount 

func (inst *DeprecatedInitAuctionManagerV1) GetUninitializedUnallocatedAuctionManagerAccount() *ag_solanago.AccountMeta

GetUninitializedUnallocatedAuctionManagerAccount gets the "uninitializedUnallocatedAuctionManager" account. Uninitialized, unallocated auction manager account with pda of ['metaplex', auction_key from auction referenced below]

func (DeprecatedInitAuctionManagerV1) MarshalWithEncoder 

func (obj DeprecatedInitAuctionManagerV1) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*DeprecatedInitAuctionManagerV1) SetAcceptPaymentAccount 

func (inst *DeprecatedInitAuctionManagerV1) SetAcceptPaymentAccount(acceptPayment ag_solanago.PublicKey) *DeprecatedInitAuctionManagerV1

SetAcceptPaymentAccount sets the "acceptPayment" account. Accept payment account of same token mint as the auction for taking payment for open editions, owner should be auction manager key

func (*DeprecatedInitAuctionManagerV1) SetArgs 

func (inst *DeprecatedInitAuctionManagerV1) SetArgs(args AuctionManagerSettingsV1) *DeprecatedInitAuctionManagerV1

SetArgs sets the "args" parameter.

func (*DeprecatedInitAuctionManagerV1) SetAuctionAccount 

func (inst *DeprecatedInitAuctionManagerV1) SetAuctionAccount(auction ag_solanago.PublicKey) *DeprecatedInitAuctionManagerV1

SetAuctionAccount sets the "auction" account. Auction with auctioned item being set to the vault given and authority set to this program's pda of ['metaplex', auction_key]

func (*DeprecatedInitAuctionManagerV1) SetAuthorityAccount 

func (inst *DeprecatedInitAuctionManagerV1) SetAuthorityAccount(authority ag_solanago.PublicKey) *DeprecatedInitAuctionManagerV1

SetAuthorityAccount sets the "authority" account. Authority for the Auction Manager

func (*DeprecatedInitAuctionManagerV1) SetCombinedVaultAccount 

func (inst *DeprecatedInitAuctionManagerV1) SetCombinedVaultAccount(combinedVault ag_solanago.PublicKey) *DeprecatedInitAuctionManagerV1

SetCombinedVaultAccount sets the "combinedVault" account. Combined vault account with authority set to auction manager account (this will be checked) Note in addition that this vault account should have authority set to this program's pda of ['metaplex', auction_key]

func (*DeprecatedInitAuctionManagerV1) SetPayerAccount 

func (inst *DeprecatedInitAuctionManagerV1) SetPayerAccount(payer ag_solanago.PublicKey) *DeprecatedInitAuctionManagerV1

SetPayerAccount sets the "payer" account. Payer

func (*DeprecatedInitAuctionManagerV1) SetRentSysvarAccount 

func (inst *DeprecatedInitAuctionManagerV1) SetRentSysvarAccount(rentSysvar ag_solanago.PublicKey) *DeprecatedInitAuctionManagerV1

SetRentSysvarAccount sets the "rentSysvar" account. Rent sysvar

func (*DeprecatedInitAuctionManagerV1) SetStoreAccount 

func (inst *DeprecatedInitAuctionManagerV1) SetStoreAccount(store ag_solanago.PublicKey) *DeprecatedInitAuctionManagerV1

SetStoreAccount sets the "store" account. Store that this auction manager will belong to

func (*DeprecatedInitAuctionManagerV1) SetSystemSysvarAccount 

func (inst *DeprecatedInitAuctionManagerV1) SetSystemSysvarAccount(systemSysvar ag_solanago.PublicKey) *DeprecatedInitAuctionManagerV1

SetSystemSysvarAccount sets the "systemSysvar" account. System sysvar

func (*DeprecatedInitAuctionManagerV1) SetUninitializedUnallocatedAuctionManagerAccount 

func (inst *DeprecatedInitAuctionManagerV1) SetUninitializedUnallocatedAuctionManagerAccount(uninitializedUnallocatedAuctionManager ag_solanago.PublicKey) *DeprecatedInitAuctionManagerV1

SetUninitializedUnallocatedAuctionManagerAccount sets the "uninitializedUnallocatedAuctionManager" account. Uninitialized, unallocated auction manager account with pda of ['metaplex', auction_key from auction referenced below]

func (*DeprecatedInitAuctionManagerV1) UnmarshalWithDecoder 

func (obj *DeprecatedInitAuctionManagerV1) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

func (*DeprecatedInitAuctionManagerV1) Validate 

func (inst *DeprecatedInitAuctionManagerV1) Validate() error

func (DeprecatedInitAuctionManagerV1) ValidateAndBuild 

func (inst DeprecatedInitAuctionManagerV1) ValidateAndBuild() (*Instruction, error)

ValidateAndBuild validates the instruction parameters and accounts; if there is a validation error, it returns the error. Otherwise, it builds and returns the instruction.

type DeprecatedPopulateParticipationPrintingAccount 

type DeprecatedPopulateParticipationPrintingAccount struct {

	// [0] = [WRITE] safetyDepositTokenStorage
	// ··········· Safety deposit token store
	//
	// [1] = [WRITE] transientAccount
	// ··········· Transient account with mint of one time authorization account on master edition - you can delete after this txn
	//
	// [2] = [WRITE] printingToken
	// ··········· The printing token account on the participation state of the auction manager
	//
	// [3] = [WRITE] oneTimePrintingAuthorizationMint
	// ··········· One time printing authorization mint
	//
	// [4] = [WRITE] printingMint
	// ··········· Printing mint
	//
	// [5] = [WRITE] participationPrizeSafetyDeposit
	// ··········· Safety deposit of the participation prize
	//
	// [6] = [WRITE] vaultInfo
	// ··········· Vault info
	//
	// [7] = [] fractionMint
	// ··········· Fraction mint
	//
	// [8] = [] auctionInfo
	// ··········· Auction info
	//
	// [9] = [] auctionManagerInfo
	// ··········· Auction manager info
	//
	// [10] = [] tokenProgram
	// ··········· Token program
	//
	// [11] = [] tokenVaultProgram
	// ··········· Token vault program
	//
	// [12] = [] tokenMetadataProgram
	// ··········· Token metadata program
	//
	// [13] = [] auctionManagerStore
	// ··········· Auction manager store
	//
	// [14] = [] masterEdition
	// ··········· Master edition
	//
	// [15] = [] pdaBasedTransferAuthority
	// ··········· PDA-based Transfer authority to move the tokens from the store to the destination seed ['vault', program_id]
	// ··········· but please note that this is a PDA relative to the Token Vault program, with the 'vault' prefix
	//
	// [16] = [] payerWithRefund
	// ··········· Payer who wishes to receive refund for closing of one time transient account once we're done here
	//
	// [17] = [] rent
	// ··········· Rent
	ag_solanago.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

NOTE: Requires an AuctionManagerV1. Needs to be called by someone at the end of the auction - will use the one time authorization token to fire up a bunch of printing tokens for use in participation redemptions.

func NewDeprecatedPopulateParticipationPrintingAccountInstruction 

func NewDeprecatedPopulateParticipationPrintingAccountInstruction(

	safetyDepositTokenStorage ag_solanago.PublicKey,
	transientAccount ag_solanago.PublicKey,
	printingToken ag_solanago.PublicKey,
	oneTimePrintingAuthorizationMint ag_solanago.PublicKey,
	printingMint ag_solanago.PublicKey,
	participationPrizeSafetyDeposit ag_solanago.PublicKey,
	vaultInfo ag_solanago.PublicKey,
	fractionMint ag_solanago.PublicKey,
	auctionInfo ag_solanago.PublicKey,
	auctionManagerInfo ag_solanago.PublicKey,
	tokenProgram ag_solanago.PublicKey,
	tokenVaultProgram ag_solanago.PublicKey,
	tokenMetadataProgram ag_solanago.PublicKey,
	auctionManagerStore ag_solanago.PublicKey,
	masterEdition ag_solanago.PublicKey,
	pdaBasedTransferAuthority ag_solanago.PublicKey,
	payerWithRefund ag_solanago.PublicKey,
	rent ag_solanago.PublicKey) *DeprecatedPopulateParticipationPrintingAccount

NewDeprecatedPopulateParticipationPrintingAccountInstruction declares a new DeprecatedPopulateParticipationPrintingAccount instruction with the provided parameters and accounts.

func NewDeprecatedPopulateParticipationPrintingAccountInstructionBuilder 

func NewDeprecatedPopulateParticipationPrintingAccountInstructionBuilder() *DeprecatedPopulateParticipationPrintingAccount

NewDeprecatedPopulateParticipationPrintingAccountInstructionBuilder creates a new `DeprecatedPopulateParticipationPrintingAccount` instruction builder.

func (DeprecatedPopulateParticipationPrintingAccount) Build 

func (inst DeprecatedPopulateParticipationPrintingAccount) Build() *Instruction

func (*DeprecatedPopulateParticipationPrintingAccount) EncodeToTree 

func (inst *DeprecatedPopulateParticipationPrintingAccount) EncodeToTree(parent ag_treeout.Branches)

func (*DeprecatedPopulateParticipationPrintingAccount) GetAuctionInfoAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) GetAuctionInfoAccount() *ag_solanago.AccountMeta

GetAuctionInfoAccount gets the "auctionInfo" account. Auction info

func (*DeprecatedPopulateParticipationPrintingAccount) GetAuctionManagerInfoAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) GetAuctionManagerInfoAccount() *ag_solanago.AccountMeta

GetAuctionManagerInfoAccount gets the "auctionManagerInfo" account. Auction manager info

func (*DeprecatedPopulateParticipationPrintingAccount) GetAuctionManagerStoreAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) GetAuctionManagerStoreAccount() *ag_solanago.AccountMeta

GetAuctionManagerStoreAccount gets the "auctionManagerStore" account. Auction manager store

func (*DeprecatedPopulateParticipationPrintingAccount) GetFractionMintAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) GetFractionMintAccount() *ag_solanago.AccountMeta

GetFractionMintAccount gets the "fractionMint" account. Fraction mint

func (*DeprecatedPopulateParticipationPrintingAccount) GetMasterEditionAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) GetMasterEditionAccount() *ag_solanago.AccountMeta

GetMasterEditionAccount gets the "masterEdition" account. Master edition

func (*DeprecatedPopulateParticipationPrintingAccount) GetOneTimePrintingAuthorizationMintAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) GetOneTimePrintingAuthorizationMintAccount() *ag_solanago.AccountMeta

GetOneTimePrintingAuthorizationMintAccount gets the "oneTimePrintingAuthorizationMint" account. One time printing authorization mint

func (*DeprecatedPopulateParticipationPrintingAccount) GetParticipationPrizeSafetyDepositAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) GetParticipationPrizeSafetyDepositAccount() *ag_solanago.AccountMeta

GetParticipationPrizeSafetyDepositAccount gets the "participationPrizeSafetyDeposit" account. Safety deposit of the participation prize

func (*DeprecatedPopulateParticipationPrintingAccount) GetPayerWithRefundAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) GetPayerWithRefundAccount() *ag_solanago.AccountMeta

GetPayerWithRefundAccount gets the "payerWithRefund" account. Payer who wishes to receive refund for closing of one time transient account once we're done here

func (*DeprecatedPopulateParticipationPrintingAccount) GetPdaBasedTransferAuthorityAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) GetPdaBasedTransferAuthorityAccount() *ag_solanago.AccountMeta

GetPdaBasedTransferAuthorityAccount gets the "pdaBasedTransferAuthority" account. PDA-based Transfer authority to move the tokens from the store to the destination seed ['vault', program_id] but please note that this is a PDA relative to the Token Vault program, with the 'vault' prefix

func (*DeprecatedPopulateParticipationPrintingAccount) GetPrintingMintAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) GetPrintingMintAccount() *ag_solanago.AccountMeta

GetPrintingMintAccount gets the "printingMint" account. Printing mint

func (*DeprecatedPopulateParticipationPrintingAccount) GetPrintingTokenAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) GetPrintingTokenAccount() *ag_solanago.AccountMeta

GetPrintingTokenAccount gets the "printingToken" account. The printing token account on the participation state of the auction manager

func (*DeprecatedPopulateParticipationPrintingAccount) GetRentAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) GetRentAccount() *ag_solanago.AccountMeta

GetRentAccount gets the "rent" account. Rent

func (*DeprecatedPopulateParticipationPrintingAccount) GetSafetyDepositTokenStorageAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) GetSafetyDepositTokenStorageAccount() *ag_solanago.AccountMeta

GetSafetyDepositTokenStorageAccount gets the "safetyDepositTokenStorage" account. Safety deposit token store

func (*DeprecatedPopulateParticipationPrintingAccount) GetTokenMetadataProgramAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) GetTokenMetadataProgramAccount() *ag_solanago.AccountMeta

GetTokenMetadataProgramAccount gets the "tokenMetadataProgram" account. Token metadata program

func (*DeprecatedPopulateParticipationPrintingAccount) GetTokenProgramAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) GetTokenProgramAccount() *ag_solanago.AccountMeta

GetTokenProgramAccount gets the "tokenProgram" account. Token program

func (*DeprecatedPopulateParticipationPrintingAccount) GetTokenVaultProgramAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) GetTokenVaultProgramAccount() *ag_solanago.AccountMeta

GetTokenVaultProgramAccount gets the "tokenVaultProgram" account. Token vault program

func (*DeprecatedPopulateParticipationPrintingAccount) GetTransientAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) GetTransientAccount() *ag_solanago.AccountMeta

GetTransientAccount gets the "transientAccount" account. Transient account with mint of one time authorization account on master edition - you can delete after this txn

func (*DeprecatedPopulateParticipationPrintingAccount) GetVaultInfoAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) GetVaultInfoAccount() *ag_solanago.AccountMeta

GetVaultInfoAccount gets the "vaultInfo" account. Vault info

func (DeprecatedPopulateParticipationPrintingAccount) MarshalWithEncoder 

func (obj DeprecatedPopulateParticipationPrintingAccount) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*DeprecatedPopulateParticipationPrintingAccount) SetAuctionInfoAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) SetAuctionInfoAccount(auctionInfo ag_solanago.PublicKey) *DeprecatedPopulateParticipationPrintingAccount

SetAuctionInfoAccount sets the "auctionInfo" account. Auction info

func (*DeprecatedPopulateParticipationPrintingAccount) SetAuctionManagerInfoAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) SetAuctionManagerInfoAccount(auctionManagerInfo ag_solanago.PublicKey) *DeprecatedPopulateParticipationPrintingAccount

SetAuctionManagerInfoAccount sets the "auctionManagerInfo" account. Auction manager info

func (*DeprecatedPopulateParticipationPrintingAccount) SetAuctionManagerStoreAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) SetAuctionManagerStoreAccount(auctionManagerStore ag_solanago.PublicKey) *DeprecatedPopulateParticipationPrintingAccount

SetAuctionManagerStoreAccount sets the "auctionManagerStore" account. Auction manager store

func (*DeprecatedPopulateParticipationPrintingAccount) SetFractionMintAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) SetFractionMintAccount(fractionMint ag_solanago.PublicKey) *DeprecatedPopulateParticipationPrintingAccount

SetFractionMintAccount sets the "fractionMint" account. Fraction mint

func (*DeprecatedPopulateParticipationPrintingAccount) SetMasterEditionAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) SetMasterEditionAccount(masterEdition ag_solanago.PublicKey) *DeprecatedPopulateParticipationPrintingAccount

SetMasterEditionAccount sets the "masterEdition" account. Master edition

func (*DeprecatedPopulateParticipationPrintingAccount) SetOneTimePrintingAuthorizationMintAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) SetOneTimePrintingAuthorizationMintAccount(oneTimePrintingAuthorizationMint ag_solanago.PublicKey) *DeprecatedPopulateParticipationPrintingAccount

SetOneTimePrintingAuthorizationMintAccount sets the "oneTimePrintingAuthorizationMint" account. One time printing authorization mint

func (*DeprecatedPopulateParticipationPrintingAccount) SetParticipationPrizeSafetyDepositAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) SetParticipationPrizeSafetyDepositAccount(participationPrizeSafetyDeposit ag_solanago.PublicKey) *DeprecatedPopulateParticipationPrintingAccount

SetParticipationPrizeSafetyDepositAccount sets the "participationPrizeSafetyDeposit" account. Safety deposit of the participation prize

func (*DeprecatedPopulateParticipationPrintingAccount) SetPayerWithRefundAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) SetPayerWithRefundAccount(payerWithRefund ag_solanago.PublicKey) *DeprecatedPopulateParticipationPrintingAccount

SetPayerWithRefundAccount sets the "payerWithRefund" account. Payer who wishes to receive refund for closing of one time transient account once we're done here

func (*DeprecatedPopulateParticipationPrintingAccount) SetPdaBasedTransferAuthorityAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) SetPdaBasedTransferAuthorityAccount(pdaBasedTransferAuthority ag_solanago.PublicKey) *DeprecatedPopulateParticipationPrintingAccount

SetPdaBasedTransferAuthorityAccount sets the "pdaBasedTransferAuthority" account. PDA-based Transfer authority to move the tokens from the store to the destination seed ['vault', program_id] but please note that this is a PDA relative to the Token Vault program, with the 'vault' prefix

func (*DeprecatedPopulateParticipationPrintingAccount) SetPrintingMintAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) SetPrintingMintAccount(printingMint ag_solanago.PublicKey) *DeprecatedPopulateParticipationPrintingAccount

SetPrintingMintAccount sets the "printingMint" account. Printing mint

func (*DeprecatedPopulateParticipationPrintingAccount) SetPrintingTokenAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) SetPrintingTokenAccount(printingToken ag_solanago.PublicKey) *DeprecatedPopulateParticipationPrintingAccount

SetPrintingTokenAccount sets the "printingToken" account. The printing token account on the participation state of the auction manager

func (*DeprecatedPopulateParticipationPrintingAccount) SetRentAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) SetRentAccount(rent ag_solanago.PublicKey) *DeprecatedPopulateParticipationPrintingAccount

SetRentAccount sets the "rent" account. Rent

func (*DeprecatedPopulateParticipationPrintingAccount) SetSafetyDepositTokenStorageAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) SetSafetyDepositTokenStorageAccount(safetyDepositTokenStorage ag_solanago.PublicKey) *DeprecatedPopulateParticipationPrintingAccount

SetSafetyDepositTokenStorageAccount sets the "safetyDepositTokenStorage" account. Safety deposit token store

func (*DeprecatedPopulateParticipationPrintingAccount) SetTokenMetadataProgramAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) SetTokenMetadataProgramAccount(tokenMetadataProgram ag_solanago.PublicKey) *DeprecatedPopulateParticipationPrintingAccount

SetTokenMetadataProgramAccount sets the "tokenMetadataProgram" account. Token metadata program

func (*DeprecatedPopulateParticipationPrintingAccount) SetTokenProgramAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) SetTokenProgramAccount(tokenProgram ag_solanago.PublicKey) *DeprecatedPopulateParticipationPrintingAccount

SetTokenProgramAccount sets the "tokenProgram" account. Token program

func (*DeprecatedPopulateParticipationPrintingAccount) SetTokenVaultProgramAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) SetTokenVaultProgramAccount(tokenVaultProgram ag_solanago.PublicKey) *DeprecatedPopulateParticipationPrintingAccount

SetTokenVaultProgramAccount sets the "tokenVaultProgram" account. Token vault program

func (*DeprecatedPopulateParticipationPrintingAccount) SetTransientAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) SetTransientAccount(transientAccount ag_solanago.PublicKey) *DeprecatedPopulateParticipationPrintingAccount

SetTransientAccount sets the "transientAccount" account. Transient account with mint of one time authorization account on master edition - you can delete after this txn

func (*DeprecatedPopulateParticipationPrintingAccount) SetVaultInfoAccount 

func (inst *DeprecatedPopulateParticipationPrintingAccount) SetVaultInfoAccount(vaultInfo ag_solanago.PublicKey) *DeprecatedPopulateParticipationPrintingAccount

SetVaultInfoAccount sets the "vaultInfo" account. Vault info

func (*DeprecatedPopulateParticipationPrintingAccount) UnmarshalWithDecoder 

func (obj *DeprecatedPopulateParticipationPrintingAccount) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

func (*DeprecatedPopulateParticipationPrintingAccount) Validate 

func (inst *DeprecatedPopulateParticipationPrintingAccount) Validate() error

func (DeprecatedPopulateParticipationPrintingAccount) ValidateAndBuild 

func (inst DeprecatedPopulateParticipationPrintingAccount) ValidateAndBuild() (*Instruction, error)

ValidateAndBuild validates the instruction parameters and accounts; if there is a validation error, it returns the error. Otherwise, it builds and returns the instruction.

type DeprecatedRedeemParticipationBid 

type DeprecatedRedeemParticipationBid struct {

	// [0] = [WRITE] auctionManager
	// ··········· Auction manager
	//
	// [1] = [WRITE] safetyDepositTokenStorage
	// ··········· Safety deposit token storage account
	//
	// [2] = [WRITE] destinationAccount
	// ··········· Destination account for limited edition authority token. Must be same mint as master edition Printing mint.
	//
	// [3] = [WRITE] bidRedemptionKey
	// ··········· Bid redemption key -
	// ··········· Just a PDA with seed ['metaplex', auction_key, bidder_metadata_key] that we will allocate to mark that you redeemed your bid
	//
	// [4] = [] safetyDepositBox
	// ··········· Safety deposit box account
	//
	// [5] = [] vaultAccount
	// ··········· Vault account
	//
	// [6] = [] safetyDepositConfig
	// ··········· Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit]
	// ··········· This account will only get used in the event this is an AuctionManagerV2
	//
	// [7] = [] auction
	// ··········· Auction
	//
	// [8] = [] bidderMetadata
	// ··········· Your BidderMetadata account
	//
	// [9] = [WRITE, SIGNER] bidder
	// ··········· Your Bidder account - Only needs to be signer if payer does not own
	//
	// [10] = [SIGNER] payer
	// ··········· Payer
	//
	// [11] = [] tokenProgram
	// ··········· Token program
	//
	// [12] = [] tokenVaultProgram
	// ··········· Token Vault program
	//
	// [13] = [] tokenMetadataProgram
	// ··········· Token metadata program
	//
	// [14] = [] store
	// ··········· Store
	//
	// [15] = [] system
	// ··········· System
	//
	// [16] = [] rentSysvar
	// ··········· Rent sysvar
	//
	// [17] = [SIGNER] transferAuthority
	// ··········· Transfer authority to move the payment in the auction's token_mint coin from the bidder account for the participation_fixed_price
	// ··········· on the auction manager to the auction manager account itself.
	//
	// [18] = [WRITE] acceptPayment
	// ··········· The accept payment account for the auction manager
	//
	// [19] = [WRITE] tokenAccount
	// ··········· The token account you will potentially pay for the open edition bid with if necessary
	//
	// [20] = [WRITE] participationNFTPrintingHoldingAccount
	// ··········· Participation NFT printing holding account (present on participation_state)
	ag_solanago.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

Note: This requires that auction manager be in a Running state.

If an auction is complete, you can redeem your bid for an Open Edition token if it is eligible. If you are the first to do this, The auction manager will switch from Running state to Disbursing state. If you are the last, this may change the auction manager state to Finished provided that no authorities remain to be delegated for Master Edition tokens.

NOTE: Please note that it is totally possible to redeem a bid 2x - once for a prize you won and once at this end point for a open edition that comes as a 'token of appreciation' for bidding. They are not mutually exclusive unless explicitly set to be that way.

NOTE: If you are redeeming a newly minted Open Edition, you must actually supply a destination account containing a token from a brand new mint. We do not provide the token to you. Our job with this action is to christen this mint + token combo as an official Open Edition.

func NewDeprecatedRedeemParticipationBidInstruction 

func NewDeprecatedRedeemParticipationBidInstruction(

	auctionManager ag_solanago.PublicKey,
	safetyDepositTokenStorage ag_solanago.PublicKey,
	destinationAccount ag_solanago.PublicKey,
	bidRedemptionKey ag_solanago.PublicKey,
	safetyDepositBox ag_solanago.PublicKey,
	vaultAccount ag_solanago.PublicKey,
	safetyDepositConfig ag_solanago.PublicKey,
	auction ag_solanago.PublicKey,
	bidderMetadata ag_solanago.PublicKey,
	bidder ag_solanago.PublicKey,
	payer ag_solanago.PublicKey,
	tokenProgram ag_solanago.PublicKey,
	tokenVaultProgram ag_solanago.PublicKey,
	tokenMetadataProgram ag_solanago.PublicKey,
	store ag_solanago.PublicKey,
	system ag_solanago.PublicKey,
	rentSysvar ag_solanago.PublicKey,
	transferAuthority ag_solanago.PublicKey,
	acceptPayment ag_solanago.PublicKey,
	tokenAccount ag_solanago.PublicKey,
	participationNFTPrintingHoldingAccount ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

NewDeprecatedRedeemParticipationBidInstruction declares a new DeprecatedRedeemParticipationBid instruction with the provided parameters and accounts.

func NewDeprecatedRedeemParticipationBidInstructionBuilder 

func NewDeprecatedRedeemParticipationBidInstructionBuilder() *DeprecatedRedeemParticipationBid

NewDeprecatedRedeemParticipationBidInstructionBuilder creates a new `DeprecatedRedeemParticipationBid` instruction builder.

func (DeprecatedRedeemParticipationBid) Build 

func (inst DeprecatedRedeemParticipationBid) Build() *Instruction

func (*DeprecatedRedeemParticipationBid) EncodeToTree 

func (inst *DeprecatedRedeemParticipationBid) EncodeToTree(parent ag_treeout.Branches)

func (*DeprecatedRedeemParticipationBid) GetAcceptPaymentAccount 

func (inst *DeprecatedRedeemParticipationBid) GetAcceptPaymentAccount() *ag_solanago.AccountMeta

GetAcceptPaymentAccount gets the "acceptPayment" account. The accept payment account for the auction manager

func (*DeprecatedRedeemParticipationBid) GetAuctionAccount 

func (inst *DeprecatedRedeemParticipationBid) GetAuctionAccount() *ag_solanago.AccountMeta

GetAuctionAccount gets the "auction" account. Auction

func (*DeprecatedRedeemParticipationBid) GetAuctionManagerAccount 

func (inst *DeprecatedRedeemParticipationBid) GetAuctionManagerAccount() *ag_solanago.AccountMeta

GetAuctionManagerAccount gets the "auctionManager" account. Auction manager

func (*DeprecatedRedeemParticipationBid) GetBidRedemptionKeyAccount 

func (inst *DeprecatedRedeemParticipationBid) GetBidRedemptionKeyAccount() *ag_solanago.AccountMeta

GetBidRedemptionKeyAccount gets the "bidRedemptionKey" account. Bid redemption key - Just a PDA with seed ['metaplex', auction_key, bidder_metadata_key] that we will allocate to mark that you redeemed your bid

func (*DeprecatedRedeemParticipationBid) GetBidderAccount 

func (inst *DeprecatedRedeemParticipationBid) GetBidderAccount() *ag_solanago.AccountMeta

GetBidderAccount gets the "bidder" account. Your Bidder account - Only needs to be signer if payer does not own

func (*DeprecatedRedeemParticipationBid) GetBidderMetadataAccount 

func (inst *DeprecatedRedeemParticipationBid) GetBidderMetadataAccount() *ag_solanago.AccountMeta

GetBidderMetadataAccount gets the "bidderMetadata" account. Your BidderMetadata account

func (*DeprecatedRedeemParticipationBid) GetDestinationAccount 

func (inst *DeprecatedRedeemParticipationBid) GetDestinationAccount() *ag_solanago.AccountMeta

GetDestinationAccount gets the "destinationAccount" account. Destination account for limited edition authority token. Must be same mint as master edition Printing mint.

func (*DeprecatedRedeemParticipationBid) GetParticipationNFTPrintingHoldingAccount 

func (inst *DeprecatedRedeemParticipationBid) GetParticipationNFTPrintingHoldingAccount() *ag_solanago.AccountMeta

GetParticipationNFTPrintingHoldingAccount gets the "participationNFTPrintingHoldingAccount" account. Participation NFT printing holding account (present on participation_state)

func (*DeprecatedRedeemParticipationBid) GetPayerAccount 

func (inst *DeprecatedRedeemParticipationBid) GetPayerAccount() *ag_solanago.AccountMeta

GetPayerAccount gets the "payer" account. Payer

func (*DeprecatedRedeemParticipationBid) GetRentSysvarAccount 

func (inst *DeprecatedRedeemParticipationBid) GetRentSysvarAccount() *ag_solanago.AccountMeta

GetRentSysvarAccount gets the "rentSysvar" account. Rent sysvar

func (*DeprecatedRedeemParticipationBid) GetSafetyDepositBoxAccount 

func (inst *DeprecatedRedeemParticipationBid) GetSafetyDepositBoxAccount() *ag_solanago.AccountMeta

GetSafetyDepositBoxAccount gets the "safetyDepositBox" account. Safety deposit box account

func (*DeprecatedRedeemParticipationBid) GetSafetyDepositConfigAccount 

func (inst *DeprecatedRedeemParticipationBid) GetSafetyDepositConfigAccount() *ag_solanago.AccountMeta

GetSafetyDepositConfigAccount gets the "safetyDepositConfig" account. Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit] This account will only get used in the event this is an AuctionManagerV2

func (*DeprecatedRedeemParticipationBid) GetSafetyDepositTokenStorageAccount 

func (inst *DeprecatedRedeemParticipationBid) GetSafetyDepositTokenStorageAccount() *ag_solanago.AccountMeta

GetSafetyDepositTokenStorageAccount gets the "safetyDepositTokenStorage" account. Safety deposit token storage account

func (*DeprecatedRedeemParticipationBid) GetStoreAccount 

func (inst *DeprecatedRedeemParticipationBid) GetStoreAccount() *ag_solanago.AccountMeta

GetStoreAccount gets the "store" account. Store

func (*DeprecatedRedeemParticipationBid) GetSystemAccount 

func (inst *DeprecatedRedeemParticipationBid) GetSystemAccount() *ag_solanago.AccountMeta

GetSystemAccount gets the "system" account. System

func (*DeprecatedRedeemParticipationBid) GetTokenAccount 

func (inst *DeprecatedRedeemParticipationBid) GetTokenAccount() *ag_solanago.AccountMeta

GetTokenAccount gets the "tokenAccount" account. The token account you will potentially pay for the open edition bid with if necessary

func (*DeprecatedRedeemParticipationBid) GetTokenMetadataProgramAccount 

func (inst *DeprecatedRedeemParticipationBid) GetTokenMetadataProgramAccount() *ag_solanago.AccountMeta

GetTokenMetadataProgramAccount gets the "tokenMetadataProgram" account. Token metadata program

func (*DeprecatedRedeemParticipationBid) GetTokenProgramAccount 

func (inst *DeprecatedRedeemParticipationBid) GetTokenProgramAccount() *ag_solanago.AccountMeta

GetTokenProgramAccount gets the "tokenProgram" account. Token program

func (*DeprecatedRedeemParticipationBid) GetTokenVaultProgramAccount 

func (inst *DeprecatedRedeemParticipationBid) GetTokenVaultProgramAccount() *ag_solanago.AccountMeta

GetTokenVaultProgramAccount gets the "tokenVaultProgram" account. Token Vault program

func (*DeprecatedRedeemParticipationBid) GetTransferAuthorityAccount 

func (inst *DeprecatedRedeemParticipationBid) GetTransferAuthorityAccount() *ag_solanago.AccountMeta

GetTransferAuthorityAccount gets the "transferAuthority" account. Transfer authority to move the payment in the auction's token_mint coin from the bidder account for the participation_fixed_price on the auction manager to the auction manager account itself.

func (*DeprecatedRedeemParticipationBid) GetVaultAccount 

func (inst *DeprecatedRedeemParticipationBid) GetVaultAccount() *ag_solanago.AccountMeta

GetVaultAccount gets the "vaultAccount" account. Vault account

func (DeprecatedRedeemParticipationBid) MarshalWithEncoder 

func (obj DeprecatedRedeemParticipationBid) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*DeprecatedRedeemParticipationBid) SetAcceptPaymentAccount 

func (inst *DeprecatedRedeemParticipationBid) SetAcceptPaymentAccount(acceptPayment ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetAcceptPaymentAccount sets the "acceptPayment" account. The accept payment account for the auction manager

func (*DeprecatedRedeemParticipationBid) SetAuctionAccount 

func (inst *DeprecatedRedeemParticipationBid) SetAuctionAccount(auction ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetAuctionAccount sets the "auction" account. Auction

func (*DeprecatedRedeemParticipationBid) SetAuctionManagerAccount 

func (inst *DeprecatedRedeemParticipationBid) SetAuctionManagerAccount(auctionManager ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetAuctionManagerAccount sets the "auctionManager" account. Auction manager

func (*DeprecatedRedeemParticipationBid) SetBidRedemptionKeyAccount 

func (inst *DeprecatedRedeemParticipationBid) SetBidRedemptionKeyAccount(bidRedemptionKey ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetBidRedemptionKeyAccount sets the "bidRedemptionKey" account. Bid redemption key - Just a PDA with seed ['metaplex', auction_key, bidder_metadata_key] that we will allocate to mark that you redeemed your bid

func (*DeprecatedRedeemParticipationBid) SetBidderAccount 

func (inst *DeprecatedRedeemParticipationBid) SetBidderAccount(bidder ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetBidderAccount sets the "bidder" account. Your Bidder account - Only needs to be signer if payer does not own

func (*DeprecatedRedeemParticipationBid) SetBidderMetadataAccount 

func (inst *DeprecatedRedeemParticipationBid) SetBidderMetadataAccount(bidderMetadata ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetBidderMetadataAccount sets the "bidderMetadata" account. Your BidderMetadata account

func (*DeprecatedRedeemParticipationBid) SetDestinationAccount 

func (inst *DeprecatedRedeemParticipationBid) SetDestinationAccount(destinationAccount ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetDestinationAccount sets the "destinationAccount" account. Destination account for limited edition authority token. Must be same mint as master edition Printing mint.

func (*DeprecatedRedeemParticipationBid) SetParticipationNFTPrintingHoldingAccount 

func (inst *DeprecatedRedeemParticipationBid) SetParticipationNFTPrintingHoldingAccount(participationNFTPrintingHoldingAccount ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetParticipationNFTPrintingHoldingAccount sets the "participationNFTPrintingHoldingAccount" account. Participation NFT printing holding account (present on participation_state)

func (*DeprecatedRedeemParticipationBid) SetPayerAccount 

func (inst *DeprecatedRedeemParticipationBid) SetPayerAccount(payer ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetPayerAccount sets the "payer" account. Payer

func (*DeprecatedRedeemParticipationBid) SetRentSysvarAccount 

func (inst *DeprecatedRedeemParticipationBid) SetRentSysvarAccount(rentSysvar ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetRentSysvarAccount sets the "rentSysvar" account. Rent sysvar

func (*DeprecatedRedeemParticipationBid) SetSafetyDepositBoxAccount 

func (inst *DeprecatedRedeemParticipationBid) SetSafetyDepositBoxAccount(safetyDepositBox ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetSafetyDepositBoxAccount sets the "safetyDepositBox" account. Safety deposit box account

func (*DeprecatedRedeemParticipationBid) SetSafetyDepositConfigAccount 

func (inst *DeprecatedRedeemParticipationBid) SetSafetyDepositConfigAccount(safetyDepositConfig ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetSafetyDepositConfigAccount sets the "safetyDepositConfig" account. Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit] This account will only get used in the event this is an AuctionManagerV2

func (*DeprecatedRedeemParticipationBid) SetSafetyDepositTokenStorageAccount 

func (inst *DeprecatedRedeemParticipationBid) SetSafetyDepositTokenStorageAccount(safetyDepositTokenStorage ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetSafetyDepositTokenStorageAccount sets the "safetyDepositTokenStorage" account. Safety deposit token storage account

func (*DeprecatedRedeemParticipationBid) SetStoreAccount 

func (inst *DeprecatedRedeemParticipationBid) SetStoreAccount(store ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetStoreAccount sets the "store" account. Store

func (*DeprecatedRedeemParticipationBid) SetSystemAccount 

func (inst *DeprecatedRedeemParticipationBid) SetSystemAccount(system ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetSystemAccount sets the "system" account. System

func (*DeprecatedRedeemParticipationBid) SetTokenAccount 

func (inst *DeprecatedRedeemParticipationBid) SetTokenAccount(tokenAccount ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetTokenAccount sets the "tokenAccount" account. The token account you will potentially pay for the open edition bid with if necessary

func (*DeprecatedRedeemParticipationBid) SetTokenMetadataProgramAccount 

func (inst *DeprecatedRedeemParticipationBid) SetTokenMetadataProgramAccount(tokenMetadataProgram ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetTokenMetadataProgramAccount sets the "tokenMetadataProgram" account. Token metadata program

func (*DeprecatedRedeemParticipationBid) SetTokenProgramAccount 

func (inst *DeprecatedRedeemParticipationBid) SetTokenProgramAccount(tokenProgram ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetTokenProgramAccount sets the "tokenProgram" account. Token program

func (*DeprecatedRedeemParticipationBid) SetTokenVaultProgramAccount 

func (inst *DeprecatedRedeemParticipationBid) SetTokenVaultProgramAccount(tokenVaultProgram ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetTokenVaultProgramAccount sets the "tokenVaultProgram" account. Token Vault program

func (*DeprecatedRedeemParticipationBid) SetTransferAuthorityAccount 

func (inst *DeprecatedRedeemParticipationBid) SetTransferAuthorityAccount(transferAuthority ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetTransferAuthorityAccount sets the "transferAuthority" account. Transfer authority to move the payment in the auction's token_mint coin from the bidder account for the participation_fixed_price on the auction manager to the auction manager account itself.

func (*DeprecatedRedeemParticipationBid) SetVaultAccount 

func (inst *DeprecatedRedeemParticipationBid) SetVaultAccount(vaultAccount ag_solanago.PublicKey) *DeprecatedRedeemParticipationBid

SetVaultAccount sets the "vaultAccount" account. Vault account

func (*DeprecatedRedeemParticipationBid) UnmarshalWithDecoder 

func (obj *DeprecatedRedeemParticipationBid) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

func (*DeprecatedRedeemParticipationBid) Validate 

func (inst *DeprecatedRedeemParticipationBid) Validate() error

func (DeprecatedRedeemParticipationBid) ValidateAndBuild 

func (inst DeprecatedRedeemParticipationBid) ValidateAndBuild() (*Instruction, error)

ValidateAndBuild validates the instruction parameters and accounts; if there is a validation error, it returns the error. Otherwise, it builds and returns the instruction.

type DeprecatedRedeemParticipationBidV2 

type DeprecatedRedeemParticipationBidV2 struct {

	// [0] = [WRITE] auctionManager
	// ··········· Auction manager
	//
	// [1] = [WRITE] safetyDepositTokenStorage
	// ··········· Safety deposit token storage account
	//
	// [2] = [WRITE] singleItemAccount
	// ··········· Account containing 1 token of your new mint type.
	// ··········· MUST be an associated token account of pda [wallet, token program, mint] relative to ata program.
	//
	// [3] = [WRITE] bidRedemptionKey
	// ··········· Bid redemption key -
	// ··········· Just a PDA with seed ['metaplex', auction_key, bidder_metadata_key] that we will allocate to mark that you redeemed your bid
	//
	// [4] = [] safetyDepositBox
	// ··········· Safety deposit box account
	//
	// [5] = [] vaultAccount
	// ··········· Vault account
	//
	// [6] = [WRITE] safetyDepositConfig
	// ··········· Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit]
	// ··········· This account will only get used in the event this is an AuctionManagerV2
	//
	// [7] = [] auction
	// ··········· Auction
	//
	// [8] = [] bidderMetadata
	// ··········· Your BidderMetadata account
	//
	// [9] = [] bidder
	// ··········· Your Bidder account
	//
	// [10] = [SIGNER] payer
	// ··········· Payer
	//
	// [11] = [] tokenProgram
	// ··········· Token program
	//
	// [12] = [] tokenVaultProgram
	// ··········· Token Vault program
	//
	// [13] = [] tokenMetadataProgram
	// ··········· Token metadata program
	//
	// [14] = [] store
	// ··········· Store
	//
	// [15] = [] system
	// ··········· System
	//
	// [16] = [] rentSysvar
	// ··········· Rent sysvar
	//
	// [17] = [SIGNER] transferAuthority
	// ··········· Transfer authority to move the payment in the auction's token_mint coin from the bidder account for the participation_fixed_price
	// ··········· on the auction manager to the auction manager account itself.
	//
	// [18] = [WRITE] acceptPayment
	// ··········· The accept payment account for the auction manager
	//
	// [19] = [WRITE] tokenAccount
	// ··········· The token account you will potentially pay for the open edition bid with if necessary.
	//
	// [20] = [WRITE] prizeTrackingTicket
	// ··········· Prize tracking ticket (pda of ['metaplex', program id, auction manager key, metadata mint id])
	//
	// [21] = [WRITE] newMetadataKey
	// ··········· New Metadata key (pda of ['metadata', program id, mint id])
	//
	// [22] = [WRITE] newEditionPDA
	// ··········· New Edition (pda of ['metadata', program id, mint id, 'edition'])
	//
	// [23] = [WRITE] masterEdition
	// ··········· Master Edition of token in vault V2 (pda of ['metadata', program id, master metadata mint id, 'edition']) PDA is relative to token metadata.
	//
	// [24] = [WRITE] newTokenMint
	// ··········· Mint of new token
	//
	// [25] = [WRITE] editionPDA
	// ··········· Edition pda to mark creation - will be checked for pre-existence. (pda of ['metadata', program id, master metadata mint id, 'edition', edition_number])
	// ··········· where edition_number is NOT the edition number you pass in args but actually edition_number = floor(edition/EDITION_MARKER_BIT_SIZE). PDA is relative to token metadata.
	//
	// [26] = [SIGNER] mintAuthority
	// ··········· Mint authority of new mint - THIS WILL TRANSFER AUTHORITY AWAY FROM THIS KEY
	//
	// [27] = [] metadataAccount
	// ··········· Metadata account of token in vault
	ag_solanago.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

Note: This requires that auction manager be in a Running state.

Second note: Unlike it's predecessor, V2 is permissionless. You can in theory pay for someone else's participation NFT and gift it to them.

If an auction is complete, you can redeem your bid for an Open Edition token if it is eligible. If you are the first to do this, The auction manager will switch from Running state to Disbursing state. If you are the last, this may change the auction manager state to Finished provided that no authorities remain to be delegated for Master Edition tokens.

NOTE: Please note that it is totally possible to redeem a bid 2x - once for a prize you won and once at this end point for a open edition that comes as a 'token of appreciation' for bidding. They are not mutually exclusive unless explicitly set to be that way.

NOTE: If you are redeeming a newly minted Open Edition, you must actually supply a destination account containing a token from a brand new mint. We do not provide the token to you. Our job with this action is to christen this mint + token combo as an official Open Edition.

func NewDeprecatedRedeemParticipationBidV2Instruction 

func NewDeprecatedRedeemParticipationBidV2Instruction(

	auctionManager ag_solanago.PublicKey,
	safetyDepositTokenStorage ag_solanago.PublicKey,
	singleItemAccount ag_solanago.PublicKey,
	bidRedemptionKey ag_solanago.PublicKey,
	safetyDepositBox ag_solanago.PublicKey,
	vaultAccount ag_solanago.PublicKey,
	safetyDepositConfig ag_solanago.PublicKey,
	auction ag_solanago.PublicKey,
	bidderMetadata ag_solanago.PublicKey,
	bidder ag_solanago.PublicKey,
	payer ag_solanago.PublicKey,
	tokenProgram ag_solanago.PublicKey,
	tokenVaultProgram ag_solanago.PublicKey,
	tokenMetadataProgram ag_solanago.PublicKey,
	store ag_solanago.PublicKey,
	system ag_solanago.PublicKey,
	rentSysvar ag_solanago.PublicKey,
	transferAuthority ag_solanago.PublicKey,
	acceptPayment ag_solanago.PublicKey,
	tokenAccount ag_solanago.PublicKey,
	prizeTrackingTicket ag_solanago.PublicKey,
	newMetadataKey ag_solanago.PublicKey,
	newEditionPDA ag_solanago.PublicKey,
	masterEdition ag_solanago.PublicKey,
	newTokenMint ag_solanago.PublicKey,
	editionPDA ag_solanago.PublicKey,
	mintAuthority ag_solanago.PublicKey,
	metadataAccount ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

NewDeprecatedRedeemParticipationBidV2Instruction declares a new DeprecatedRedeemParticipationBidV2 instruction with the provided parameters and accounts.

func NewDeprecatedRedeemParticipationBidV2InstructionBuilder 

func NewDeprecatedRedeemParticipationBidV2InstructionBuilder() *DeprecatedRedeemParticipationBidV2

NewDeprecatedRedeemParticipationBidV2InstructionBuilder creates a new `DeprecatedRedeemParticipationBidV2` instruction builder.

func (DeprecatedRedeemParticipationBidV2) Build 

func (inst DeprecatedRedeemParticipationBidV2) Build() *Instruction

func (*DeprecatedRedeemParticipationBidV2) EncodeToTree 

func (inst *DeprecatedRedeemParticipationBidV2) EncodeToTree(parent ag_treeout.Branches)

func (*DeprecatedRedeemParticipationBidV2) GetAcceptPaymentAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetAcceptPaymentAccount() *ag_solanago.AccountMeta

GetAcceptPaymentAccount gets the "acceptPayment" account. The accept payment account for the auction manager

func (*DeprecatedRedeemParticipationBidV2) GetAuctionAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetAuctionAccount() *ag_solanago.AccountMeta

GetAuctionAccount gets the "auction" account. Auction

func (*DeprecatedRedeemParticipationBidV2) GetAuctionManagerAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetAuctionManagerAccount() *ag_solanago.AccountMeta

GetAuctionManagerAccount gets the "auctionManager" account. Auction manager

func (*DeprecatedRedeemParticipationBidV2) GetBidRedemptionKeyAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetBidRedemptionKeyAccount() *ag_solanago.AccountMeta

GetBidRedemptionKeyAccount gets the "bidRedemptionKey" account. Bid redemption key - Just a PDA with seed ['metaplex', auction_key, bidder_metadata_key] that we will allocate to mark that you redeemed your bid

func (*DeprecatedRedeemParticipationBidV2) GetBidderAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetBidderAccount() *ag_solanago.AccountMeta

GetBidderAccount gets the "bidder" account. Your Bidder account

func (*DeprecatedRedeemParticipationBidV2) GetBidderMetadataAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetBidderMetadataAccount() *ag_solanago.AccountMeta

GetBidderMetadataAccount gets the "bidderMetadata" account. Your BidderMetadata account

func (*DeprecatedRedeemParticipationBidV2) GetEditionPDAAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetEditionPDAAccount() *ag_solanago.AccountMeta

GetEditionPDAAccount gets the "editionPDA" account. Edition pda to mark creation - will be checked for pre-existence. (pda of ['metadata', program id, master metadata mint id, 'edition', edition_number]) where edition_number is NOT the edition number you pass in args but actually edition_number = floor(edition/EDITION_MARKER_BIT_SIZE). PDA is relative to token metadata.

func (*DeprecatedRedeemParticipationBidV2) GetMasterEditionAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetMasterEditionAccount() *ag_solanago.AccountMeta

GetMasterEditionAccount gets the "masterEdition" account. Master Edition of token in vault V2 (pda of ['metadata', program id, master metadata mint id, 'edition']) PDA is relative to token metadata.

func (*DeprecatedRedeemParticipationBidV2) GetMetadataAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetMetadataAccount() *ag_solanago.AccountMeta

GetMetadataAccount gets the "metadataAccount" account. Metadata account of token in vault

func (*DeprecatedRedeemParticipationBidV2) GetMintAuthorityAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetMintAuthorityAccount() *ag_solanago.AccountMeta

GetMintAuthorityAccount gets the "mintAuthority" account. Mint authority of new mint - THIS WILL TRANSFER AUTHORITY AWAY FROM THIS KEY

func (*DeprecatedRedeemParticipationBidV2) GetNewEditionPDAAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetNewEditionPDAAccount() *ag_solanago.AccountMeta

GetNewEditionPDAAccount gets the "newEditionPDA" account. New Edition (pda of ['metadata', program id, mint id, 'edition'])

func (*DeprecatedRedeemParticipationBidV2) GetNewMetadataKeyAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetNewMetadataKeyAccount() *ag_solanago.AccountMeta

GetNewMetadataKeyAccount gets the "newMetadataKey" account. New Metadata key (pda of ['metadata', program id, mint id])

func (*DeprecatedRedeemParticipationBidV2) GetNewTokenMintAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetNewTokenMintAccount() *ag_solanago.AccountMeta

GetNewTokenMintAccount gets the "newTokenMint" account. Mint of new token

func (*DeprecatedRedeemParticipationBidV2) GetPayerAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetPayerAccount() *ag_solanago.AccountMeta

GetPayerAccount gets the "payer" account. Payer

func (*DeprecatedRedeemParticipationBidV2) GetPrizeTrackingTicketAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetPrizeTrackingTicketAccount() *ag_solanago.AccountMeta

GetPrizeTrackingTicketAccount gets the "prizeTrackingTicket" account. Prize tracking ticket (pda of ['metaplex', program id, auction manager key, metadata mint id])

func (*DeprecatedRedeemParticipationBidV2) GetRentSysvarAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetRentSysvarAccount() *ag_solanago.AccountMeta

GetRentSysvarAccount gets the "rentSysvar" account. Rent sysvar

func (*DeprecatedRedeemParticipationBidV2) GetSafetyDepositBoxAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetSafetyDepositBoxAccount() *ag_solanago.AccountMeta

GetSafetyDepositBoxAccount gets the "safetyDepositBox" account. Safety deposit box account

func (*DeprecatedRedeemParticipationBidV2) GetSafetyDepositConfigAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetSafetyDepositConfigAccount() *ag_solanago.AccountMeta

GetSafetyDepositConfigAccount gets the "safetyDepositConfig" account. Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit] This account will only get used in the event this is an AuctionManagerV2

func (*DeprecatedRedeemParticipationBidV2) GetSafetyDepositTokenStorageAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetSafetyDepositTokenStorageAccount() *ag_solanago.AccountMeta

GetSafetyDepositTokenStorageAccount gets the "safetyDepositTokenStorage" account. Safety deposit token storage account

func (*DeprecatedRedeemParticipationBidV2) GetSingleItemAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetSingleItemAccount() *ag_solanago.AccountMeta

GetSingleItemAccount gets the "singleItemAccount" account. Account containing 1 token of your new mint type. MUST be an associated token account of pda [wallet, token program, mint] relative to ata program.

func (*DeprecatedRedeemParticipationBidV2) GetStoreAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetStoreAccount() *ag_solanago.AccountMeta

GetStoreAccount gets the "store" account. Store

func (*DeprecatedRedeemParticipationBidV2) GetSystemAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetSystemAccount() *ag_solanago.AccountMeta

GetSystemAccount gets the "system" account. System

func (*DeprecatedRedeemParticipationBidV2) GetTokenAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetTokenAccount() *ag_solanago.AccountMeta

GetTokenAccount gets the "tokenAccount" account. The token account you will potentially pay for the open edition bid with if necessary.

func (*DeprecatedRedeemParticipationBidV2) GetTokenMetadataProgramAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetTokenMetadataProgramAccount() *ag_solanago.AccountMeta

GetTokenMetadataProgramAccount gets the "tokenMetadataProgram" account. Token metadata program

func (*DeprecatedRedeemParticipationBidV2) GetTokenProgramAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetTokenProgramAccount() *ag_solanago.AccountMeta

GetTokenProgramAccount gets the "tokenProgram" account. Token program

func (*DeprecatedRedeemParticipationBidV2) GetTokenVaultProgramAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetTokenVaultProgramAccount() *ag_solanago.AccountMeta

GetTokenVaultProgramAccount gets the "tokenVaultProgram" account. Token Vault program

func (*DeprecatedRedeemParticipationBidV2) GetTransferAuthorityAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetTransferAuthorityAccount() *ag_solanago.AccountMeta

GetTransferAuthorityAccount gets the "transferAuthority" account. Transfer authority to move the payment in the auction's token_mint coin from the bidder account for the participation_fixed_price on the auction manager to the auction manager account itself.

func (*DeprecatedRedeemParticipationBidV2) GetVaultAccount 

func (inst *DeprecatedRedeemParticipationBidV2) GetVaultAccount() *ag_solanago.AccountMeta

GetVaultAccount gets the "vaultAccount" account. Vault account

func (DeprecatedRedeemParticipationBidV2) MarshalWithEncoder 

func (obj DeprecatedRedeemParticipationBidV2) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*DeprecatedRedeemParticipationBidV2) SetAcceptPaymentAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetAcceptPaymentAccount(acceptPayment ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetAcceptPaymentAccount sets the "acceptPayment" account. The accept payment account for the auction manager

func (*DeprecatedRedeemParticipationBidV2) SetAuctionAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetAuctionAccount(auction ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetAuctionAccount sets the "auction" account. Auction

func (*DeprecatedRedeemParticipationBidV2) SetAuctionManagerAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetAuctionManagerAccount(auctionManager ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetAuctionManagerAccount sets the "auctionManager" account. Auction manager

func (*DeprecatedRedeemParticipationBidV2) SetBidRedemptionKeyAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetBidRedemptionKeyAccount(bidRedemptionKey ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetBidRedemptionKeyAccount sets the "bidRedemptionKey" account. Bid redemption key - Just a PDA with seed ['metaplex', auction_key, bidder_metadata_key] that we will allocate to mark that you redeemed your bid

func (*DeprecatedRedeemParticipationBidV2) SetBidderAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetBidderAccount(bidder ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetBidderAccount sets the "bidder" account. Your Bidder account

func (*DeprecatedRedeemParticipationBidV2) SetBidderMetadataAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetBidderMetadataAccount(bidderMetadata ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetBidderMetadataAccount sets the "bidderMetadata" account. Your BidderMetadata account

func (*DeprecatedRedeemParticipationBidV2) SetEditionPDAAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetEditionPDAAccount(editionPDA ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetEditionPDAAccount sets the "editionPDA" account. Edition pda to mark creation - will be checked for pre-existence. (pda of ['metadata', program id, master metadata mint id, 'edition', edition_number]) where edition_number is NOT the edition number you pass in args but actually edition_number = floor(edition/EDITION_MARKER_BIT_SIZE). PDA is relative to token metadata.

func (*DeprecatedRedeemParticipationBidV2) SetMasterEditionAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetMasterEditionAccount(masterEdition ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetMasterEditionAccount sets the "masterEdition" account. Master Edition of token in vault V2 (pda of ['metadata', program id, master metadata mint id, 'edition']) PDA is relative to token metadata.

func (*DeprecatedRedeemParticipationBidV2) SetMetadataAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetMetadataAccount(metadataAccount ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetMetadataAccount sets the "metadataAccount" account. Metadata account of token in vault

func (*DeprecatedRedeemParticipationBidV2) SetMintAuthorityAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetMintAuthorityAccount(mintAuthority ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetMintAuthorityAccount sets the "mintAuthority" account. Mint authority of new mint - THIS WILL TRANSFER AUTHORITY AWAY FROM THIS KEY

func (*DeprecatedRedeemParticipationBidV2) SetNewEditionPDAAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetNewEditionPDAAccount(newEditionPDA ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetNewEditionPDAAccount sets the "newEditionPDA" account. New Edition (pda of ['metadata', program id, mint id, 'edition'])

func (*DeprecatedRedeemParticipationBidV2) SetNewMetadataKeyAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetNewMetadataKeyAccount(newMetadataKey ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetNewMetadataKeyAccount sets the "newMetadataKey" account. New Metadata key (pda of ['metadata', program id, mint id])

func (*DeprecatedRedeemParticipationBidV2) SetNewTokenMintAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetNewTokenMintAccount(newTokenMint ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetNewTokenMintAccount sets the "newTokenMint" account. Mint of new token

func (*DeprecatedRedeemParticipationBidV2) SetPayerAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetPayerAccount(payer ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetPayerAccount sets the "payer" account. Payer

func (*DeprecatedRedeemParticipationBidV2) SetPrizeTrackingTicketAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetPrizeTrackingTicketAccount(prizeTrackingTicket ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetPrizeTrackingTicketAccount sets the "prizeTrackingTicket" account. Prize tracking ticket (pda of ['metaplex', program id, auction manager key, metadata mint id])

func (*DeprecatedRedeemParticipationBidV2) SetRentSysvarAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetRentSysvarAccount(rentSysvar ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetRentSysvarAccount sets the "rentSysvar" account. Rent sysvar

func (*DeprecatedRedeemParticipationBidV2) SetSafetyDepositBoxAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetSafetyDepositBoxAccount(safetyDepositBox ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetSafetyDepositBoxAccount sets the "safetyDepositBox" account. Safety deposit box account

func (*DeprecatedRedeemParticipationBidV2) SetSafetyDepositConfigAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetSafetyDepositConfigAccount(safetyDepositConfig ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetSafetyDepositConfigAccount sets the "safetyDepositConfig" account. Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit] This account will only get used in the event this is an AuctionManagerV2

func (*DeprecatedRedeemParticipationBidV2) SetSafetyDepositTokenStorageAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetSafetyDepositTokenStorageAccount(safetyDepositTokenStorage ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetSafetyDepositTokenStorageAccount sets the "safetyDepositTokenStorage" account. Safety deposit token storage account

func (*DeprecatedRedeemParticipationBidV2) SetSingleItemAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetSingleItemAccount(singleItemAccount ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetSingleItemAccount sets the "singleItemAccount" account. Account containing 1 token of your new mint type. MUST be an associated token account of pda [wallet, token program, mint] relative to ata program.

func (*DeprecatedRedeemParticipationBidV2) SetStoreAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetStoreAccount(store ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetStoreAccount sets the "store" account. Store

func (*DeprecatedRedeemParticipationBidV2) SetSystemAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetSystemAccount(system ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetSystemAccount sets the "system" account. System

func (*DeprecatedRedeemParticipationBidV2) SetTokenAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetTokenAccount(tokenAccount ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetTokenAccount sets the "tokenAccount" account. The token account you will potentially pay for the open edition bid with if necessary.

func (*DeprecatedRedeemParticipationBidV2) SetTokenMetadataProgramAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetTokenMetadataProgramAccount(tokenMetadataProgram ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetTokenMetadataProgramAccount sets the "tokenMetadataProgram" account. Token metadata program

func (*DeprecatedRedeemParticipationBidV2) SetTokenProgramAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetTokenProgramAccount(tokenProgram ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetTokenProgramAccount sets the "tokenProgram" account. Token program

func (*DeprecatedRedeemParticipationBidV2) SetTokenVaultProgramAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetTokenVaultProgramAccount(tokenVaultProgram ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetTokenVaultProgramAccount sets the "tokenVaultProgram" account. Token Vault program

func (*DeprecatedRedeemParticipationBidV2) SetTransferAuthorityAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetTransferAuthorityAccount(transferAuthority ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetTransferAuthorityAccount sets the "transferAuthority" account. Transfer authority to move the payment in the auction's token_mint coin from the bidder account for the participation_fixed_price on the auction manager to the auction manager account itself.

func (*DeprecatedRedeemParticipationBidV2) SetVaultAccount 

func (inst *DeprecatedRedeemParticipationBidV2) SetVaultAccount(vaultAccount ag_solanago.PublicKey) *DeprecatedRedeemParticipationBidV2

SetVaultAccount sets the "vaultAccount" account. Vault account

func (*DeprecatedRedeemParticipationBidV2) UnmarshalWithDecoder 

func (obj *DeprecatedRedeemParticipationBidV2) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

func (*DeprecatedRedeemParticipationBidV2) Validate 

func (inst *DeprecatedRedeemParticipationBidV2) Validate() error

func (DeprecatedRedeemParticipationBidV2) ValidateAndBuild 

func (inst DeprecatedRedeemParticipationBidV2) ValidateAndBuild() (*Instruction, error)

ValidateAndBuild validates the instruction parameters and accounts; if there is a validation error, it returns the error. Otherwise, it builds and returns the instruction.

type DeprecatedValidateParticipation 

type DeprecatedValidateParticipation struct {

	// [0] = [WRITE] auctionManager
	// ··········· Auction manager
	//
	// [1] = [] openEditionMetadata
	// ··········· Open edition metadata
	//
	// [2] = [] openEditionMasterEdition
	// ··········· Open edition MasterEdition account
	//
	// [3] = [] printingAuthorizationTokenHoldingAccount
	// ··········· Printing authorization token holding account - must be of the printing_mint type on the master_edition, used by
	// ··········· the auction manager to hold printing authorization tokens for all eligible winners of the participation nft when auction ends. Must
	// ··········· be owned by auction manager account.
	//
	// [4] = [SIGNER] auctionManagerAuthority
	// ··········· Authority for the Auction Manager
	//
	// [5] = [] whitelistedCreatorEntry
	// ··········· A whitelisted creator entry for this store for the open edition
	// ··········· pda of ['metaplex', store key, creator key] where creator key comes from creator list of metadata
	//
	// [6] = [] auctionManagerStore
	// ··········· The auction manager's store
	//
	// [7] = [] safetyDepositBox
	// ··········· Safety deposit box
	//
	// [8] = [] safetyDepositTokenStorage
	// ··········· Safety deposit token store
	//
	// [9] = [] vault
	// ··········· Vault
	//
	// [10] = [] rentSysvar
	// ··········· Rent sysvar
	ag_solanago.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

NOTE: Requires an AuctionManagerV1. Validates an participation nft (if present) on the Auction Manager. Because of the differing mechanics of an open edition (required for participation nft), it needs to be validated at a different endpoint than a normal safety deposit box.

func NewDeprecatedValidateParticipationInstruction 

func NewDeprecatedValidateParticipationInstruction(

	auctionManager ag_solanago.PublicKey,
	openEditionMetadata ag_solanago.PublicKey,
	openEditionMasterEdition ag_solanago.PublicKey,
	printingAuthorizationTokenHoldingAccount ag_solanago.PublicKey,
	auctionManagerAuthority ag_solanago.PublicKey,
	whitelistedCreatorEntry ag_solanago.PublicKey,
	auctionManagerStore ag_solanago.PublicKey,
	safetyDepositBox ag_solanago.PublicKey,
	safetyDepositTokenStorage ag_solanago.PublicKey,
	vault ag_solanago.PublicKey,
	rentSysvar ag_solanago.PublicKey) *DeprecatedValidateParticipation

NewDeprecatedValidateParticipationInstruction declares a new DeprecatedValidateParticipation instruction with the provided parameters and accounts.

func NewDeprecatedValidateParticipationInstructionBuilder 

func NewDeprecatedValidateParticipationInstructionBuilder() *DeprecatedValidateParticipation

NewDeprecatedValidateParticipationInstructionBuilder creates a new `DeprecatedValidateParticipation` instruction builder.

func (DeprecatedValidateParticipation) Build 

func (inst DeprecatedValidateParticipation) Build() *Instruction

func (*DeprecatedValidateParticipation) EncodeToTree 

func (inst *DeprecatedValidateParticipation) EncodeToTree(parent ag_treeout.Branches)

func (*DeprecatedValidateParticipation) GetAuctionManagerAccount 

func (inst *DeprecatedValidateParticipation) GetAuctionManagerAccount() *ag_solanago.AccountMeta

GetAuctionManagerAccount gets the "auctionManager" account. Auction manager

func (*DeprecatedValidateParticipation) GetAuctionManagerAuthorityAccount 

func (inst *DeprecatedValidateParticipation) GetAuctionManagerAuthorityAccount() *ag_solanago.AccountMeta

GetAuctionManagerAuthorityAccount gets the "auctionManagerAuthority" account. Authority for the Auction Manager

func (*DeprecatedValidateParticipation) GetAuctionManagerStoreAccount 

func (inst *DeprecatedValidateParticipation) GetAuctionManagerStoreAccount() *ag_solanago.AccountMeta

GetAuctionManagerStoreAccount gets the "auctionManagerStore" account. The auction manager's store

func (*DeprecatedValidateParticipation) GetOpenEditionMasterEditionAccount 

func (inst *DeprecatedValidateParticipation) GetOpenEditionMasterEditionAccount() *ag_solanago.AccountMeta

GetOpenEditionMasterEditionAccount gets the "openEditionMasterEdition" account. Open edition MasterEdition account

func (*DeprecatedValidateParticipation) GetOpenEditionMetadataAccount 

func (inst *DeprecatedValidateParticipation) GetOpenEditionMetadataAccount() *ag_solanago.AccountMeta

GetOpenEditionMetadataAccount gets the "openEditionMetadata" account. Open edition metadata

func (*DeprecatedValidateParticipation) GetPrintingAuthorizationTokenHoldingAccount 

func (inst *DeprecatedValidateParticipation) GetPrintingAuthorizationTokenHoldingAccount() *ag_solanago.AccountMeta

GetPrintingAuthorizationTokenHoldingAccount gets the "printingAuthorizationTokenHoldingAccount" account. Printing authorization token holding account - must be of the printing_mint type on the master_edition, used by the auction manager to hold printing authorization tokens for all eligible winners of the participation nft when auction ends. Must be owned by auction manager account.

func (*DeprecatedValidateParticipation) GetRentSysvarAccount 

func (inst *DeprecatedValidateParticipation) GetRentSysvarAccount() *ag_solanago.AccountMeta

GetRentSysvarAccount gets the "rentSysvar" account. Rent sysvar

func (*DeprecatedValidateParticipation) GetSafetyDepositBoxAccount 

func (inst *DeprecatedValidateParticipation) GetSafetyDepositBoxAccount() *ag_solanago.AccountMeta

GetSafetyDepositBoxAccount gets the "safetyDepositBox" account. Safety deposit box

func (*DeprecatedValidateParticipation) GetSafetyDepositTokenStorageAccount 

func (inst *DeprecatedValidateParticipation) GetSafetyDepositTokenStorageAccount() *ag_solanago.AccountMeta

GetSafetyDepositTokenStorageAccount gets the "safetyDepositTokenStorage" account. Safety deposit token store

func (*DeprecatedValidateParticipation) GetVaultAccount 

func (inst *DeprecatedValidateParticipation) GetVaultAccount() *ag_solanago.AccountMeta

GetVaultAccount gets the "vault" account. Vault

func (*DeprecatedValidateParticipation) GetWhitelistedCreatorEntryAccount 

func (inst *DeprecatedValidateParticipation) GetWhitelistedCreatorEntryAccount() *ag_solanago.AccountMeta

GetWhitelistedCreatorEntryAccount gets the "whitelistedCreatorEntry" account. A whitelisted creator entry for this store for the open edition pda of ['metaplex', store key, creator key] where creator key comes from creator list of metadata

func (DeprecatedValidateParticipation) MarshalWithEncoder 

func (obj DeprecatedValidateParticipation) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*DeprecatedValidateParticipation) SetAuctionManagerAccount 

func (inst *DeprecatedValidateParticipation) SetAuctionManagerAccount(auctionManager ag_solanago.PublicKey) *DeprecatedValidateParticipation

SetAuctionManagerAccount sets the "auctionManager" account. Auction manager

func (*DeprecatedValidateParticipation) SetAuctionManagerAuthorityAccount 

func (inst *DeprecatedValidateParticipation) SetAuctionManagerAuthorityAccount(auctionManagerAuthority ag_solanago.PublicKey) *DeprecatedValidateParticipation

SetAuctionManagerAuthorityAccount sets the "auctionManagerAuthority" account. Authority for the Auction Manager

func (*DeprecatedValidateParticipation) SetAuctionManagerStoreAccount 

func (inst *DeprecatedValidateParticipation) SetAuctionManagerStoreAccount(auctionManagerStore ag_solanago.PublicKey) *DeprecatedValidateParticipation

SetAuctionManagerStoreAccount sets the "auctionManagerStore" account. The auction manager's store

func (*DeprecatedValidateParticipation) SetOpenEditionMasterEditionAccount 

func (inst *DeprecatedValidateParticipation) SetOpenEditionMasterEditionAccount(openEditionMasterEdition ag_solanago.PublicKey) *DeprecatedValidateParticipation

SetOpenEditionMasterEditionAccount sets the "openEditionMasterEdition" account. Open edition MasterEdition account

func (*DeprecatedValidateParticipation) SetOpenEditionMetadataAccount 

func (inst *DeprecatedValidateParticipation) SetOpenEditionMetadataAccount(openEditionMetadata ag_solanago.PublicKey) *DeprecatedValidateParticipation

SetOpenEditionMetadataAccount sets the "openEditionMetadata" account. Open edition metadata

func (*DeprecatedValidateParticipation) SetPrintingAuthorizationTokenHoldingAccount 

func (inst *DeprecatedValidateParticipation) SetPrintingAuthorizationTokenHoldingAccount(printingAuthorizationTokenHoldingAccount ag_solanago.PublicKey) *DeprecatedValidateParticipation

SetPrintingAuthorizationTokenHoldingAccount sets the "printingAuthorizationTokenHoldingAccount" account. Printing authorization token holding account - must be of the printing_mint type on the master_edition, used by the auction manager to hold printing authorization tokens for all eligible winners of the participation nft when auction ends. Must be owned by auction manager account.

func (*DeprecatedValidateParticipation) SetRentSysvarAccount 

func (inst *DeprecatedValidateParticipation) SetRentSysvarAccount(rentSysvar ag_solanago.PublicKey) *DeprecatedValidateParticipation

SetRentSysvarAccount sets the "rentSysvar" account. Rent sysvar

func (*DeprecatedValidateParticipation) SetSafetyDepositBoxAccount 

func (inst *DeprecatedValidateParticipation) SetSafetyDepositBoxAccount(safetyDepositBox ag_solanago.PublicKey) *DeprecatedValidateParticipation

SetSafetyDepositBoxAccount sets the "safetyDepositBox" account. Safety deposit box

func (*DeprecatedValidateParticipation) SetSafetyDepositTokenStorageAccount 

func (inst *DeprecatedValidateParticipation) SetSafetyDepositTokenStorageAccount(safetyDepositTokenStorage ag_solanago.PublicKey) *DeprecatedValidateParticipation

SetSafetyDepositTokenStorageAccount sets the "safetyDepositTokenStorage" account. Safety deposit token store

func (*DeprecatedValidateParticipation) SetVaultAccount 

func (inst *DeprecatedValidateParticipation) SetVaultAccount(vault ag_solanago.PublicKey) *DeprecatedValidateParticipation

SetVaultAccount sets the "vault" account. Vault

func (*DeprecatedValidateParticipation) SetWhitelistedCreatorEntryAccount 

func (inst *DeprecatedValidateParticipation) SetWhitelistedCreatorEntryAccount(whitelistedCreatorEntry ag_solanago.PublicKey) *DeprecatedValidateParticipation

SetWhitelistedCreatorEntryAccount sets the "whitelistedCreatorEntry" account. A whitelisted creator entry for this store for the open edition pda of ['metaplex', store key, creator key] where creator key comes from creator list of metadata

func (*DeprecatedValidateParticipation) UnmarshalWithDecoder 

func (obj *DeprecatedValidateParticipation) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

func (*DeprecatedValidateParticipation) Validate 

func (inst *DeprecatedValidateParticipation) Validate() error

func (DeprecatedValidateParticipation) ValidateAndBuild 

func (inst DeprecatedValidateParticipation) ValidateAndBuild() (*Instruction, error)

ValidateAndBuild validates the instruction parameters and accounts; if there is a validation error, it returns the error. Otherwise, it builds and returns the instruction.

type DeprecatedValidateSafetyDepositBoxV1 

type DeprecatedValidateSafetyDepositBoxV1 struct {

	// [0] = [WRITE] uninitializedSafetyDepositValidationTicket
	// ··········· Uninitialized Safety deposit validation ticket, pda of seed ['metaplex', program id, auction manager key, safety deposit key]
	//
	// [1] = [WRITE] auctionManager
	// ··········· Auction manager
	//
	// [2] = [WRITE] metadataAccount
	// ··········· Metadata account
	//
	// [3] = [WRITE] originalAuthorityLookup
	// ··········· Original authority lookup - unallocated uninitialized pda account with seed ['metaplex', auction key, metadata key]
	// ··········· We will store original authority here to return it later.
	//
	// [4] = [] whitelistedCreatorEntry
	// ··········· A whitelisted creator entry for the store of this auction manager pda of ['metaplex', store key, creator key]
	// ··········· where creator key comes from creator list of metadata, any will do
	//
	// [5] = [] auctionManagerStoreKey
	// ··········· The auction manager's store key
	//
	// [6] = [] safetyDepositBox
	// ··········· Safety deposit box account
	//
	// [7] = [] safetyDepositBoxStorage
	// ··········· Safety deposit box storage account where the actual nft token is stored
	//
	// [8] = [] mintAccount
	// ··········· Mint account of the token in the safety deposit box
	//
	// [9] = [] editionOrMasterEditionRecordKey
	// ··········· Edition OR MasterEdition record key
	// ··········· Remember this does not need to be an existing account (may not be depending on token), just is a pda with seed
	// ··········· of ['metadata', program id, Printing mint id, 'edition']. - remember PDA is relative to token metadata program.
	//
	// [10] = [] vaultAccount
	// ··········· Vault account
	//
	// [11] = [SIGNER] authority
	// ··········· Authority
	//
	// [12] = [SIGNER] metadataAuthority
	// ··········· [optional] Metadata Authority - Signer only required if doing a full ownership txfer
	//
	// [13] = [SIGNER] payer
	// ··········· Payer
	//
	// [14] = [] tokenMetadataProgram
	// ··········· Token metadata program
	//
	// [15] = [] system
	// ··········· System
	//
	// [16] = [] rentSysvar
	// ··········· Rent sysvar
	//
	// [17] = [WRITE] limitedEditionPrintingMint
	// ··········· Limited edition Printing mint account (optional - only if using sending Limited Edition)
	//
	// [18] = [SIGNER] limitedEditionPrintingMintAuthority
	// ··········· Limited edition Printing mint Authority account, this will TEMPORARILY TRANSFER MINTING AUTHORITY to the auction manager
	// ··········· until all limited editions have been redeemed for authority tokens.
	ag_solanago.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

Validates that a given safety deposit box has in it contents that match the expected WinningConfig in the auction manager. A stateful call, this will error out if you call it a second time after validation has occurred.

func NewDeprecatedValidateSafetyDepositBoxV1Instruction 

func NewDeprecatedValidateSafetyDepositBoxV1Instruction(

	uninitializedSafetyDepositValidationTicket ag_solanago.PublicKey,
	auctionManager ag_solanago.PublicKey,
	metadataAccount ag_solanago.PublicKey,
	originalAuthorityLookup ag_solanago.PublicKey,
	whitelistedCreatorEntry ag_solanago.PublicKey,
	auctionManagerStoreKey ag_solanago.PublicKey,
	safetyDepositBox ag_solanago.PublicKey,
	safetyDepositBoxStorage ag_solanago.PublicKey,
	mintAccount ag_solanago.PublicKey,
	editionOrMasterEditionRecordKey ag_solanago.PublicKey,
	vaultAccount ag_solanago.PublicKey,
	authority ag_solanago.PublicKey,
	metadataAuthority ag_solanago.PublicKey,
	payer ag_solanago.PublicKey,
	tokenMetadataProgram ag_solanago.PublicKey,
	system ag_solanago.PublicKey,
	rentSysvar ag_solanago.PublicKey,
	limitedEditionPrintingMint ag_solanago.PublicKey,
	limitedEditionPrintingMintAuthority ag_solanago.PublicKey) *DeprecatedValidateSafetyDepositBoxV1

NewDeprecatedValidateSafetyDepositBoxV1Instruction declares a new DeprecatedValidateSafetyDepositBoxV1 instruction with the provided parameters and accounts.

func NewDeprecatedValidateSafetyDepositBoxV1InstructionBuilder 

func NewDeprecatedValidateSafetyDepositBoxV1InstructionBuilder() *DeprecatedValidateSafetyDepositBoxV1

NewDeprecatedValidateSafetyDepositBoxV1InstructionBuilder creates a new `DeprecatedValidateSafetyDepositBoxV1` instruction builder.

func (DeprecatedValidateSafetyDepositBoxV1) Build 

func (inst DeprecatedValidateSafetyDepositBoxV1) Build() *Instruction

func (*DeprecatedValidateSafetyDepositBoxV1) EncodeToTree 

func (inst *DeprecatedValidateSafetyDepositBoxV1) EncodeToTree(parent ag_treeout.Branches)

func (*DeprecatedValidateSafetyDepositBoxV1) GetAuctionManagerAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) GetAuctionManagerAccount() *ag_solanago.AccountMeta

GetAuctionManagerAccount gets the "auctionManager" account. Auction manager

func (*DeprecatedValidateSafetyDepositBoxV1) GetAuctionManagerStoreKeyAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) GetAuctionManagerStoreKeyAccount() *ag_solanago.AccountMeta

GetAuctionManagerStoreKeyAccount gets the "auctionManagerStoreKey" account. The auction manager's store key

func (*DeprecatedValidateSafetyDepositBoxV1) GetAuthorityAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) GetAuthorityAccount() *ag_solanago.AccountMeta

GetAuthorityAccount gets the "authority" account. Authority

func (*DeprecatedValidateSafetyDepositBoxV1) GetEditionOrMasterEditionRecordKeyAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) GetEditionOrMasterEditionRecordKeyAccount() *ag_solanago.AccountMeta

GetEditionOrMasterEditionRecordKeyAccount gets the "editionOrMasterEditionRecordKey" account. Edition OR MasterEdition record key Remember this does not need to be an existing account (may not be depending on token), just is a pda with seed of ['metadata', program id, Printing mint id, 'edition']. - remember PDA is relative to token metadata program.

func (*DeprecatedValidateSafetyDepositBoxV1) GetLimitedEditionPrintingMintAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) GetLimitedEditionPrintingMintAccount() *ag_solanago.AccountMeta

GetLimitedEditionPrintingMintAccount gets the "limitedEditionPrintingMint" account. Limited edition Printing mint account (optional - only if using sending Limited Edition)

func (*DeprecatedValidateSafetyDepositBoxV1) GetLimitedEditionPrintingMintAuthorityAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) GetLimitedEditionPrintingMintAuthorityAccount() *ag_solanago.AccountMeta

GetLimitedEditionPrintingMintAuthorityAccount gets the "limitedEditionPrintingMintAuthority" account. Limited edition Printing mint Authority account, this will TEMPORARILY TRANSFER MINTING AUTHORITY to the auction manager until all limited editions have been redeemed for authority tokens.

func (*DeprecatedValidateSafetyDepositBoxV1) GetMetadataAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) GetMetadataAccount() *ag_solanago.AccountMeta

GetMetadataAccount gets the "metadataAccount" account. Metadata account

func (*DeprecatedValidateSafetyDepositBoxV1) GetMetadataAuthorityAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) GetMetadataAuthorityAccount() *ag_solanago.AccountMeta

GetMetadataAuthorityAccount gets the "metadataAuthority" account. [optional] Metadata Authority - Signer only required if doing a full ownership txfer

func (*DeprecatedValidateSafetyDepositBoxV1) GetMintAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) GetMintAccount() *ag_solanago.AccountMeta

GetMintAccount gets the "mintAccount" account. Mint account of the token in the safety deposit box

func (*DeprecatedValidateSafetyDepositBoxV1) GetOriginalAuthorityLookupAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) GetOriginalAuthorityLookupAccount() *ag_solanago.AccountMeta

GetOriginalAuthorityLookupAccount gets the "originalAuthorityLookup" account. Original authority lookup - unallocated uninitialized pda account with seed ['metaplex', auction key, metadata key] We will store original authority here to return it later.

func (*DeprecatedValidateSafetyDepositBoxV1) GetPayerAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) GetPayerAccount() *ag_solanago.AccountMeta

GetPayerAccount gets the "payer" account. Payer

func (*DeprecatedValidateSafetyDepositBoxV1) GetRentSysvarAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) GetRentSysvarAccount() *ag_solanago.AccountMeta

GetRentSysvarAccount gets the "rentSysvar" account. Rent sysvar

func (*DeprecatedValidateSafetyDepositBoxV1) GetSafetyDepositBoxAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) GetSafetyDepositBoxAccount() *ag_solanago.AccountMeta

GetSafetyDepositBoxAccount gets the "safetyDepositBox" account. Safety deposit box account

func (*DeprecatedValidateSafetyDepositBoxV1) GetSafetyDepositBoxStorageAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) GetSafetyDepositBoxStorageAccount() *ag_solanago.AccountMeta

GetSafetyDepositBoxStorageAccount gets the "safetyDepositBoxStorage" account. Safety deposit box storage account where the actual nft token is stored

func (*DeprecatedValidateSafetyDepositBoxV1) GetSystemAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) GetSystemAccount() *ag_solanago.AccountMeta

GetSystemAccount gets the "system" account. System

func (*DeprecatedValidateSafetyDepositBoxV1) GetTokenMetadataProgramAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) GetTokenMetadataProgramAccount() *ag_solanago.AccountMeta

GetTokenMetadataProgramAccount gets the "tokenMetadataProgram" account. Token metadata program

func (*DeprecatedValidateSafetyDepositBoxV1) GetUninitializedSafetyDepositValidationTicketAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) GetUninitializedSafetyDepositValidationTicketAccount() *ag_solanago.AccountMeta

GetUninitializedSafetyDepositValidationTicketAccount gets the "uninitializedSafetyDepositValidationTicket" account. Uninitialized Safety deposit validation ticket, pda of seed ['metaplex', program id, auction manager key, safety deposit key]

func (*DeprecatedValidateSafetyDepositBoxV1) GetVaultAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) GetVaultAccount() *ag_solanago.AccountMeta

GetVaultAccount gets the "vaultAccount" account. Vault account

func (*DeprecatedValidateSafetyDepositBoxV1) GetWhitelistedCreatorEntryAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) GetWhitelistedCreatorEntryAccount() *ag_solanago.AccountMeta

GetWhitelistedCreatorEntryAccount gets the "whitelistedCreatorEntry" account. A whitelisted creator entry for the store of this auction manager pda of ['metaplex', store key, creator key] where creator key comes from creator list of metadata, any will do

func (DeprecatedValidateSafetyDepositBoxV1) MarshalWithEncoder 

func (obj DeprecatedValidateSafetyDepositBoxV1) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*DeprecatedValidateSafetyDepositBoxV1) SetAuctionManagerAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) SetAuctionManagerAccount(auctionManager ag_solanago.PublicKey) *DeprecatedValidateSafetyDepositBoxV1

SetAuctionManagerAccount sets the "auctionManager" account. Auction manager

func (*DeprecatedValidateSafetyDepositBoxV1) SetAuctionManagerStoreKeyAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) SetAuctionManagerStoreKeyAccount(auctionManagerStoreKey ag_solanago.PublicKey) *DeprecatedValidateSafetyDepositBoxV1

SetAuctionManagerStoreKeyAccount sets the "auctionManagerStoreKey" account. The auction manager's store key

func (*DeprecatedValidateSafetyDepositBoxV1) SetAuthorityAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) SetAuthorityAccount(authority ag_solanago.PublicKey) *DeprecatedValidateSafetyDepositBoxV1

SetAuthorityAccount sets the "authority" account. Authority

func (*DeprecatedValidateSafetyDepositBoxV1) SetEditionOrMasterEditionRecordKeyAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) SetEditionOrMasterEditionRecordKeyAccount(editionOrMasterEditionRecordKey ag_solanago.PublicKey) *DeprecatedValidateSafetyDepositBoxV1

SetEditionOrMasterEditionRecordKeyAccount sets the "editionOrMasterEditionRecordKey" account. Edition OR MasterEdition record key Remember this does not need to be an existing account (may not be depending on token), just is a pda with seed of ['metadata', program id, Printing mint id, 'edition']. - remember PDA is relative to token metadata program.

func (*DeprecatedValidateSafetyDepositBoxV1) SetLimitedEditionPrintingMintAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) SetLimitedEditionPrintingMintAccount(limitedEditionPrintingMint ag_solanago.PublicKey) *DeprecatedValidateSafetyDepositBoxV1

SetLimitedEditionPrintingMintAccount sets the "limitedEditionPrintingMint" account. Limited edition Printing mint account (optional - only if using sending Limited Edition)

func (*DeprecatedValidateSafetyDepositBoxV1) SetLimitedEditionPrintingMintAuthorityAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) SetLimitedEditionPrintingMintAuthorityAccount(limitedEditionPrintingMintAuthority ag_solanago.PublicKey) *DeprecatedValidateSafetyDepositBoxV1

SetLimitedEditionPrintingMintAuthorityAccount sets the "limitedEditionPrintingMintAuthority" account. Limited edition Printing mint Authority account, this will TEMPORARILY TRANSFER MINTING AUTHORITY to the auction manager until all limited editions have been redeemed for authority tokens.

func (*DeprecatedValidateSafetyDepositBoxV1) SetMetadataAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) SetMetadataAccount(metadataAccount ag_solanago.PublicKey) *DeprecatedValidateSafetyDepositBoxV1

SetMetadataAccount sets the "metadataAccount" account. Metadata account

func (*DeprecatedValidateSafetyDepositBoxV1) SetMetadataAuthorityAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) SetMetadataAuthorityAccount(metadataAuthority ag_solanago.PublicKey) *DeprecatedValidateSafetyDepositBoxV1

SetMetadataAuthorityAccount sets the "metadataAuthority" account. [optional] Metadata Authority - Signer only required if doing a full ownership txfer

func (*DeprecatedValidateSafetyDepositBoxV1) SetMintAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) SetMintAccount(mintAccount ag_solanago.PublicKey) *DeprecatedValidateSafetyDepositBoxV1

SetMintAccount sets the "mintAccount" account. Mint account of the token in the safety deposit box

func (*DeprecatedValidateSafetyDepositBoxV1) SetOriginalAuthorityLookupAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) SetOriginalAuthorityLookupAccount(originalAuthorityLookup ag_solanago.PublicKey) *DeprecatedValidateSafetyDepositBoxV1

SetOriginalAuthorityLookupAccount sets the "originalAuthorityLookup" account. Original authority lookup - unallocated uninitialized pda account with seed ['metaplex', auction key, metadata key] We will store original authority here to return it later.

func (*DeprecatedValidateSafetyDepositBoxV1) SetPayerAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) SetPayerAccount(payer ag_solanago.PublicKey) *DeprecatedValidateSafetyDepositBoxV1

SetPayerAccount sets the "payer" account. Payer

func (*DeprecatedValidateSafetyDepositBoxV1) SetRentSysvarAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) SetRentSysvarAccount(rentSysvar ag_solanago.PublicKey) *DeprecatedValidateSafetyDepositBoxV1

SetRentSysvarAccount sets the "rentSysvar" account. Rent sysvar

func (*DeprecatedValidateSafetyDepositBoxV1) SetSafetyDepositBoxAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) SetSafetyDepositBoxAccount(safetyDepositBox ag_solanago.PublicKey) *DeprecatedValidateSafetyDepositBoxV1

SetSafetyDepositBoxAccount sets the "safetyDepositBox" account. Safety deposit box account

func (*DeprecatedValidateSafetyDepositBoxV1) SetSafetyDepositBoxStorageAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) SetSafetyDepositBoxStorageAccount(safetyDepositBoxStorage ag_solanago.PublicKey) *DeprecatedValidateSafetyDepositBoxV1

SetSafetyDepositBoxStorageAccount sets the "safetyDepositBoxStorage" account. Safety deposit box storage account where the actual nft token is stored

func (*DeprecatedValidateSafetyDepositBoxV1) SetSystemAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) SetSystemAccount(system ag_solanago.PublicKey) *DeprecatedValidateSafetyDepositBoxV1

SetSystemAccount sets the "system" account. System

func (*DeprecatedValidateSafetyDepositBoxV1) SetTokenMetadataProgramAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) SetTokenMetadataProgramAccount(tokenMetadataProgram ag_solanago.PublicKey) *DeprecatedValidateSafetyDepositBoxV1

SetTokenMetadataProgramAccount sets the "tokenMetadataProgram" account. Token metadata program

func (*DeprecatedValidateSafetyDepositBoxV1) SetUninitializedSafetyDepositValidationTicketAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) SetUninitializedSafetyDepositValidationTicketAccount(uninitializedSafetyDepositValidationTicket ag_solanago.PublicKey) *DeprecatedValidateSafetyDepositBoxV1

SetUninitializedSafetyDepositValidationTicketAccount sets the "uninitializedSafetyDepositValidationTicket" account. Uninitialized Safety deposit validation ticket, pda of seed ['metaplex', program id, auction manager key, safety deposit key]

func (*DeprecatedValidateSafetyDepositBoxV1) SetVaultAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) SetVaultAccount(vaultAccount ag_solanago.PublicKey) *DeprecatedValidateSafetyDepositBoxV1

SetVaultAccount sets the "vaultAccount" account. Vault account

func (*DeprecatedValidateSafetyDepositBoxV1) SetWhitelistedCreatorEntryAccount 

func (inst *DeprecatedValidateSafetyDepositBoxV1) SetWhitelistedCreatorEntryAccount(whitelistedCreatorEntry ag_solanago.PublicKey) *DeprecatedValidateSafetyDepositBoxV1

SetWhitelistedCreatorEntryAccount sets the "whitelistedCreatorEntry" account. A whitelisted creator entry for the store of this auction manager pda of ['metaplex', store key, creator key] where creator key comes from creator list of metadata, any will do

func (*DeprecatedValidateSafetyDepositBoxV1) UnmarshalWithDecoder 

func (obj *DeprecatedValidateSafetyDepositBoxV1) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

func (*DeprecatedValidateSafetyDepositBoxV1) Validate 

func (inst *DeprecatedValidateSafetyDepositBoxV1) Validate() error

func (DeprecatedValidateSafetyDepositBoxV1) ValidateAndBuild 

func (inst DeprecatedValidateSafetyDepositBoxV1) ValidateAndBuild() (*Instruction, error)

ValidateAndBuild validates the instruction parameters and accounts; if there is a validation error, it returns the error. Otherwise, it builds and returns the instruction.

type EmptyPaymentAccount 

type EmptyPaymentAccount struct {
	Args *EmptyPaymentAccountArgs

	// [0] = [WRITE] acceptPayment
	// ··········· The accept payment account on the auction manager
	//
	// [1] = [WRITE] destinationAccount
	// ··········· The destination account of same mint type as the accept payment account. Must be an Associated Token Account.
	//
	// [2] = [WRITE] auctionManager
	// ··········· Auction manager
	//
	// [3] = [WRITE] payoutTicketInfo
	// ··········· Payout ticket info to keep track of this artist or auctioneer's payment, pda of [metaplex, auction manager, winning config index OR 'participation', safety deposit key]
	//
	// [4] = [SIGNER] payer
	// ··········· payer
	//
	// [5] = [] metadata
	// ··········· The metadata
	//
	// [6] = [] masterEdition
	// ··········· The master edition of the metadata (optional if exists)
	// ··········· (pda of ['metadata', program id, metadata mint id, 'edition']) - remember PDA is relative to token metadata program
	//
	// [7] = [] safetyDepositBox
	// ··········· Safety deposit box account
	//
	// [8] = [] auctionManagerStore
	// ··········· The store of the auction manager
	//
	// [9] = [] vault
	// ··········· The vault
	//
	// [10] = [] auction
	// ··········· Auction
	//
	// [11] = [] tokenProgram
	// ··········· Token program
	//
	// [12] = [] systemProgram
	// ··········· System program
	//
	// [13] = [] rentSysvar
	// ··········· Rent sysvar
	//
	// [14] = [] auctionWinnerTokenTypeTracker
	// ··········· AuctionWinnerTokenTypeTracker, pda of seed ['metaplex', program id, auction manager key, 'totals']
	//
	// [15] = [] safetyDepositConfig
	// ··········· Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit]
	ag_solanago.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

At any time, the auction manager authority may empty whatever funds are in the accept payment account on the auction manager. Funds come here from fixed price payments for partipation nfts, and from draining bid payments from the auction.

This action specifically takes a given safety deposit box, winning config, and creator on a metadata for the token inside that safety deposit box and pumps the requisite monies out to that creator as required by the royalties formula.

It's up to the UI to iterate through all winning configs, all safety deposit boxes in a given winning config tier, and all creators for each metadata attached to each safety deposit box, to get all the money. Note that one safety deposit box can be used in multiple different winning configs, but this shouldn't make any difference to this function.

We designed this function to be called in this loop-like manner because there is a limit to the number of accounts that can be passed up at once (32) and there may be many more than that easily in a given auction, so it's easier for the implementer to just loop through and call it, and there is an incentive for them to do so (to get paid.) It's permissionless as well as it will empty into any destination account owned by the creator that has the proper mint, so anybody can call it.

For the participation NFT, there is no winning config, but the total is figured by summing the winning bids and subtracting from the total escrow amount present.

func NewEmptyPaymentAccountInstruction 

func NewEmptyPaymentAccountInstruction(

	args EmptyPaymentAccountArgs,

	acceptPayment ag_solanago.PublicKey,
	destinationAccount ag_solanago.PublicKey,
	auctionManager ag_solanago.PublicKey,
	payoutTicketInfo ag_solanago.PublicKey,
	payer ag_solanago.PublicKey,
	metadata ag_solanago.PublicKey,
	masterEdition ag_solanago.PublicKey,
	safetyDepositBox ag_solanago.PublicKey,
	auctionManagerStore ag_solanago.PublicKey,
	vault ag_solanago.PublicKey,
	auction ag_solanago.PublicKey,
	tokenProgram ag_solanago.PublicKey,
	systemProgram ag_solanago.PublicKey,
	rentSysvar ag_solanago.PublicKey,
	auctionWinnerTokenTypeTracker ag_solanago.PublicKey,
	safetyDepositConfig ag_solanago.PublicKey) *EmptyPaymentAccount

NewEmptyPaymentAccountInstruction declares a new EmptyPaymentAccount instruction with the provided parameters and accounts.

func NewEmptyPaymentAccountInstructionBuilder 

func NewEmptyPaymentAccountInstructionBuilder() *EmptyPaymentAccount

NewEmptyPaymentAccountInstructionBuilder creates a new `EmptyPaymentAccount` instruction builder.

func (EmptyPaymentAccount) Build 

func (inst EmptyPaymentAccount) Build() *Instruction

func (*EmptyPaymentAccount) EncodeToTree 

func (inst *EmptyPaymentAccount) EncodeToTree(parent ag_treeout.Branches)

func (*EmptyPaymentAccount) GetAcceptPaymentAccount 

func (inst *EmptyPaymentAccount) GetAcceptPaymentAccount() *ag_solanago.AccountMeta

GetAcceptPaymentAccount gets the "acceptPayment" account. The accept payment account on the auction manager

func (*EmptyPaymentAccount) GetAuctionAccount 

func (inst *EmptyPaymentAccount) GetAuctionAccount() *ag_solanago.AccountMeta

GetAuctionAccount gets the "auction" account. Auction

func (*EmptyPaymentAccount) GetAuctionManagerAccount 

func (inst *EmptyPaymentAccount) GetAuctionManagerAccount() *ag_solanago.AccountMeta

GetAuctionManagerAccount gets the "auctionManager" account. Auction manager

func (*EmptyPaymentAccount) GetAuctionManagerStoreAccount 

func (inst *EmptyPaymentAccount) GetAuctionManagerStoreAccount() *ag_solanago.AccountMeta

GetAuctionManagerStoreAccount gets the "auctionManagerStore" account. The store of the auction manager

func (*EmptyPaymentAccount) GetAuctionWinnerTokenTypeTrackerAccount 

func (inst *EmptyPaymentAccount) GetAuctionWinnerTokenTypeTrackerAccount() *ag_solanago.AccountMeta

GetAuctionWinnerTokenTypeTrackerAccount gets the "auctionWinnerTokenTypeTracker" account. AuctionWinnerTokenTypeTracker, pda of seed ['metaplex', program id, auction manager key, 'totals']

func (*EmptyPaymentAccount) GetDestinationAccount 

func (inst *EmptyPaymentAccount) GetDestinationAccount() *ag_solanago.AccountMeta

GetDestinationAccount gets the "destinationAccount" account. The destination account of same mint type as the accept payment account. Must be an Associated Token Account.

func (*EmptyPaymentAccount) GetMasterEditionAccount 

func (inst *EmptyPaymentAccount) GetMasterEditionAccount() *ag_solanago.AccountMeta

GetMasterEditionAccount gets the "masterEdition" account. The master edition of the metadata (optional if exists) (pda of ['metadata', program id, metadata mint id, 'edition']) - remember PDA is relative to token metadata program

func (*EmptyPaymentAccount) GetMetadataAccount 

func (inst *EmptyPaymentAccount) GetMetadataAccount() *ag_solanago.AccountMeta

GetMetadataAccount gets the "metadata" account. The metadata

func (*EmptyPaymentAccount) GetPayerAccount 

func (inst *EmptyPaymentAccount) GetPayerAccount() *ag_solanago.AccountMeta

GetPayerAccount gets the "payer" account. payer

func (*EmptyPaymentAccount) GetPayoutTicketInfoAccount 

func (inst *EmptyPaymentAccount) GetPayoutTicketInfoAccount() *ag_solanago.AccountMeta

GetPayoutTicketInfoAccount gets the "payoutTicketInfo" account. Payout ticket info to keep track of this artist or auctioneer's payment, pda of [metaplex, auction manager, winning config index OR 'participation', safety deposit key]

func (*EmptyPaymentAccount) GetRentSysvarAccount 

func (inst *EmptyPaymentAccount) GetRentSysvarAccount() *ag_solanago.AccountMeta

GetRentSysvarAccount gets the "rentSysvar" account. Rent sysvar

func (*EmptyPaymentAccount) GetSafetyDepositBoxAccount 

func (inst *EmptyPaymentAccount) GetSafetyDepositBoxAccount() *ag_solanago.AccountMeta

GetSafetyDepositBoxAccount gets the "safetyDepositBox" account. Safety deposit box account

func (*EmptyPaymentAccount) GetSafetyDepositConfigAccount 

func (inst *EmptyPaymentAccount) GetSafetyDepositConfigAccount() *ag_solanago.AccountMeta

GetSafetyDepositConfigAccount gets the "safetyDepositConfig" account. Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit]

func (*EmptyPaymentAccount) GetSystemProgramAccount 

func (inst *EmptyPaymentAccount) GetSystemProgramAccount() *ag_solanago.AccountMeta

GetSystemProgramAccount gets the "systemProgram" account. System program

func (*EmptyPaymentAccount) GetTokenProgramAccount 

func (inst *EmptyPaymentAccount) GetTokenProgramAccount() *ag_solanago.AccountMeta

GetTokenProgramAccount gets the "tokenProgram" account. Token program

func (*EmptyPaymentAccount) GetVaultAccount 

func (inst *EmptyPaymentAccount) GetVaultAccount() *ag_solanago.AccountMeta

GetVaultAccount gets the "vault" account. The vault

func (EmptyPaymentAccount) MarshalWithEncoder 

func (obj EmptyPaymentAccount) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*EmptyPaymentAccount) SetAcceptPaymentAccount 

func (inst *EmptyPaymentAccount) SetAcceptPaymentAccount(acceptPayment ag_solanago.PublicKey) *EmptyPaymentAccount

SetAcceptPaymentAccount sets the "acceptPayment" account. The accept payment account on the auction manager

func (*EmptyPaymentAccount) SetArgs 

func (inst *EmptyPaymentAccount) SetArgs(args EmptyPaymentAccountArgs) *EmptyPaymentAccount

SetArgs sets the "args" parameter.

func (*EmptyPaymentAccount) SetAuctionAccount 

func (inst *EmptyPaymentAccount) SetAuctionAccount(auction ag_solanago.PublicKey) *EmptyPaymentAccount

SetAuctionAccount sets the "auction" account. Auction

func (*EmptyPaymentAccount) SetAuctionManagerAccount 

func (inst *EmptyPaymentAccount) SetAuctionManagerAccount(auctionManager ag_solanago.PublicKey) *EmptyPaymentAccount

SetAuctionManagerAccount sets the "auctionManager" account. Auction manager

func (*EmptyPaymentAccount) SetAuctionManagerStoreAccount 

func (inst *EmptyPaymentAccount) SetAuctionManagerStoreAccount(auctionManagerStore ag_solanago.PublicKey) *EmptyPaymentAccount

SetAuctionManagerStoreAccount sets the "auctionManagerStore" account. The store of the auction manager

func (*EmptyPaymentAccount) SetAuctionWinnerTokenTypeTrackerAccount 

func (inst *EmptyPaymentAccount) SetAuctionWinnerTokenTypeTrackerAccount(auctionWinnerTokenTypeTracker ag_solanago.PublicKey) *EmptyPaymentAccount

SetAuctionWinnerTokenTypeTrackerAccount sets the "auctionWinnerTokenTypeTracker" account. AuctionWinnerTokenTypeTracker, pda of seed ['metaplex', program id, auction manager key, 'totals']

func (*EmptyPaymentAccount) SetDestinationAccount 

func (inst *EmptyPaymentAccount) SetDestinationAccount(destinationAccount ag_solanago.PublicKey) *EmptyPaymentAccount

SetDestinationAccount sets the "destinationAccount" account. The destination account of same mint type as the accept payment account. Must be an Associated Token Account.

func (*EmptyPaymentAccount) SetMasterEditionAccount 

func (inst *EmptyPaymentAccount) SetMasterEditionAccount(masterEdition ag_solanago.PublicKey) *EmptyPaymentAccount

SetMasterEditionAccount sets the "masterEdition" account. The master edition of the metadata (optional if exists) (pda of ['metadata', program id, metadata mint id, 'edition']) - remember PDA is relative to token metadata program

func (*EmptyPaymentAccount) SetMetadataAccount 

func (inst *EmptyPaymentAccount) SetMetadataAccount(metadata ag_solanago.PublicKey) *EmptyPaymentAccount

SetMetadataAccount sets the "metadata" account. The metadata

func (*EmptyPaymentAccount) SetPayerAccount 

func (inst *EmptyPaymentAccount) SetPayerAccount(payer ag_solanago.PublicKey) *EmptyPaymentAccount

SetPayerAccount sets the "payer" account. payer

func (*EmptyPaymentAccount) SetPayoutTicketInfoAccount 

func (inst *EmptyPaymentAccount) SetPayoutTicketInfoAccount(payoutTicketInfo ag_solanago.PublicKey) *EmptyPaymentAccount

SetPayoutTicketInfoAccount sets the "payoutTicketInfo" account. Payout ticket info to keep track of this artist or auctioneer's payment, pda of [metaplex, auction manager, winning config index OR 'participation', safety deposit key]

func (*EmptyPaymentAccount) SetRentSysvarAccount 

func (inst *EmptyPaymentAccount) SetRentSysvarAccount(rentSysvar ag_solanago.PublicKey) *EmptyPaymentAccount

SetRentSysvarAccount sets the "rentSysvar" account. Rent sysvar

func (*EmptyPaymentAccount) SetSafetyDepositBoxAccount 

func (inst *EmptyPaymentAccount) SetSafetyDepositBoxAccount(safetyDepositBox ag_solanago.PublicKey) *EmptyPaymentAccount

SetSafetyDepositBoxAccount sets the "safetyDepositBox" account. Safety deposit box account

func (*EmptyPaymentAccount) SetSafetyDepositConfigAccount 

func (inst *EmptyPaymentAccount) SetSafetyDepositConfigAccount(safetyDepositConfig ag_solanago.PublicKey) *EmptyPaymentAccount

SetSafetyDepositConfigAccount sets the "safetyDepositConfig" account. Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit]

func (*EmptyPaymentAccount) SetSystemProgramAccount 

func (inst *EmptyPaymentAccount) SetSystemProgramAccount(systemProgram ag_solanago.PublicKey) *EmptyPaymentAccount

SetSystemProgramAccount sets the "systemProgram" account. System program

func (*EmptyPaymentAccount) SetTokenProgramAccount 

func (inst *EmptyPaymentAccount) SetTokenProgramAccount(tokenProgram ag_solanago.PublicKey) *EmptyPaymentAccount

SetTokenProgramAccount sets the "tokenProgram" account. Token program

func (*EmptyPaymentAccount) SetVaultAccount 

func (inst *EmptyPaymentAccount) SetVaultAccount(vault ag_solanago.PublicKey) *EmptyPaymentAccount

SetVaultAccount sets the "vault" account. The vault

func (*EmptyPaymentAccount) UnmarshalWithDecoder 

func (obj *EmptyPaymentAccount) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

func (*EmptyPaymentAccount) Validate 

func (inst *EmptyPaymentAccount) Validate() error

func (EmptyPaymentAccount) ValidateAndBuild 

func (inst EmptyPaymentAccount) ValidateAndBuild() (*Instruction, error)

ValidateAndBuild validates the instruction parameters and accounts; if there is a validation error, it returns the error. Otherwise, it builds and returns the instruction.

type EmptyPaymentAccountArgs 

type EmptyPaymentAccountArgs struct {
	// If not redeeming a participation NFT's contributions, need to provide
	// the winning config index your redeeming for. For participation, just pass None.
	WinningConfigIndex *uint8 `bin:"optional"`

	// If not redeeming a participation NFT, you also need to index into the winning config item's list.
	WinningConfigItemIndex *uint8 `bin:"optional"`

	// index in the metadata creator list, can be None if metadata has no creator list.
	CreatorIndex *uint8 `bin:"optional"`
}

func (EmptyPaymentAccountArgs) MarshalWithEncoder 

func (obj EmptyPaymentAccountArgs) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*EmptyPaymentAccountArgs) UnmarshalWithDecoder 

func (obj *EmptyPaymentAccountArgs) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type InitAuctionManagerV2 

type InitAuctionManagerV2 struct {
	Args *InitAuctionManagerV2Args

	// [0] = [WRITE] uninitializedUnallocatedAuctionManager
	// ··········· Uninitialized, unallocated auction manager account with pda of ['metaplex', auction_key from auction referenced below]
	//
	// [1] = [WRITE] auctionWinnerTokenTypeTracker
	// ··········· AuctionWinnerTokenTypeTracker, pda of seed ['metaplex', program id, auction manager key, 'totals']
	//
	// [2] = [] combinedVault
	// ··········· Combined vault account with authority set to auction manager account (this will be checked)
	// ··········· Note in addition that this vault account should have authority set to this program's pda of ['metaplex', auction_key]
	//
	// [3] = [] auction
	// ··········· Auction with auctioned item being set to the vault given and authority set to this program's pda of ['metaplex', auction_key]
	//
	// [4] = [] auctionManagerAuthority
	// ··········· Authority for the Auction Manager
	//
	// [5] = [SIGNER] payer
	// ··········· Payer
	//
	// [6] = [] acceptPayment
	// ··········· Accept payment account of same token mint as the auction for taking payment for open editions, owner should be auction manager key
	//
	// [7] = [] store
	// ··········· Store that this auction manager will belong to
	//
	// [8] = [] systemSysvar
	// ··········· System sysvar
	//
	// [9] = [] rentSysvar
	// ··········· Rent sysvar
	ag_solanago.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

Initializes an Auction Manager V2

NOTE: It is not possible to use MasterEditionV1s for participation nfts with these managers.

func NewInitAuctionManagerV2Instruction 

func NewInitAuctionManagerV2Instruction(

	args InitAuctionManagerV2Args,

	uninitializedUnallocatedAuctionManager ag_solanago.PublicKey,
	auctionWinnerTokenTypeTracker ag_solanago.PublicKey,
	combinedVault ag_solanago.PublicKey,
	auction ag_solanago.PublicKey,
	auctionManagerAuthority ag_solanago.PublicKey,
	payer ag_solanago.PublicKey,
	acceptPayment ag_solanago.PublicKey,
	store ag_solanago.PublicKey,
	systemSysvar ag_solanago.PublicKey,
	rentSysvar ag_solanago.PublicKey) *InitAuctionManagerV2

NewInitAuctionManagerV2Instruction declares a new InitAuctionManagerV2 instruction with the provided parameters and accounts.

func NewInitAuctionManagerV2InstructionBuilder 

func NewInitAuctionManagerV2InstructionBuilder() *InitAuctionManagerV2

NewInitAuctionManagerV2InstructionBuilder creates a new `InitAuctionManagerV2` instruction builder.

func (InitAuctionManagerV2) Build 

func (inst InitAuctionManagerV2) Build() *Instruction

func (*InitAuctionManagerV2) EncodeToTree 

func (inst *InitAuctionManagerV2) EncodeToTree(parent ag_treeout.Branches)

func (*InitAuctionManagerV2) GetAcceptPaymentAccount 

func (inst *InitAuctionManagerV2) GetAcceptPaymentAccount() *ag_solanago.AccountMeta

GetAcceptPaymentAccount gets the "acceptPayment" account. Accept payment account of same token mint as the auction for taking payment for open editions, owner should be auction manager key

func (*InitAuctionManagerV2) GetAuctionAccount 

func (inst *InitAuctionManagerV2) GetAuctionAccount() *ag_solanago.AccountMeta

GetAuctionAccount gets the "auction" account. Auction with auctioned item being set to the vault given and authority set to this program's pda of ['metaplex', auction_key]

func (*InitAuctionManagerV2) GetAuctionManagerAuthorityAccount 

func (inst *InitAuctionManagerV2) GetAuctionManagerAuthorityAccount() *ag_solanago.AccountMeta

GetAuctionManagerAuthorityAccount gets the "auctionManagerAuthority" account. Authority for the Auction Manager

func (*InitAuctionManagerV2) GetAuctionWinnerTokenTypeTrackerAccount 

func (inst *InitAuctionManagerV2) GetAuctionWinnerTokenTypeTrackerAccount() *ag_solanago.AccountMeta

GetAuctionWinnerTokenTypeTrackerAccount gets the "auctionWinnerTokenTypeTracker" account. AuctionWinnerTokenTypeTracker, pda of seed ['metaplex', program id, auction manager key, 'totals']

func (*InitAuctionManagerV2) GetCombinedVaultAccount 

func (inst *InitAuctionManagerV2) GetCombinedVaultAccount() *ag_solanago.AccountMeta

GetCombinedVaultAccount gets the "combinedVault" account. Combined vault account with authority set to auction manager account (this will be checked) Note in addition that this vault account should have authority set to this program's pda of ['metaplex', auction_key]

func (*InitAuctionManagerV2) GetPayerAccount 

func (inst *InitAuctionManagerV2) GetPayerAccount() *ag_solanago.AccountMeta

GetPayerAccount gets the "payer" account. Payer

func (*InitAuctionManagerV2) GetRentSysvarAccount 

func (inst *InitAuctionManagerV2) GetRentSysvarAccount() *ag_solanago.AccountMeta

GetRentSysvarAccount gets the "rentSysvar" account. Rent sysvar

func (*InitAuctionManagerV2) GetStoreAccount 

func (inst *InitAuctionManagerV2) GetStoreAccount() *ag_solanago.AccountMeta

GetStoreAccount gets the "store" account. Store that this auction manager will belong to

func (*InitAuctionManagerV2) GetSystemSysvarAccount 

func (inst *InitAuctionManagerV2) GetSystemSysvarAccount() *ag_solanago.AccountMeta

GetSystemSysvarAccount gets the "systemSysvar" account. System sysvar

func (*InitAuctionManagerV2) GetUninitializedUnallocatedAuctionManagerAccount 

func (inst *InitAuctionManagerV2) GetUninitializedUnallocatedAuctionManagerAccount() *ag_solanago.AccountMeta

GetUninitializedUnallocatedAuctionManagerAccount gets the "uninitializedUnallocatedAuctionManager" account. Uninitialized, unallocated auction manager account with pda of ['metaplex', auction_key from auction referenced below]

func (InitAuctionManagerV2) MarshalWithEncoder 

func (obj InitAuctionManagerV2) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*InitAuctionManagerV2) SetAcceptPaymentAccount 

func (inst *InitAuctionManagerV2) SetAcceptPaymentAccount(acceptPayment ag_solanago.PublicKey) *InitAuctionManagerV2

SetAcceptPaymentAccount sets the "acceptPayment" account. Accept payment account of same token mint as the auction for taking payment for open editions, owner should be auction manager key

func (*InitAuctionManagerV2) SetArgs 

func (inst *InitAuctionManagerV2) SetArgs(args InitAuctionManagerV2Args) *InitAuctionManagerV2

SetArgs sets the "args" parameter.

func (*InitAuctionManagerV2) SetAuctionAccount 

func (inst *InitAuctionManagerV2) SetAuctionAccount(auction ag_solanago.PublicKey) *InitAuctionManagerV2

SetAuctionAccount sets the "auction" account. Auction with auctioned item being set to the vault given and authority set to this program's pda of ['metaplex', auction_key]

func (*InitAuctionManagerV2) SetAuctionManagerAuthorityAccount 

func (inst *InitAuctionManagerV2) SetAuctionManagerAuthorityAccount(auctionManagerAuthority ag_solanago.PublicKey) *InitAuctionManagerV2

SetAuctionManagerAuthorityAccount sets the "auctionManagerAuthority" account. Authority for the Auction Manager

func (*InitAuctionManagerV2) SetAuctionWinnerTokenTypeTrackerAccount 

func (inst *InitAuctionManagerV2) SetAuctionWinnerTokenTypeTrackerAccount(auctionWinnerTokenTypeTracker ag_solanago.PublicKey) *InitAuctionManagerV2

SetAuctionWinnerTokenTypeTrackerAccount sets the "auctionWinnerTokenTypeTracker" account. AuctionWinnerTokenTypeTracker, pda of seed ['metaplex', program id, auction manager key, 'totals']

func (*InitAuctionManagerV2) SetCombinedVaultAccount 

func (inst *InitAuctionManagerV2) SetCombinedVaultAccount(combinedVault ag_solanago.PublicKey) *InitAuctionManagerV2

SetCombinedVaultAccount sets the "combinedVault" account. Combined vault account with authority set to auction manager account (this will be checked) Note in addition that this vault account should have authority set to this program's pda of ['metaplex', auction_key]

func (*InitAuctionManagerV2) SetPayerAccount 

func (inst *InitAuctionManagerV2) SetPayerAccount(payer ag_solanago.PublicKey) *InitAuctionManagerV2

SetPayerAccount sets the "payer" account. Payer

func (*InitAuctionManagerV2) SetRentSysvarAccount 

func (inst *InitAuctionManagerV2) SetRentSysvarAccount(rentSysvar ag_solanago.PublicKey) *InitAuctionManagerV2

SetRentSysvarAccount sets the "rentSysvar" account. Rent sysvar

func (*InitAuctionManagerV2) SetStoreAccount 

func (inst *InitAuctionManagerV2) SetStoreAccount(store ag_solanago.PublicKey) *InitAuctionManagerV2

SetStoreAccount sets the "store" account. Store that this auction manager will belong to

func (*InitAuctionManagerV2) SetSystemSysvarAccount 

func (inst *InitAuctionManagerV2) SetSystemSysvarAccount(systemSysvar ag_solanago.PublicKey) *InitAuctionManagerV2

SetSystemSysvarAccount sets the "systemSysvar" account. System sysvar

func (*InitAuctionManagerV2) SetUninitializedUnallocatedAuctionManagerAccount 

func (inst *InitAuctionManagerV2) SetUninitializedUnallocatedAuctionManagerAccount(uninitializedUnallocatedAuctionManager ag_solanago.PublicKey) *InitAuctionManagerV2

SetUninitializedUnallocatedAuctionManagerAccount sets the "uninitializedUnallocatedAuctionManager" account. Uninitialized, unallocated auction manager account with pda of ['metaplex', auction_key from auction referenced below]

func (*InitAuctionManagerV2) UnmarshalWithDecoder 

func (obj *InitAuctionManagerV2) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

func (*InitAuctionManagerV2) Validate 

func (inst *InitAuctionManagerV2) Validate() error

func (InitAuctionManagerV2) ValidateAndBuild 

func (inst InitAuctionManagerV2) ValidateAndBuild() (*Instruction, error)

ValidateAndBuild validates the instruction parameters and accounts; if there is a validation error, it returns the error. Otherwise, it builds and returns the instruction.

type InitAuctionManagerV2Args 

type InitAuctionManagerV2Args struct {
	AmountType TupleNumericType
	LengthType TupleNumericType
	MaxRanges  uint64
}

func (InitAuctionManagerV2Args) MarshalWithEncoder 

func (obj InitAuctionManagerV2Args) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*InitAuctionManagerV2Args) UnmarshalWithDecoder 

func (obj *InitAuctionManagerV2Args) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type Instruction 

type Instruction struct {
	ag_binary.BaseVariant
}

func DecodeInstruction 

func DecodeInstruction(accounts []*ag_solanago.AccountMeta, data []byte) (*Instruction, error)

func (*Instruction) Accounts 

func (inst *Instruction) Accounts() (out []*ag_solanago.AccountMeta)

func (*Instruction) Data 

func (inst *Instruction) Data() ([]byte, error)

func (*Instruction) EncodeToTree 

func (inst *Instruction) EncodeToTree(parent ag_treeout.Branches)

func (*Instruction) MarshalWithEncoder 

func (inst *Instruction) MarshalWithEncoder(encoder *ag_binary.Encoder) error

func (*Instruction) ProgramID 

func (inst *Instruction) ProgramID() ag_solanago.PublicKey

func (*Instruction) TextEncode 

func (inst *Instruction) TextEncode(encoder *ag_text.Encoder, option *ag_text.Option) error

func (*Instruction) UnmarshalWithDecoder 

func (inst *Instruction) UnmarshalWithDecoder(decoder *ag_binary.Decoder) error

type Key 

type Key ag_binary.BorshEnum
const (
	Uninitialized_Key Key = iota
	OriginalAuthorityLookupV1_Key
	BidRedemptionTicketV1_Key
	StoreV1_Key
	WhitelistedCreatorV1_Key
	PayoutTicketV1_Key
	SafetyDepositValidationTicketV1_Key
	AuctionManagerV1_Key
	PrizeTrackingTicketV1_Key
	SafetyDepositConfigV1_Key
	AuctionManagerV2_Key
	BidRedemptionTicketV2_Key
	AuctionWinnerTokenTypeTrackerV1_Key
)

func (Key) String added in v0.1.2 

func (value Key) String() string

type NonWinningConstraint 

type NonWinningConstraint ag_binary.BorshEnum
const (
	NoParticipationPrize_NonWinningConstraint NonWinningConstraint = iota
	GivenForFixedPrice_NonWinningConstraint
	GivenForBidPrice_NonWinningConstraint
)

func (NonWinningConstraint) String added in v0.1.2 

func (value NonWinningConstraint) String() string

type OriginalAuthorityLookup 

type OriginalAuthorityLookup struct {
	Key               Key
	OriginalAuthority ag_solanago.PublicKey
}

func (OriginalAuthorityLookup) MarshalWithEncoder 

func (obj OriginalAuthorityLookup) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*OriginalAuthorityLookup) UnmarshalWithDecoder 

func (obj *OriginalAuthorityLookup) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type ParticipationConfig 

type ParticipationConfig struct {
	// Setups:
	// 1. Winners get participation + not charged extra
	// 2. Winners dont get participation prize
	WinnerConstraint WinningConstraint

	// Setups:
	// 1. Losers get prize for free
	// 2. Losers get prize but pay fixed price
	// 3. Losers get prize but pay bid price
	NonWinningConstraint NonWinningConstraint

	// The safety deposit box index in the vault containing the template for the participation prize
	SafetyDepositBoxIndex uint8

	// Setting this field disconnects the participation prizes price from the bid. Any bid you submit, regardless
	// of amount, charges you the same fixed price.
	FixedPrice *uint64 `bin:"optional"`
}

func (ParticipationConfig) MarshalWithEncoder 

func (obj ParticipationConfig) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*ParticipationConfig) UnmarshalWithDecoder 

func (obj *ParticipationConfig) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type ParticipationConfigV1 

type ParticipationConfigV1 struct {
	// Setups:
	// 1. Winners get participation + not charged extra
	// 2. Winners dont get participation prize
	WinnerConstraint WinningConstraint

	// Setups:
	// 1. Losers get prize for free
	// 2. Losers get prize but pay fixed price
	// 3. Losers get prize but pay bid price
	NonWinningConstraint NonWinningConstraint

	// The safety deposit box index in the vault containing the template for the participation prize
	SafetyDepositBoxIndex uint8

	// Setting this field disconnects the participation prizes price from the bid. Any bid you submit, regardless
	// of amount, charges you the same fixed price.
	FixedPrice *uint64 `bin:"optional"`
}

func (ParticipationConfigV1) MarshalWithEncoder 

func (obj ParticipationConfigV1) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*ParticipationConfigV1) UnmarshalWithDecoder 

func (obj *ParticipationConfigV1) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type ParticipationConfigV2 

type ParticipationConfigV2 struct {
	// Setups:
	// 1. Winners get participation + not charged extra
	// 2. Winners dont get participation prize
	WinnerConstraint WinningConstraint

	// Setups:
	// 1. Losers get prize for free
	// 2. Losers get prize but pay fixed price
	// 3. Losers get prize but pay bid price
	NonWinningConstraint NonWinningConstraint

	// Setting this field disconnects the participation prizes price from the bid. Any bid you submit, regardless
	// of amount, charges you the same fixed price.
	FixedPrice *uint64 `bin:"optional"`
}

func (ParticipationConfigV2) MarshalWithEncoder 

func (obj ParticipationConfigV2) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*ParticipationConfigV2) UnmarshalWithDecoder 

func (obj *ParticipationConfigV2) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type ParticipationStateV1 

type ParticipationStateV1 struct {
	// We have this variable below to keep track in the case of the participation NFTs, whose
	// income will trickle in over time, how much the artists have in the escrow account and
	// how much would/should be owed to them if they try to claim it relative to the winning bids.
	// It's  abit tougher than a straightforward bid which has a price attached to it, because
	// there are many bids of differing amounts (in the case of GivenForBidPrice) and they dont all
	// come in at one time, so this little ledger here keeps track.
	CollectedToAcceptPayment uint64

	// Record of primary sale or not at time of auction creation, set during validation step
	PrimarySaleHappened bool
	Validated           bool

	// NOTE: DEPRECATED.
	// An account for printing authorization tokens that are made with the one time use token
	// after the auction ends. Provided during validation step.
	PrintingAuthorizationTokenAccount *ag_solanago.PublicKey `bin:"optional"`
}

func (ParticipationStateV1) MarshalWithEncoder 

func (obj ParticipationStateV1) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*ParticipationStateV1) UnmarshalWithDecoder 

func (obj *ParticipationStateV1) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type ParticipationStateV2 

type ParticipationStateV2 struct {
	// We have this variable below to keep track in the case of the participation NFTs, whose
	// income will trickle in over time, how much the artists have in the escrow account and
	// how much would/should be owed to them if they try to claim it relative to the winning bids.
	// It's  abit tougher than a straightforward bid which has a price attached to it, because
	// there are many bids of differing amounts (in the case of GivenForBidPrice) and they dont all
	// come in at one time, so this little ledger here keeps track.
	CollectedToAcceptPayment uint64
}

func (ParticipationStateV2) MarshalWithEncoder 

func (obj ParticipationStateV2) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*ParticipationStateV2) UnmarshalWithDecoder 

func (obj *ParticipationStateV2) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type PayoutTicket 

type PayoutTicket struct {
	Key        Key
	Recipient  ag_solanago.PublicKey
	AmountPaid uint64
}

func (PayoutTicket) MarshalWithEncoder 

func (obj PayoutTicket) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*PayoutTicket) UnmarshalWithDecoder 

func (obj *PayoutTicket) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type PrintingV2CalculationCheckReturn 

type PrintingV2CalculationCheckReturn struct {
	ExpectedRedemptions    uint64
	WinningConfigType      WinningConfigType
	WinningConfigItemIndex *uint8 `bin:"optional"`
}

func (PrintingV2CalculationCheckReturn) MarshalWithEncoder 

func (obj PrintingV2CalculationCheckReturn) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*PrintingV2CalculationCheckReturn) UnmarshalWithDecoder 

func (obj *PrintingV2CalculationCheckReturn) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type PrizeTrackingTicket 

type PrizeTrackingTicket struct {
	Key                 Key
	Metadata            ag_solanago.PublicKey
	SupplySnapshot      uint64
	ExpectedRedemptions uint64
	Redemptions         uint64
}

func (PrizeTrackingTicket) MarshalWithEncoder 

func (obj PrizeTrackingTicket) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*PrizeTrackingTicket) UnmarshalWithDecoder 

func (obj *PrizeTrackingTicket) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type ProxyCallAddress 

type ProxyCallAddress ag_binary.BorshEnum
const (
	RedeemBid_ProxyCallAddress ProxyCallAddress = iota
	RedeemFullRightsTransferBid_ProxyCallAddress
)

func (ProxyCallAddress) String added in v0.1.2 

func (value ProxyCallAddress) String() string

type RedeemBid 

type RedeemBid struct {

	// [0] = [WRITE] auctionManager
	// ··········· Auction manager
	//
	// [1] = [WRITE] safetyDepositTokenStorage
	// ··········· Safety deposit token storage account
	//
	// [2] = [WRITE] destinationAccount
	// ··········· Destination account.
	//
	// [3] = [WRITE] bidRedemptionKey
	// ··········· Bid redemption key -
	// ··········· Just a PDA with seed ['metaplex', auction_key, bidder_metadata_key] that we will allocate to mark that you redeemed your bid
	//
	// [4] = [WRITE] safetyDepositBox
	// ··········· Safety deposit box account
	//
	// [5] = [WRITE] vaultAccount
	// ··········· Vault account
	//
	// [6] = [WRITE] fractionMint
	// ··········· Fraction mint of the vault
	//
	// [7] = [] auction
	// ··········· Auction
	//
	// [8] = [] bidderMetadata
	// ··········· Your BidderMetadata account
	//
	// [9] = [SIGNER] bidder
	// ··········· [optional] Your Bidder account - Only needs to be signer if payer does not own
	//
	// [10] = [SIGNER] payer
	// ··········· Payer
	//
	// [11] = [] tokenProgram
	// ··········· Token program
	//
	// [12] = [] tokenVaultProgram
	// ··········· Token Vault program
	//
	// [13] = [] tokenMetadataProgram
	// ··········· Token metadata program
	//
	// [14] = [] store
	// ··········· Store
	//
	// [15] = [] system
	// ··········· System
	//
	// [16] = [] rentSysvar
	// ··········· Rent sysvar
	//
	// [17] = [] pdaBasedTransferAuthority
	// ··········· PDA-based Transfer authority to move the tokens from the store to the destination seed ['vault', program_id, vault key]
	// ··········· but please note that this is a PDA relative to the Token Vault program, with the 'vault' prefix
	//
	// [18] = [WRITE] masterEdition
	// ··········· Master edition (if Printing type of WinningConfig)
	//
	// [19] = [WRITE] reservationListPDA
	// ··········· Reservation list PDA ['metadata', program id, master edition key, 'reservation', auction manager key]
	// ··········· relative to token metadata program (if Printing type of WinningConfig)
	//
	// [20] = [] safetyDepositConfig
	// ··········· Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit]
	// ··········· This account will only get used AND BE REQUIRED in the event this is an AuctionManagerV2
	ag_solanago.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

NOTE: Requires an AuctionManagerV1. Note: This requires that auction manager be in a Running state.

If an auction is complete, you can redeem your bid for a specific item here. If you are the first to do this, The auction manager will switch from Running state to Disbursing state. If you are the last, this may change the auction manager state to Finished provided that no authorities remain to be delegated for Master Edition tokens.

NOTE: Please note that it is totally possible to redeem a bid 2x - once for a prize you won and once at the RedeemParticipationBid point for an open edition that comes as a 'token of appreciation' for bidding. They are not mutually exclusive unless explicitly set to be that way.

func NewRedeemBidInstruction 

func NewRedeemBidInstruction(

	auctionManager ag_solanago.PublicKey,
	safetyDepositTokenStorage ag_solanago.PublicKey,
	destinationAccount ag_solanago.PublicKey,
	bidRedemptionKey ag_solanago.PublicKey,
	safetyDepositBox ag_solanago.PublicKey,
	vaultAccount ag_solanago.PublicKey,
	fractionMint ag_solanago.PublicKey,
	auction ag_solanago.PublicKey,
	bidderMetadata ag_solanago.PublicKey,
	bidder ag_solanago.PublicKey,
	payer ag_solanago.PublicKey,
	tokenProgram ag_solanago.PublicKey,
	tokenVaultProgram ag_solanago.PublicKey,
	tokenMetadataProgram ag_solanago.PublicKey,
	store ag_solanago.PublicKey,
	system ag_solanago.PublicKey,
	rentSysvar ag_solanago.PublicKey,
	pdaBasedTransferAuthority ag_solanago.PublicKey,
	masterEdition ag_solanago.PublicKey,
	reservationListPDA ag_solanago.PublicKey,
	safetyDepositConfig ag_solanago.PublicKey) *RedeemBid

NewRedeemBidInstruction declares a new RedeemBid instruction with the provided parameters and accounts.

func NewRedeemBidInstructionBuilder 

func NewRedeemBidInstructionBuilder() *RedeemBid

NewRedeemBidInstructionBuilder creates a new `RedeemBid` instruction builder.

func (RedeemBid) Build 

func (inst RedeemBid) Build() *Instruction

func (*RedeemBid) EncodeToTree 

func (inst *RedeemBid) EncodeToTree(parent ag_treeout.Branches)

func (*RedeemBid) GetAuctionAccount 

func (inst *RedeemBid) GetAuctionAccount() *ag_solanago.AccountMeta

GetAuctionAccount gets the "auction" account. Auction

func (*RedeemBid) GetAuctionManagerAccount 

func (inst *RedeemBid) GetAuctionManagerAccount() *ag_solanago.AccountMeta

GetAuctionManagerAccount gets the "auctionManager" account. Auction manager

func (*RedeemBid) GetBidRedemptionKeyAccount 

func (inst *RedeemBid) GetBidRedemptionKeyAccount() *ag_solanago.AccountMeta

GetBidRedemptionKeyAccount gets the "bidRedemptionKey" account. Bid redemption key - Just a PDA with seed ['metaplex', auction_key, bidder_metadata_key] that we will allocate to mark that you redeemed your bid

func (*RedeemBid) GetBidderAccount 

func (inst *RedeemBid) GetBidderAccount() *ag_solanago.AccountMeta

GetBidderAccount gets the "bidder" account. [optional] Your Bidder account - Only needs to be signer if payer does not own

func (*RedeemBid) GetBidderMetadataAccount 

func (inst *RedeemBid) GetBidderMetadataAccount() *ag_solanago.AccountMeta

GetBidderMetadataAccount gets the "bidderMetadata" account. Your BidderMetadata account

func (*RedeemBid) GetDestinationAccount 

func (inst *RedeemBid) GetDestinationAccount() *ag_solanago.AccountMeta

GetDestinationAccount gets the "destinationAccount" account. Destination account.

func (*RedeemBid) GetFractionMintAccount 

func (inst *RedeemBid) GetFractionMintAccount() *ag_solanago.AccountMeta

GetFractionMintAccount gets the "fractionMint" account. Fraction mint of the vault

func (*RedeemBid) GetMasterEditionAccount 

func (inst *RedeemBid) GetMasterEditionAccount() *ag_solanago.AccountMeta

GetMasterEditionAccount gets the "masterEdition" account. Master edition (if Printing type of WinningConfig)

func (*RedeemBid) GetPayerAccount 

func (inst *RedeemBid) GetPayerAccount() *ag_solanago.AccountMeta

GetPayerAccount gets the "payer" account. Payer

func (*RedeemBid) GetPdaBasedTransferAuthorityAccount 

func (inst *RedeemBid) GetPdaBasedTransferAuthorityAccount() *ag_solanago.AccountMeta

GetPdaBasedTransferAuthorityAccount gets the "pdaBasedTransferAuthority" account. PDA-based Transfer authority to move the tokens from the store to the destination seed ['vault', program_id, vault key] but please note that this is a PDA relative to the Token Vault program, with the 'vault' prefix

func (*RedeemBid) GetRentSysvarAccount 

func (inst *RedeemBid) GetRentSysvarAccount() *ag_solanago.AccountMeta

GetRentSysvarAccount gets the "rentSysvar" account. Rent sysvar

func (*RedeemBid) GetReservationListPDAAccount 

func (inst *RedeemBid) GetReservationListPDAAccount() *ag_solanago.AccountMeta

GetReservationListPDAAccount gets the "reservationListPDA" account. Reservation list PDA ['metadata', program id, master edition key, 'reservation', auction manager key] relative to token metadata program (if Printing type of WinningConfig)

func (*RedeemBid) GetSafetyDepositBoxAccount 

func (inst *RedeemBid) GetSafetyDepositBoxAccount() *ag_solanago.AccountMeta

GetSafetyDepositBoxAccount gets the "safetyDepositBox" account. Safety deposit box account

func (*RedeemBid) GetSafetyDepositConfigAccount 

func (inst *RedeemBid) GetSafetyDepositConfigAccount() *ag_solanago.AccountMeta

GetSafetyDepositConfigAccount gets the "safetyDepositConfig" account. Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit] This account will only get used AND BE REQUIRED in the event this is an AuctionManagerV2

func (*RedeemBid) GetSafetyDepositTokenStorageAccount 

func (inst *RedeemBid) GetSafetyDepositTokenStorageAccount() *ag_solanago.AccountMeta

GetSafetyDepositTokenStorageAccount gets the "safetyDepositTokenStorage" account. Safety deposit token storage account

func (*RedeemBid) GetStoreAccount 

func (inst *RedeemBid) GetStoreAccount() *ag_solanago.AccountMeta

GetStoreAccount gets the "store" account. Store

func (*RedeemBid) GetSystemAccount 

func (inst *RedeemBid) GetSystemAccount() *ag_solanago.AccountMeta

GetSystemAccount gets the "system" account. System

func (*RedeemBid) GetTokenMetadataProgramAccount 

func (inst *RedeemBid) GetTokenMetadataProgramAccount() *ag_solanago.AccountMeta

GetTokenMetadataProgramAccount gets the "tokenMetadataProgram" account. Token metadata program

func (*RedeemBid) GetTokenProgramAccount 

func (inst *RedeemBid) GetTokenProgramAccount() *ag_solanago.AccountMeta

GetTokenProgramAccount gets the "tokenProgram" account. Token program

func (*RedeemBid) GetTokenVaultProgramAccount 

func (inst *RedeemBid) GetTokenVaultProgramAccount() *ag_solanago.AccountMeta

GetTokenVaultProgramAccount gets the "tokenVaultProgram" account. Token Vault program

func (*RedeemBid) GetVaultAccount 

func (inst *RedeemBid) GetVaultAccount() *ag_solanago.AccountMeta

GetVaultAccount gets the "vaultAccount" account. Vault account

func (RedeemBid) MarshalWithEncoder 

func (obj RedeemBid) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*RedeemBid) SetAuctionAccount 

func (inst *RedeemBid) SetAuctionAccount(auction ag_solanago.PublicKey) *RedeemBid

SetAuctionAccount sets the "auction" account. Auction

func (*RedeemBid) SetAuctionManagerAccount 

func (inst *RedeemBid) SetAuctionManagerAccount(auctionManager ag_solanago.PublicKey) *RedeemBid

SetAuctionManagerAccount sets the "auctionManager" account. Auction manager

func (*RedeemBid) SetBidRedemptionKeyAccount 

func (inst *RedeemBid) SetBidRedemptionKeyAccount(bidRedemptionKey ag_solanago.PublicKey) *RedeemBid

SetBidRedemptionKeyAccount sets the "bidRedemptionKey" account. Bid redemption key - Just a PDA with seed ['metaplex', auction_key, bidder_metadata_key] that we will allocate to mark that you redeemed your bid

func (*RedeemBid) SetBidderAccount 

func (inst *RedeemBid) SetBidderAccount(bidder ag_solanago.PublicKey) *RedeemBid

SetBidderAccount sets the "bidder" account. [optional] Your Bidder account - Only needs to be signer if payer does not own

func (*RedeemBid) SetBidderMetadataAccount 

func (inst *RedeemBid) SetBidderMetadataAccount(bidderMetadata ag_solanago.PublicKey) *RedeemBid

SetBidderMetadataAccount sets the "bidderMetadata" account. Your BidderMetadata account

func (*RedeemBid) SetDestinationAccount 

func (inst *RedeemBid) SetDestinationAccount(destinationAccount ag_solanago.PublicKey) *RedeemBid

SetDestinationAccount sets the "destinationAccount" account. Destination account.

func (*RedeemBid) SetFractionMintAccount 

func (inst *RedeemBid) SetFractionMintAccount(fractionMint ag_solanago.PublicKey) *RedeemBid

SetFractionMintAccount sets the "fractionMint" account. Fraction mint of the vault

func (*RedeemBid) SetMasterEditionAccount 

func (inst *RedeemBid) SetMasterEditionAccount(masterEdition ag_solanago.PublicKey) *RedeemBid

SetMasterEditionAccount sets the "masterEdition" account. Master edition (if Printing type of WinningConfig)

func (*RedeemBid) SetPayerAccount 

func (inst *RedeemBid) SetPayerAccount(payer ag_solanago.PublicKey) *RedeemBid

SetPayerAccount sets the "payer" account. Payer

func (*RedeemBid) SetPdaBasedTransferAuthorityAccount 

func (inst *RedeemBid) SetPdaBasedTransferAuthorityAccount(pdaBasedTransferAuthority ag_solanago.PublicKey) *RedeemBid

SetPdaBasedTransferAuthorityAccount sets the "pdaBasedTransferAuthority" account. PDA-based Transfer authority to move the tokens from the store to the destination seed ['vault', program_id, vault key] but please note that this is a PDA relative to the Token Vault program, with the 'vault' prefix

func (*RedeemBid) SetRentSysvarAccount 

func (inst *RedeemBid) SetRentSysvarAccount(rentSysvar ag_solanago.PublicKey) *RedeemBid

SetRentSysvarAccount sets the "rentSysvar" account. Rent sysvar

func (*RedeemBid) SetReservationListPDAAccount 

func (inst *RedeemBid) SetReservationListPDAAccount(reservationListPDA ag_solanago.PublicKey) *RedeemBid

SetReservationListPDAAccount sets the "reservationListPDA" account. Reservation list PDA ['metadata', program id, master edition key, 'reservation', auction manager key] relative to token metadata program (if Printing type of WinningConfig)

func (*RedeemBid) SetSafetyDepositBoxAccount 

func (inst *RedeemBid) SetSafetyDepositBoxAccount(safetyDepositBox ag_solanago.PublicKey) *RedeemBid

SetSafetyDepositBoxAccount sets the "safetyDepositBox" account. Safety deposit box account

func (*RedeemBid) SetSafetyDepositConfigAccount 

func (inst *RedeemBid) SetSafetyDepositConfigAccount(safetyDepositConfig ag_solanago.PublicKey) *RedeemBid

SetSafetyDepositConfigAccount sets the "safetyDepositConfig" account. Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit] This account will only get used AND BE REQUIRED in the event this is an AuctionManagerV2

func (*RedeemBid) SetSafetyDepositTokenStorageAccount 

func (inst *RedeemBid) SetSafetyDepositTokenStorageAccount(safetyDepositTokenStorage ag_solanago.PublicKey) *RedeemBid

SetSafetyDepositTokenStorageAccount sets the "safetyDepositTokenStorage" account. Safety deposit token storage account

func (*RedeemBid) SetStoreAccount 

func (inst *RedeemBid) SetStoreAccount(store ag_solanago.PublicKey) *RedeemBid

SetStoreAccount sets the "store" account. Store

func (*RedeemBid) SetSystemAccount 

func (inst *RedeemBid) SetSystemAccount(system ag_solanago.PublicKey) *RedeemBid

SetSystemAccount sets the "system" account. System

func (*RedeemBid) SetTokenMetadataProgramAccount 

func (inst *RedeemBid) SetTokenMetadataProgramAccount(tokenMetadataProgram ag_solanago.PublicKey) *RedeemBid

SetTokenMetadataProgramAccount sets the "tokenMetadataProgram" account. Token metadata program

func (*RedeemBid) SetTokenProgramAccount 

func (inst *RedeemBid) SetTokenProgramAccount(tokenProgram ag_solanago.PublicKey) *RedeemBid

SetTokenProgramAccount sets the "tokenProgram" account. Token program

func (*RedeemBid) SetTokenVaultProgramAccount 

func (inst *RedeemBid) SetTokenVaultProgramAccount(tokenVaultProgram ag_solanago.PublicKey) *RedeemBid

SetTokenVaultProgramAccount sets the "tokenVaultProgram" account. Token Vault program

func (*RedeemBid) SetVaultAccount 

func (inst *RedeemBid) SetVaultAccount(vaultAccount ag_solanago.PublicKey) *RedeemBid

SetVaultAccount sets the "vaultAccount" account. Vault account

func (*RedeemBid) UnmarshalWithDecoder 

func (obj *RedeemBid) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

func (*RedeemBid) Validate 

func (inst *RedeemBid) Validate() error

func (RedeemBid) ValidateAndBuild 

func (inst RedeemBid) ValidateAndBuild() (*Instruction, error)

ValidateAndBuild validates the instruction parameters and accounts; if there is a validation error, it returns the error. Otherwise, it builds and returns the instruction.

type RedeemFullRightsTransferBid 

type RedeemFullRightsTransferBid struct {

	// [0] = [WRITE] auctionManager
	// ··········· Auction manager
	//
	// [1] = [WRITE] safetyDepositTokenStorage
	// ··········· Safety deposit token storage account
	//
	// [2] = [WRITE] destinationAccount
	// ··········· Destination account.
	//
	// [3] = [WRITE] bidRedemptionKey
	// ··········· Bid redemption key -
	// ··········· Just a PDA with seed ['metaplex', auction_key, bidder_metadata_key] that we will allocate to mark that you redeemed your bid
	//
	// [4] = [WRITE] safetyDepositBox
	// ··········· Safety deposit box account
	//
	// [5] = [WRITE] vaultAccount
	// ··········· Vault account
	//
	// [6] = [WRITE] fractionMint
	// ··········· Fraction mint of the vault
	//
	// [7] = [] auction
	// ··········· Auction
	//
	// [8] = [] bidderMetadata
	// ··········· Your BidderMetadata account
	//
	// [9] = [SIGNER] bidder
	// ··········· Your Bidder account - Only needs to be signer if payer does not own
	//
	// [10] = [SIGNER] payer
	// ··········· Payer
	//
	// [11] = [] tokenProgram
	// ··········· Token program
	//
	// [12] = [] tokenVaultProgram
	// ··········· Token Vault program
	//
	// [13] = [] tokenMetadataProgram
	// ··········· Token metadata program
	//
	// [14] = [] store
	// ··········· Store
	//
	// [15] = [] system
	// ··········· System
	//
	// [16] = [] rentSysvar
	// ··········· Rent sysvar
	//
	// [17] = [WRITE] masterMetadata
	// ··········· Master Metadata account (pda of ['metadata', program id, Printing mint id]) - remember PDA is relative to token metadata program
	// ··········· (This account is optional, and will only be used if metadata is unique, otherwise this account key will be ignored no matter it's value)
	//
	// [18] = [] newAuthority
	// ··········· New authority for Master Metadata - If you are taking ownership of a Master Edition in and of itself, or a Limited Edition that isn't newly minted for you during this auction
	// ··········· ie someone else had it minted for themselves in a prior auction or through some other means, this is the account the metadata for these tokens will be delegated to
	// ··········· after this transaction. Otherwise this account will be ignored.
	//
	// [19] = [] pdaBasedTransferAuthority
	// ··········· PDA-based Transfer authority to move the tokens from the store to the destination seed ['vault', program_id, vault key]
	// ··········· but please note that this is a PDA relative to the Token Vault program, with the 'vault' prefix
	//
	// [20] = [] safetyDepositConfig
	// ··········· Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit]
	// ··········· This account will only get used AND BE REQUIRED in the event this is an AuctionManagerV2
	ag_solanago.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

Note: This requires that auction manager be in a Running state.

If an auction is complete, you can redeem your bid for the actual Master Edition itself if it's for that prize here. If you are the first to do this, the auction manager will switch from Running state to Disbursing state. If you are the last, this may change the auction manager state to Finished provided that no authorities remain to be delegated for Master Edition tokens.

NOTE: Please note that it is totally possible to redeem a bid 2x - once for a prize you won and once at the RedeemParticipationBid point for an open edition that comes as a 'token of appreciation' for bidding. They are not mutually exclusive unless explicitly set to be that way.

func NewRedeemFullRightsTransferBidInstruction 

func NewRedeemFullRightsTransferBidInstruction(

	auctionManager ag_solanago.PublicKey,
	safetyDepositTokenStorage ag_solanago.PublicKey,
	destinationAccount ag_solanago.PublicKey,
	bidRedemptionKey ag_solanago.PublicKey,
	safetyDepositBox ag_solanago.PublicKey,
	vaultAccount ag_solanago.PublicKey,
	fractionMint ag_solanago.PublicKey,
	auction ag_solanago.PublicKey,
	bidderMetadata ag_solanago.PublicKey,
	bidder ag_solanago.PublicKey,
	payer ag_solanago.PublicKey,
	tokenProgram ag_solanago.PublicKey,
	tokenVaultProgram ag_solanago.PublicKey,
	tokenMetadataProgram ag_solanago.PublicKey,
	store ag_solanago.PublicKey,
	system ag_solanago.PublicKey,
	rentSysvar ag_solanago.PublicKey,
	masterMetadata ag_solanago.PublicKey,
	newAuthority ag_solanago.PublicKey,
	pdaBasedTransferAuthority ag_solanago.PublicKey,
	safetyDepositConfig ag_solanago.PublicKey) *RedeemFullRightsTransferBid

NewRedeemFullRightsTransferBidInstruction declares a new RedeemFullRightsTransferBid instruction with the provided parameters and accounts.

func NewRedeemFullRightsTransferBidInstructionBuilder 

func NewRedeemFullRightsTransferBidInstructionBuilder() *RedeemFullRightsTransferBid

NewRedeemFullRightsTransferBidInstructionBuilder creates a new `RedeemFullRightsTransferBid` instruction builder.

func (RedeemFullRightsTransferBid) Build 

func (inst RedeemFullRightsTransferBid) Build() *Instruction

func (*RedeemFullRightsTransferBid) EncodeToTree 

func (inst *RedeemFullRightsTransferBid) EncodeToTree(parent ag_treeout.Branches)

func (*RedeemFullRightsTransferBid) GetAuctionAccount 

func (inst *RedeemFullRightsTransferBid) GetAuctionAccount() *ag_solanago.AccountMeta

GetAuctionAccount gets the "auction" account. Auction

func (*RedeemFullRightsTransferBid) GetAuctionManagerAccount 

func (inst *RedeemFullRightsTransferBid) GetAuctionManagerAccount() *ag_solanago.AccountMeta

GetAuctionManagerAccount gets the "auctionManager" account. Auction manager

func (*RedeemFullRightsTransferBid) GetBidRedemptionKeyAccount 

func (inst *RedeemFullRightsTransferBid) GetBidRedemptionKeyAccount() *ag_solanago.AccountMeta

GetBidRedemptionKeyAccount gets the "bidRedemptionKey" account. Bid redemption key - Just a PDA with seed ['metaplex', auction_key, bidder_metadata_key] that we will allocate to mark that you redeemed your bid

func (*RedeemFullRightsTransferBid) GetBidderAccount 

func (inst *RedeemFullRightsTransferBid) GetBidderAccount() *ag_solanago.AccountMeta

GetBidderAccount gets the "bidder" account. Your Bidder account - Only needs to be signer if payer does not own

func (*RedeemFullRightsTransferBid) GetBidderMetadataAccount 

func (inst *RedeemFullRightsTransferBid) GetBidderMetadataAccount() *ag_solanago.AccountMeta

GetBidderMetadataAccount gets the "bidderMetadata" account. Your BidderMetadata account

func (*RedeemFullRightsTransferBid) GetDestinationAccount 

func (inst *RedeemFullRightsTransferBid) GetDestinationAccount() *ag_solanago.AccountMeta

GetDestinationAccount gets the "destinationAccount" account. Destination account.

func (*RedeemFullRightsTransferBid) GetFractionMintAccount 

func (inst *RedeemFullRightsTransferBid) GetFractionMintAccount() *ag_solanago.AccountMeta

GetFractionMintAccount gets the "fractionMint" account. Fraction mint of the vault

func (*RedeemFullRightsTransferBid) GetMasterMetadataAccount 

func (inst *RedeemFullRightsTransferBid) GetMasterMetadataAccount() *ag_solanago.AccountMeta

GetMasterMetadataAccount gets the "masterMetadata" account. Master Metadata account (pda of ['metadata', program id, Printing mint id]) - remember PDA is relative to token metadata program (This account is optional, and will only be used if metadata is unique, otherwise this account key will be ignored no matter it's value)

func (*RedeemFullRightsTransferBid) GetNewAuthorityAccount 

func (inst *RedeemFullRightsTransferBid) GetNewAuthorityAccount() *ag_solanago.AccountMeta

GetNewAuthorityAccount gets the "newAuthority" account. New authority for Master Metadata - If you are taking ownership of a Master Edition in and of itself, or a Limited Edition that isn't newly minted for you during this auction ie someone else had it minted for themselves in a prior auction or through some other means, this is the account the metadata for these tokens will be delegated to after this transaction. Otherwise this account will be ignored.

func (*RedeemFullRightsTransferBid) GetPayerAccount 

func (inst *RedeemFullRightsTransferBid) GetPayerAccount() *ag_solanago.AccountMeta

GetPayerAccount gets the "payer" account. Payer

func (*RedeemFullRightsTransferBid) GetPdaBasedTransferAuthorityAccount 

func (inst *RedeemFullRightsTransferBid) GetPdaBasedTransferAuthorityAccount() *ag_solanago.AccountMeta

GetPdaBasedTransferAuthorityAccount gets the "pdaBasedTransferAuthority" account. PDA-based Transfer authority to move the tokens from the store to the destination seed ['vault', program_id, vault key] but please note that this is a PDA relative to the Token Vault program, with the 'vault' prefix

func (*RedeemFullRightsTransferBid) GetRentSysvarAccount 

func (inst *RedeemFullRightsTransferBid) GetRentSysvarAccount() *ag_solanago.AccountMeta

GetRentSysvarAccount gets the "rentSysvar" account. Rent sysvar

func (*RedeemFullRightsTransferBid) GetSafetyDepositBoxAccount 

func (inst *RedeemFullRightsTransferBid) GetSafetyDepositBoxAccount() *ag_solanago.AccountMeta

GetSafetyDepositBoxAccount gets the "safetyDepositBox" account. Safety deposit box account

func (*RedeemFullRightsTransferBid) GetSafetyDepositConfigAccount 

func (inst *RedeemFullRightsTransferBid) GetSafetyDepositConfigAccount() *ag_solanago.AccountMeta

GetSafetyDepositConfigAccount gets the "safetyDepositConfig" account. Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit] This account will only get used AND BE REQUIRED in the event this is an AuctionManagerV2

func (*RedeemFullRightsTransferBid) GetSafetyDepositTokenStorageAccount 

func (inst *RedeemFullRightsTransferBid) GetSafetyDepositTokenStorageAccount() *ag_solanago.AccountMeta

GetSafetyDepositTokenStorageAccount gets the "safetyDepositTokenStorage" account. Safety deposit token storage account

func (*RedeemFullRightsTransferBid) GetStoreAccount 

func (inst *RedeemFullRightsTransferBid) GetStoreAccount() *ag_solanago.AccountMeta

GetStoreAccount gets the "store" account. Store

func (*RedeemFullRightsTransferBid) GetSystemAccount 

func (inst *RedeemFullRightsTransferBid) GetSystemAccount() *ag_solanago.AccountMeta

GetSystemAccount gets the "system" account. System

func (*RedeemFullRightsTransferBid) GetTokenMetadataProgramAccount 

func (inst *RedeemFullRightsTransferBid) GetTokenMetadataProgramAccount() *ag_solanago.AccountMeta

GetTokenMetadataProgramAccount gets the "tokenMetadataProgram" account. Token metadata program

func (*RedeemFullRightsTransferBid) GetTokenProgramAccount 

func (inst *RedeemFullRightsTransferBid) GetTokenProgramAccount() *ag_solanago.AccountMeta

GetTokenProgramAccount gets the "tokenProgram" account. Token program

func (*RedeemFullRightsTransferBid) GetTokenVaultProgramAccount 

func (inst *RedeemFullRightsTransferBid) GetTokenVaultProgramAccount() *ag_solanago.AccountMeta

GetTokenVaultProgramAccount gets the "tokenVaultProgram" account. Token Vault program

func (*RedeemFullRightsTransferBid) GetVaultAccount 

func (inst *RedeemFullRightsTransferBid) GetVaultAccount() *ag_solanago.AccountMeta

GetVaultAccount gets the "vaultAccount" account. Vault account

func (RedeemFullRightsTransferBid) MarshalWithEncoder 

func (obj RedeemFullRightsTransferBid) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*RedeemFullRightsTransferBid) SetAuctionAccount 

func (inst *RedeemFullRightsTransferBid) SetAuctionAccount(auction ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetAuctionAccount sets the "auction" account. Auction

func (*RedeemFullRightsTransferBid) SetAuctionManagerAccount 

func (inst *RedeemFullRightsTransferBid) SetAuctionManagerAccount(auctionManager ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetAuctionManagerAccount sets the "auctionManager" account. Auction manager

func (*RedeemFullRightsTransferBid) SetBidRedemptionKeyAccount 

func (inst *RedeemFullRightsTransferBid) SetBidRedemptionKeyAccount(bidRedemptionKey ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetBidRedemptionKeyAccount sets the "bidRedemptionKey" account. Bid redemption key - Just a PDA with seed ['metaplex', auction_key, bidder_metadata_key] that we will allocate to mark that you redeemed your bid

func (*RedeemFullRightsTransferBid) SetBidderAccount 

func (inst *RedeemFullRightsTransferBid) SetBidderAccount(bidder ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetBidderAccount sets the "bidder" account. Your Bidder account - Only needs to be signer if payer does not own

func (*RedeemFullRightsTransferBid) SetBidderMetadataAccount 

func (inst *RedeemFullRightsTransferBid) SetBidderMetadataAccount(bidderMetadata ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetBidderMetadataAccount sets the "bidderMetadata" account. Your BidderMetadata account

func (*RedeemFullRightsTransferBid) SetDestinationAccount 

func (inst *RedeemFullRightsTransferBid) SetDestinationAccount(destinationAccount ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetDestinationAccount sets the "destinationAccount" account. Destination account.

func (*RedeemFullRightsTransferBid) SetFractionMintAccount 

func (inst *RedeemFullRightsTransferBid) SetFractionMintAccount(fractionMint ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetFractionMintAccount sets the "fractionMint" account. Fraction mint of the vault

func (*RedeemFullRightsTransferBid) SetMasterMetadataAccount 

func (inst *RedeemFullRightsTransferBid) SetMasterMetadataAccount(masterMetadata ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetMasterMetadataAccount sets the "masterMetadata" account. Master Metadata account (pda of ['metadata', program id, Printing mint id]) - remember PDA is relative to token metadata program (This account is optional, and will only be used if metadata is unique, otherwise this account key will be ignored no matter it's value)

func (*RedeemFullRightsTransferBid) SetNewAuthorityAccount 

func (inst *RedeemFullRightsTransferBid) SetNewAuthorityAccount(newAuthority ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetNewAuthorityAccount sets the "newAuthority" account. New authority for Master Metadata - If you are taking ownership of a Master Edition in and of itself, or a Limited Edition that isn't newly minted for you during this auction ie someone else had it minted for themselves in a prior auction or through some other means, this is the account the metadata for these tokens will be delegated to after this transaction. Otherwise this account will be ignored.

func (*RedeemFullRightsTransferBid) SetPayerAccount 

func (inst *RedeemFullRightsTransferBid) SetPayerAccount(payer ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetPayerAccount sets the "payer" account. Payer

func (*RedeemFullRightsTransferBid) SetPdaBasedTransferAuthorityAccount 

func (inst *RedeemFullRightsTransferBid) SetPdaBasedTransferAuthorityAccount(pdaBasedTransferAuthority ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetPdaBasedTransferAuthorityAccount sets the "pdaBasedTransferAuthority" account. PDA-based Transfer authority to move the tokens from the store to the destination seed ['vault', program_id, vault key] but please note that this is a PDA relative to the Token Vault program, with the 'vault' prefix

func (*RedeemFullRightsTransferBid) SetRentSysvarAccount 

func (inst *RedeemFullRightsTransferBid) SetRentSysvarAccount(rentSysvar ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetRentSysvarAccount sets the "rentSysvar" account. Rent sysvar

func (*RedeemFullRightsTransferBid) SetSafetyDepositBoxAccount 

func (inst *RedeemFullRightsTransferBid) SetSafetyDepositBoxAccount(safetyDepositBox ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetSafetyDepositBoxAccount sets the "safetyDepositBox" account. Safety deposit box account

func (*RedeemFullRightsTransferBid) SetSafetyDepositConfigAccount 

func (inst *RedeemFullRightsTransferBid) SetSafetyDepositConfigAccount(safetyDepositConfig ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetSafetyDepositConfigAccount sets the "safetyDepositConfig" account. Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit] This account will only get used AND BE REQUIRED in the event this is an AuctionManagerV2

func (*RedeemFullRightsTransferBid) SetSafetyDepositTokenStorageAccount 

func (inst *RedeemFullRightsTransferBid) SetSafetyDepositTokenStorageAccount(safetyDepositTokenStorage ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetSafetyDepositTokenStorageAccount sets the "safetyDepositTokenStorage" account. Safety deposit token storage account

func (*RedeemFullRightsTransferBid) SetStoreAccount 

func (inst *RedeemFullRightsTransferBid) SetStoreAccount(store ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetStoreAccount sets the "store" account. Store

func (*RedeemFullRightsTransferBid) SetSystemAccount 

func (inst *RedeemFullRightsTransferBid) SetSystemAccount(system ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetSystemAccount sets the "system" account. System

func (*RedeemFullRightsTransferBid) SetTokenMetadataProgramAccount 

func (inst *RedeemFullRightsTransferBid) SetTokenMetadataProgramAccount(tokenMetadataProgram ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetTokenMetadataProgramAccount sets the "tokenMetadataProgram" account. Token metadata program

func (*RedeemFullRightsTransferBid) SetTokenProgramAccount 

func (inst *RedeemFullRightsTransferBid) SetTokenProgramAccount(tokenProgram ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetTokenProgramAccount sets the "tokenProgram" account. Token program

func (*RedeemFullRightsTransferBid) SetTokenVaultProgramAccount 

func (inst *RedeemFullRightsTransferBid) SetTokenVaultProgramAccount(tokenVaultProgram ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetTokenVaultProgramAccount sets the "tokenVaultProgram" account. Token Vault program

func (*RedeemFullRightsTransferBid) SetVaultAccount 

func (inst *RedeemFullRightsTransferBid) SetVaultAccount(vaultAccount ag_solanago.PublicKey) *RedeemFullRightsTransferBid

SetVaultAccount sets the "vaultAccount" account. Vault account

func (*RedeemFullRightsTransferBid) UnmarshalWithDecoder 

func (obj *RedeemFullRightsTransferBid) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

func (*RedeemFullRightsTransferBid) Validate 

func (inst *RedeemFullRightsTransferBid) Validate() error

func (RedeemFullRightsTransferBid) ValidateAndBuild 

func (inst RedeemFullRightsTransferBid) ValidateAndBuild() (*Instruction, error)

ValidateAndBuild validates the instruction parameters and accounts; if there is a validation error, it returns the error. Otherwise, it builds and returns the instruction.

type RedeemParticipationBidV3 

type RedeemParticipationBidV3 struct {
	Args *RedeemParticipationBidV3Args

	// [0] = [WRITE] auctionManager
	// ··········· Auction manager
	//
	// [1] = [WRITE] safetyDepositTokenStorage
	// ··········· Safety deposit token storage account
	//
	// [2] = [WRITE] singleItemAccount
	// ··········· Account containing 1 token of your new mint type.
	// ··········· MUST be an associated token account of pda [wallet, token program, mint] relative to ata program.
	//
	// [3] = [WRITE] bidRedemptionKey
	// ··········· Bid redemption key -
	// ··········· Just a PDA with seed ['metaplex', auction_key, bidder_metadata_key] that we will allocate to mark that you redeemed your bid
	//
	// [4] = [] safetyDepositBox
	// ··········· Safety deposit box account
	//
	// [5] = [] vaultAccount
	// ··········· Vault account
	//
	// [6] = [WRITE] safetyDepositConfig
	// ··········· Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit]
	// ··········· This account will only get used in the event this is an AuctionManagerV2
	//
	// [7] = [] auction
	// ··········· Auction
	//
	// [8] = [] bidderMetadata
	// ··········· Your BidderMetadata account
	//
	// [9] = [] bidder
	// ··········· Your Bidder account
	//
	// [10] = [SIGNER] payer
	// ··········· Payer
	//
	// [11] = [] tokenProgram
	// ··········· Token program
	//
	// [12] = [] tokenVaultProgram
	// ··········· Token Vault program
	//
	// [13] = [] tokenMetadataProgram
	// ··········· Token metadata program
	//
	// [14] = [] store
	// ··········· Store
	//
	// [15] = [] system
	// ··········· System
	//
	// [16] = [] rentSysvar
	// ··········· Rent sysvar
	//
	// [17] = [SIGNER] transferAuthority
	// ··········· Transfer authority to move the payment in the auction's token_mint coin from the bidder account for the participation_fixed_price
	// ··········· on the auction manager to the auction manager account itself.
	//
	// [18] = [WRITE] acceptPayment
	// ··········· The accept payment account for the auction manager
	//
	// [19] = [WRITE] tokenAccount
	// ··········· The token account you will potentially pay for the open edition bid with if necessary.
	//
	// [20] = [WRITE] prizeTrackingTicket
	// ··········· Prize tracking ticket (pda of ['metaplex', program id, auction manager key, metadata mint id])
	//
	// [21] = [WRITE] newMetadataKey
	// ··········· New Metadata key (pda of ['metadata', program id, mint id])
	//
	// [22] = [WRITE] newEditionPDA
	// ··········· New Edition (pda of ['metadata', program id, mint id, 'edition'])
	//
	// [23] = [WRITE] masterEdition
	// ··········· Master Edition of token in vault V2 (pda of ['metadata', program id, master metadata mint id, 'edition']) PDA is relative to token metadata.
	//
	// [24] = [WRITE] newTokenMint
	// ··········· Mint of new token
	//
	// [25] = [WRITE] editionPDA
	// ··········· Edition pda to mark creation - will be checked for pre-existence. (pda of ['metadata', program id, master metadata mint id, 'edition', edition_number])
	// ··········· where edition_number is NOT the edition number you pass in args but actually edition_number = floor(edition/EDITION_MARKER_BIT_SIZE). PDA is relative to token metadata.
	//
	// [26] = [SIGNER] mintAuthority
	// ··········· Mint authority of new mint - THIS WILL TRANSFER AUTHORITY AWAY FROM THIS KEY
	//
	// [27] = [] metadataAccount
	// ··········· Metadata account of token in vault
	ag_solanago.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

Note: This requires that auction manager be in a Running state.

Second note: V3 is the same as V2, but it requires an additional argument because it is intended to be used with AuctionManagerV2s, not V1s, which use BidRedemptionTicketV2s, which require this additional argument (the user_provided_win_index). You can in theory pay for someone else's participation NFT and gift it to them.

If an auction is complete, you can redeem your bid for an Open Edition token if it is eligible. If you are the first to do this, The auction manager will switch from Running state to Disbursing state. If you are the last, this may change the auction manager state to Finished provided that no authorities remain to be delegated for Master Edition tokens.

NOTE: Please note that it is totally possible to redeem a bid 2x - once for a prize you won and once at this end point for a open edition that comes as a 'token of appreciation' for bidding. They are not mutually exclusive unless explicitly set to be that way.

NOTE: If you are redeeming a newly minted Open Edition, you must actually supply a destination account containing a token from a brand new mint. We do not provide the token to you. Our job with this action is to christen this mint + token combo as an official Open Edition.

func NewRedeemParticipationBidV3Instruction 

func NewRedeemParticipationBidV3Instruction(

	args RedeemParticipationBidV3Args,

	auctionManager ag_solanago.PublicKey,
	safetyDepositTokenStorage ag_solanago.PublicKey,
	singleItemAccount ag_solanago.PublicKey,
	bidRedemptionKey ag_solanago.PublicKey,
	safetyDepositBox ag_solanago.PublicKey,
	vaultAccount ag_solanago.PublicKey,
	safetyDepositConfig ag_solanago.PublicKey,
	auction ag_solanago.PublicKey,
	bidderMetadata ag_solanago.PublicKey,
	bidder ag_solanago.PublicKey,
	payer ag_solanago.PublicKey,
	tokenProgram ag_solanago.PublicKey,
	tokenVaultProgram ag_solanago.PublicKey,
	tokenMetadataProgram ag_solanago.PublicKey,
	store ag_solanago.PublicKey,
	system ag_solanago.PublicKey,
	rentSysvar ag_solanago.PublicKey,
	transferAuthority ag_solanago.PublicKey,
	acceptPayment ag_solanago.PublicKey,
	tokenAccount ag_solanago.PublicKey,
	prizeTrackingTicket ag_solanago.PublicKey,
	newMetadataKey ag_solanago.PublicKey,
	newEditionPDA ag_solanago.PublicKey,
	masterEdition ag_solanago.PublicKey,
	newTokenMint ag_solanago.PublicKey,
	editionPDA ag_solanago.PublicKey,
	mintAuthority ag_solanago.PublicKey,
	metadataAccount ag_solanago.PublicKey) *RedeemParticipationBidV3

NewRedeemParticipationBidV3Instruction declares a new RedeemParticipationBidV3 instruction with the provided parameters and accounts.

func NewRedeemParticipationBidV3InstructionBuilder 

func NewRedeemParticipationBidV3InstructionBuilder() *RedeemParticipationBidV3

NewRedeemParticipationBidV3InstructionBuilder creates a new `RedeemParticipationBidV3` instruction builder.

func (RedeemParticipationBidV3) Build 

func (inst RedeemParticipationBidV3) Build() *Instruction

func (*RedeemParticipationBidV3) EncodeToTree 

func (inst *RedeemParticipationBidV3) EncodeToTree(parent ag_treeout.Branches)

func (*RedeemParticipationBidV3) GetAcceptPaymentAccount 

func (inst *RedeemParticipationBidV3) GetAcceptPaymentAccount() *ag_solanago.AccountMeta

GetAcceptPaymentAccount gets the "acceptPayment" account. The accept payment account for the auction manager

func (*RedeemParticipationBidV3) GetAuctionAccount 

func (inst *RedeemParticipationBidV3) GetAuctionAccount() *ag_solanago.AccountMeta

GetAuctionAccount gets the "auction" account. Auction

func (*RedeemParticipationBidV3) GetAuctionManagerAccount 

func (inst *RedeemParticipationBidV3) GetAuctionManagerAccount() *ag_solanago.AccountMeta

GetAuctionManagerAccount gets the "auctionManager" account. Auction manager

func (*RedeemParticipationBidV3) GetBidRedemptionKeyAccount 

func (inst *RedeemParticipationBidV3) GetBidRedemptionKeyAccount() *ag_solanago.AccountMeta

GetBidRedemptionKeyAccount gets the "bidRedemptionKey" account. Bid redemption key - Just a PDA with seed ['metaplex', auction_key, bidder_metadata_key] that we will allocate to mark that you redeemed your bid

func (*RedeemParticipationBidV3) GetBidderAccount 

func (inst *RedeemParticipationBidV3) GetBidderAccount() *ag_solanago.AccountMeta

GetBidderAccount gets the "bidder" account. Your Bidder account

func (*RedeemParticipationBidV3) GetBidderMetadataAccount 

func (inst *RedeemParticipationBidV3) GetBidderMetadataAccount() *ag_solanago.AccountMeta

GetBidderMetadataAccount gets the "bidderMetadata" account. Your BidderMetadata account

func (*RedeemParticipationBidV3) GetEditionPDAAccount 

func (inst *RedeemParticipationBidV3) GetEditionPDAAccount() *ag_solanago.AccountMeta

GetEditionPDAAccount gets the "editionPDA" account. Edition pda to mark creation - will be checked for pre-existence. (pda of ['metadata', program id, master metadata mint id, 'edition', edition_number]) where edition_number is NOT the edition number you pass in args but actually edition_number = floor(edition/EDITION_MARKER_BIT_SIZE). PDA is relative to token metadata.

func (*RedeemParticipationBidV3) GetMasterEditionAccount 

func (inst *RedeemParticipationBidV3) GetMasterEditionAccount() *ag_solanago.AccountMeta

GetMasterEditionAccount gets the "masterEdition" account. Master Edition of token in vault V2 (pda of ['metadata', program id, master metadata mint id, 'edition']) PDA is relative to token metadata.

func (*RedeemParticipationBidV3) GetMetadataAccount 

func (inst *RedeemParticipationBidV3) GetMetadataAccount() *ag_solanago.AccountMeta

GetMetadataAccount gets the "metadataAccount" account. Metadata account of token in vault

func (*RedeemParticipationBidV3) GetMintAuthorityAccount 

func (inst *RedeemParticipationBidV3) GetMintAuthorityAccount() *ag_solanago.AccountMeta

GetMintAuthorityAccount gets the "mintAuthority" account. Mint authority of new mint - THIS WILL TRANSFER AUTHORITY AWAY FROM THIS KEY

func (*RedeemParticipationBidV3) GetNewEditionPDAAccount 

func (inst *RedeemParticipationBidV3) GetNewEditionPDAAccount() *ag_solanago.AccountMeta

GetNewEditionPDAAccount gets the "newEditionPDA" account. New Edition (pda of ['metadata', program id, mint id, 'edition'])

func (*RedeemParticipationBidV3) GetNewMetadataKeyAccount 

func (inst *RedeemParticipationBidV3) GetNewMetadataKeyAccount() *ag_solanago.AccountMeta

GetNewMetadataKeyAccount gets the "newMetadataKey" account. New Metadata key (pda of ['metadata', program id, mint id])

func (*RedeemParticipationBidV3) GetNewTokenMintAccount 

func (inst *RedeemParticipationBidV3) GetNewTokenMintAccount() *ag_solanago.AccountMeta

GetNewTokenMintAccount gets the "newTokenMint" account. Mint of new token

func (*RedeemParticipationBidV3) GetPayerAccount 

func (inst *RedeemParticipationBidV3) GetPayerAccount() *ag_solanago.AccountMeta

GetPayerAccount gets the "payer" account. Payer

func (*RedeemParticipationBidV3) GetPrizeTrackingTicketAccount 

func (inst *RedeemParticipationBidV3) GetPrizeTrackingTicketAccount() *ag_solanago.AccountMeta

GetPrizeTrackingTicketAccount gets the "prizeTrackingTicket" account. Prize tracking ticket (pda of ['metaplex', program id, auction manager key, metadata mint id])

func (*RedeemParticipationBidV3) GetRentSysvarAccount 

func (inst *RedeemParticipationBidV3) GetRentSysvarAccount() *ag_solanago.AccountMeta

GetRentSysvarAccount gets the "rentSysvar" account. Rent sysvar

func (*RedeemParticipationBidV3) GetSafetyDepositBoxAccount 

func (inst *RedeemParticipationBidV3) GetSafetyDepositBoxAccount() *ag_solanago.AccountMeta

GetSafetyDepositBoxAccount gets the "safetyDepositBox" account. Safety deposit box account

func (*RedeemParticipationBidV3) GetSafetyDepositConfigAccount 

func (inst *RedeemParticipationBidV3) GetSafetyDepositConfigAccount() *ag_solanago.AccountMeta

GetSafetyDepositConfigAccount gets the "safetyDepositConfig" account. Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit] This account will only get used in the event this is an AuctionManagerV2

func (*RedeemParticipationBidV3) GetSafetyDepositTokenStorageAccount 

func (inst *RedeemParticipationBidV3) GetSafetyDepositTokenStorageAccount() *ag_solanago.AccountMeta

GetSafetyDepositTokenStorageAccount gets the "safetyDepositTokenStorage" account. Safety deposit token storage account

func (*RedeemParticipationBidV3) GetSingleItemAccount 

func (inst *RedeemParticipationBidV3) GetSingleItemAccount() *ag_solanago.AccountMeta

GetSingleItemAccount gets the "singleItemAccount" account. Account containing 1 token of your new mint type. MUST be an associated token account of pda [wallet, token program, mint] relative to ata program.

func (*RedeemParticipationBidV3) GetStoreAccount 

func (inst *RedeemParticipationBidV3) GetStoreAccount() *ag_solanago.AccountMeta

GetStoreAccount gets the "store" account. Store

func (*RedeemParticipationBidV3) GetSystemAccount 

func (inst *RedeemParticipationBidV3) GetSystemAccount() *ag_solanago.AccountMeta

GetSystemAccount gets the "system" account. System

func (*RedeemParticipationBidV3) GetTokenAccount 

func (inst *RedeemParticipationBidV3) GetTokenAccount() *ag_solanago.AccountMeta

GetTokenAccount gets the "tokenAccount" account. The token account you will potentially pay for the open edition bid with if necessary.

func (*RedeemParticipationBidV3) GetTokenMetadataProgramAccount 

func (inst *RedeemParticipationBidV3) GetTokenMetadataProgramAccount() *ag_solanago.AccountMeta

GetTokenMetadataProgramAccount gets the "tokenMetadataProgram" account. Token metadata program

func (*RedeemParticipationBidV3) GetTokenProgramAccount 

func (inst *RedeemParticipationBidV3) GetTokenProgramAccount() *ag_solanago.AccountMeta

GetTokenProgramAccount gets the "tokenProgram" account. Token program

func (*RedeemParticipationBidV3) GetTokenVaultProgramAccount 

func (inst *RedeemParticipationBidV3) GetTokenVaultProgramAccount() *ag_solanago.AccountMeta

GetTokenVaultProgramAccount gets the "tokenVaultProgram" account. Token Vault program

func (*RedeemParticipationBidV3) GetTransferAuthorityAccount 

func (inst *RedeemParticipationBidV3) GetTransferAuthorityAccount() *ag_solanago.AccountMeta

GetTransferAuthorityAccount gets the "transferAuthority" account. Transfer authority to move the payment in the auction's token_mint coin from the bidder account for the participation_fixed_price on the auction manager to the auction manager account itself.

func (*RedeemParticipationBidV3) GetVaultAccount 

func (inst *RedeemParticipationBidV3) GetVaultAccount() *ag_solanago.AccountMeta

GetVaultAccount gets the "vaultAccount" account. Vault account

func (RedeemParticipationBidV3) MarshalWithEncoder 

func (obj RedeemParticipationBidV3) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*RedeemParticipationBidV3) SetAcceptPaymentAccount 

func (inst *RedeemParticipationBidV3) SetAcceptPaymentAccount(acceptPayment ag_solanago.PublicKey) *RedeemParticipationBidV3

SetAcceptPaymentAccount sets the "acceptPayment" account. The accept payment account for the auction manager

func (*RedeemParticipationBidV3) SetArgs 

func (inst *RedeemParticipationBidV3) SetArgs(args RedeemParticipationBidV3Args) *RedeemParticipationBidV3

SetArgs sets the "args" parameter.

func (*RedeemParticipationBidV3) SetAuctionAccount 

func (inst *RedeemParticipationBidV3) SetAuctionAccount(auction ag_solanago.PublicKey) *RedeemParticipationBidV3

SetAuctionAccount sets the "auction" account. Auction

func (*RedeemParticipationBidV3) SetAuctionManagerAccount 

func (inst *RedeemParticipationBidV3) SetAuctionManagerAccount(auctionManager ag_solanago.PublicKey) *RedeemParticipationBidV3

SetAuctionManagerAccount sets the "auctionManager" account. Auction manager

func (*RedeemParticipationBidV3) SetBidRedemptionKeyAccount 

func (inst *RedeemParticipationBidV3) SetBidRedemptionKeyAccount(bidRedemptionKey ag_solanago.PublicKey) *RedeemParticipationBidV3

SetBidRedemptionKeyAccount sets the "bidRedemptionKey" account. Bid redemption key - Just a PDA with seed ['metaplex', auction_key, bidder_metadata_key] that we will allocate to mark that you redeemed your bid

func (*RedeemParticipationBidV3) SetBidderAccount 

func (inst *RedeemParticipationBidV3) SetBidderAccount(bidder ag_solanago.PublicKey) *RedeemParticipationBidV3

SetBidderAccount sets the "bidder" account. Your Bidder account

func (*RedeemParticipationBidV3) SetBidderMetadataAccount 

func (inst *RedeemParticipationBidV3) SetBidderMetadataAccount(bidderMetadata ag_solanago.PublicKey) *RedeemParticipationBidV3

SetBidderMetadataAccount sets the "bidderMetadata" account. Your BidderMetadata account

func (*RedeemParticipationBidV3) SetEditionPDAAccount 

func (inst *RedeemParticipationBidV3) SetEditionPDAAccount(editionPDA ag_solanago.PublicKey) *RedeemParticipationBidV3

SetEditionPDAAccount sets the "editionPDA" account. Edition pda to mark creation - will be checked for pre-existence. (pda of ['metadata', program id, master metadata mint id, 'edition', edition_number]) where edition_number is NOT the edition number you pass in args but actually edition_number = floor(edition/EDITION_MARKER_BIT_SIZE). PDA is relative to token metadata.

func (*RedeemParticipationBidV3) SetMasterEditionAccount 

func (inst *RedeemParticipationBidV3) SetMasterEditionAccount(masterEdition ag_solanago.PublicKey) *RedeemParticipationBidV3

SetMasterEditionAccount sets the "masterEdition" account. Master Edition of token in vault V2 (pda of ['metadata', program id, master metadata mint id, 'edition']) PDA is relative to token metadata.

func (*RedeemParticipationBidV3) SetMetadataAccount 

func (inst *RedeemParticipationBidV3) SetMetadataAccount(metadataAccount ag_solanago.PublicKey) *RedeemParticipationBidV3

SetMetadataAccount sets the "metadataAccount" account. Metadata account of token in vault

func (*RedeemParticipationBidV3) SetMintAuthorityAccount 

func (inst *RedeemParticipationBidV3) SetMintAuthorityAccount(mintAuthority ag_solanago.PublicKey) *RedeemParticipationBidV3

SetMintAuthorityAccount sets the "mintAuthority" account. Mint authority of new mint - THIS WILL TRANSFER AUTHORITY AWAY FROM THIS KEY

func (*RedeemParticipationBidV3) SetNewEditionPDAAccount 

func (inst *RedeemParticipationBidV3) SetNewEditionPDAAccount(newEditionPDA ag_solanago.PublicKey) *RedeemParticipationBidV3

SetNewEditionPDAAccount sets the "newEditionPDA" account. New Edition (pda of ['metadata', program id, mint id, 'edition'])

func (*RedeemParticipationBidV3) SetNewMetadataKeyAccount 

func (inst *RedeemParticipationBidV3) SetNewMetadataKeyAccount(newMetadataKey ag_solanago.PublicKey) *RedeemParticipationBidV3

SetNewMetadataKeyAccount sets the "newMetadataKey" account. New Metadata key (pda of ['metadata', program id, mint id])

func (*RedeemParticipationBidV3) SetNewTokenMintAccount 

func (inst *RedeemParticipationBidV3) SetNewTokenMintAccount(newTokenMint ag_solanago.PublicKey) *RedeemParticipationBidV3

SetNewTokenMintAccount sets the "newTokenMint" account. Mint of new token

func (*RedeemParticipationBidV3) SetPayerAccount 

func (inst *RedeemParticipationBidV3) SetPayerAccount(payer ag_solanago.PublicKey) *RedeemParticipationBidV3

SetPayerAccount sets the "payer" account. Payer

func (*RedeemParticipationBidV3) SetPrizeTrackingTicketAccount 

func (inst *RedeemParticipationBidV3) SetPrizeTrackingTicketAccount(prizeTrackingTicket ag_solanago.PublicKey) *RedeemParticipationBidV3

SetPrizeTrackingTicketAccount sets the "prizeTrackingTicket" account. Prize tracking ticket (pda of ['metaplex', program id, auction manager key, metadata mint id])

func (*RedeemParticipationBidV3) SetRentSysvarAccount 

func (inst *RedeemParticipationBidV3) SetRentSysvarAccount(rentSysvar ag_solanago.PublicKey) *RedeemParticipationBidV3

SetRentSysvarAccount sets the "rentSysvar" account. Rent sysvar

func (*RedeemParticipationBidV3) SetSafetyDepositBoxAccount 

func (inst *RedeemParticipationBidV3) SetSafetyDepositBoxAccount(safetyDepositBox ag_solanago.PublicKey) *RedeemParticipationBidV3

SetSafetyDepositBoxAccount sets the "safetyDepositBox" account. Safety deposit box account

func (*RedeemParticipationBidV3) SetSafetyDepositConfigAccount 

func (inst *RedeemParticipationBidV3) SetSafetyDepositConfigAccount(safetyDepositConfig ag_solanago.PublicKey) *RedeemParticipationBidV3

SetSafetyDepositConfigAccount sets the "safetyDepositConfig" account. Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit] This account will only get used in the event this is an AuctionManagerV2

func (*RedeemParticipationBidV3) SetSafetyDepositTokenStorageAccount 

func (inst *RedeemParticipationBidV3) SetSafetyDepositTokenStorageAccount(safetyDepositTokenStorage ag_solanago.PublicKey) *RedeemParticipationBidV3

SetSafetyDepositTokenStorageAccount sets the "safetyDepositTokenStorage" account. Safety deposit token storage account

func (*RedeemParticipationBidV3) SetSingleItemAccount 

func (inst *RedeemParticipationBidV3) SetSingleItemAccount(singleItemAccount ag_solanago.PublicKey) *RedeemParticipationBidV3

SetSingleItemAccount sets the "singleItemAccount" account. Account containing 1 token of your new mint type. MUST be an associated token account of pda [wallet, token program, mint] relative to ata program.

func (*RedeemParticipationBidV3) SetStoreAccount 

func (inst *RedeemParticipationBidV3) SetStoreAccount(store ag_solanago.PublicKey) *RedeemParticipationBidV3

SetStoreAccount sets the "store" account. Store

func (*RedeemParticipationBidV3) SetSystemAccount 

func (inst *RedeemParticipationBidV3) SetSystemAccount(system ag_solanago.PublicKey) *RedeemParticipationBidV3

SetSystemAccount sets the "system" account. System

func (*RedeemParticipationBidV3) SetTokenAccount 

func (inst *RedeemParticipationBidV3) SetTokenAccount(tokenAccount ag_solanago.PublicKey) *RedeemParticipationBidV3

SetTokenAccount sets the "tokenAccount" account. The token account you will potentially pay for the open edition bid with if necessary.

func (*RedeemParticipationBidV3) SetTokenMetadataProgramAccount 

func (inst *RedeemParticipationBidV3) SetTokenMetadataProgramAccount(tokenMetadataProgram ag_solanago.PublicKey) *RedeemParticipationBidV3

SetTokenMetadataProgramAccount sets the "tokenMetadataProgram" account. Token metadata program

func (*RedeemParticipationBidV3) SetTokenProgramAccount 

func (inst *RedeemParticipationBidV3) SetTokenProgramAccount(tokenProgram ag_solanago.PublicKey) *RedeemParticipationBidV3

SetTokenProgramAccount sets the "tokenProgram" account. Token program

func (*RedeemParticipationBidV3) SetTokenVaultProgramAccount 

func (inst *RedeemParticipationBidV3) SetTokenVaultProgramAccount(tokenVaultProgram ag_solanago.PublicKey) *RedeemParticipationBidV3

SetTokenVaultProgramAccount sets the "tokenVaultProgram" account. Token Vault program

func (*RedeemParticipationBidV3) SetTransferAuthorityAccount 

func (inst *RedeemParticipationBidV3) SetTransferAuthorityAccount(transferAuthority ag_solanago.PublicKey) *RedeemParticipationBidV3

SetTransferAuthorityAccount sets the "transferAuthority" account. Transfer authority to move the payment in the auction's token_mint coin from the bidder account for the participation_fixed_price on the auction manager to the auction manager account itself.

func (*RedeemParticipationBidV3) SetVaultAccount 

func (inst *RedeemParticipationBidV3) SetVaultAccount(vaultAccount ag_solanago.PublicKey) *RedeemParticipationBidV3

SetVaultAccount sets the "vaultAccount" account. Vault account

func (*RedeemParticipationBidV3) UnmarshalWithDecoder 

func (obj *RedeemParticipationBidV3) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

func (*RedeemParticipationBidV3) Validate 

func (inst *RedeemParticipationBidV3) Validate() error

func (RedeemParticipationBidV3) ValidateAndBuild 

func (inst RedeemParticipationBidV3) ValidateAndBuild() (*Instruction, error)

ValidateAndBuild validates the instruction parameters and accounts; if there is a validation error, it returns the error. Otherwise, it builds and returns the instruction.

type RedeemParticipationBidV3Args 

type RedeemParticipationBidV3Args struct {
	WinIndex *uint64 `bin:"optional"`
}

func (RedeemParticipationBidV3Args) MarshalWithEncoder 

func (obj RedeemParticipationBidV3Args) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*RedeemParticipationBidV3Args) UnmarshalWithDecoder 

func (obj *RedeemParticipationBidV3Args) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type RedeemPrintingV2Bid 

type RedeemPrintingV2Bid struct {
	Args *RedeemPrintingV2BidArgs

	// [0] = [WRITE] auctionManager
	// ··········· Auction manager
	//
	// [1] = [WRITE] safetyDepositTokenStorage
	// ··········· Safety deposit token storage account
	//
	// [2] = [WRITE] singleItemAccount
	// ··········· Account containing 1 token of your new mint type.
	// ··········· MUST be an associated token account of pda [wallet, token program, mint] relative to ata program.
	//
	// [3] = [WRITE] bidRedemptionKey
	// ··········· Bid redemption key -
	// ··········· Just a PDA with seed ['metaplex', auction_key, bidder_metadata_key] that we will allocate to mark that you redeemed your bid
	//
	// [4] = [WRITE] safetyDepositBox
	// ··········· Safety deposit box account
	//
	// [5] = [WRITE] vaultAccount
	// ··········· Vault account
	//
	// [6] = [] safetyDepositConfig
	// ··········· Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit]
	// ··········· This account will only get used in the event this is an AuctionManagerV2
	//
	// [7] = [] auction
	// ··········· Auction
	//
	// [8] = [] bidderMetadata
	// ··········· Your BidderMetadata account
	//
	// [9] = [] bidder
	// ··········· Your Bidder account - Only needs to be signer if payer does not own
	//
	// [10] = [SIGNER] payer
	// ··········· Payer
	//
	// [11] = [] tokenProgram
	// ··········· Token program
	//
	// [12] = [] tokenVaultProgram
	// ··········· Token Vault program
	//
	// [13] = [] tokenMetadataProgram
	// ··········· Token metadata program
	//
	// [14] = [] store
	// ··········· Store
	//
	// [15] = [] system
	// ··········· System
	//
	// [16] = [] rentSysvar
	// ··········· Rent sysvar
	//
	// [17] = [WRITE] prizeTrackingTicket
	// ··········· Prize tracking ticket (pda of ['metaplex', program id, auction manager key, metadata mint id])
	//
	// [18] = [WRITE] newMetadataKey
	// ··········· New Metadata key (pda of ['metadata', program id, mint id])
	//
	// [19] = [WRITE] newEditionPDA
	// ··········· New Edition (pda of ['metadata', program id, mint id, 'edition'])
	//
	// [20] = [WRITE] masterEdition
	// ··········· Master Edition of token in vault V2 (pda of ['metadata', program id, master metadata mint id, 'edition']) PDA is relative to token metadata.
	//
	// [21] = [WRITE] newTokenMint
	// ··········· Mint of new token
	//
	// [22] = [WRITE] editionPDA
	// ··········· Edition pda to mark creation - will be checked for pre-existence. (pda of ['metadata', program id, master metadata mint id, 'edition', edition_number])
	// ··········· where edition_number is NOT the edition number you pass in args but actually edition_number = floor(edition/EDITION_MARKER_BIT_SIZE). PDA is relative to token metadata.
	//
	// [23] = [SIGNER] mintAuthority
	// ··········· Mint authority of new mint - THIS WILL TRANSFER AUTHORITY AWAY FROM THIS KEY
	//
	// [24] = [] metadataAccount
	// ··········· Metadata account of token in vault
	ag_solanago.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

Note: This requires that auction manager be in a Running state and that be of the V1 type.

If an auction is complete, you can redeem your printing v2 bid for a specific item here. If you are the first to do this, The auction manager will switch from Running state to Disbursing state. If you are the last, this may change the auction manager state to Finished provided that no authorities remain to be delegated for Master Edition tokens.

NOTE: Please note that it is totally possible to redeem a bid 2x - once for a prize you won and once at the RedeemParticipationBid point for an open edition that comes as a 'token of appreciation' for bidding. They are not mutually exclusive unless explicitly set to be that way.

func NewRedeemPrintingV2BidInstruction 

func NewRedeemPrintingV2BidInstruction(

	args RedeemPrintingV2BidArgs,

	auctionManager ag_solanago.PublicKey,
	safetyDepositTokenStorage ag_solanago.PublicKey,
	singleItemAccount ag_solanago.PublicKey,
	bidRedemptionKey ag_solanago.PublicKey,
	safetyDepositBox ag_solanago.PublicKey,
	vaultAccount ag_solanago.PublicKey,
	safetyDepositConfig ag_solanago.PublicKey,
	auction ag_solanago.PublicKey,
	bidderMetadata ag_solanago.PublicKey,
	bidder ag_solanago.PublicKey,
	payer ag_solanago.PublicKey,
	tokenProgram ag_solanago.PublicKey,
	tokenVaultProgram ag_solanago.PublicKey,
	tokenMetadataProgram ag_solanago.PublicKey,
	store ag_solanago.PublicKey,
	system ag_solanago.PublicKey,
	rentSysvar ag_solanago.PublicKey,
	prizeTrackingTicket ag_solanago.PublicKey,
	newMetadataKey ag_solanago.PublicKey,
	newEditionPDA ag_solanago.PublicKey,
	masterEdition ag_solanago.PublicKey,
	newTokenMint ag_solanago.PublicKey,
	editionPDA ag_solanago.PublicKey,
	mintAuthority ag_solanago.PublicKey,
	metadataAccount ag_solanago.PublicKey) *RedeemPrintingV2Bid

NewRedeemPrintingV2BidInstruction declares a new RedeemPrintingV2Bid instruction with the provided parameters and accounts.

func NewRedeemPrintingV2BidInstructionBuilder 

func NewRedeemPrintingV2BidInstructionBuilder() *RedeemPrintingV2Bid

NewRedeemPrintingV2BidInstructionBuilder creates a new `RedeemPrintingV2Bid` instruction builder.

func (RedeemPrintingV2Bid) Build 

func (inst RedeemPrintingV2Bid) Build() *Instruction

func (*RedeemPrintingV2Bid) EncodeToTree 

func (inst *RedeemPrintingV2Bid) EncodeToTree(parent ag_treeout.Branches)

func (*RedeemPrintingV2Bid) GetAuctionAccount 

func (inst *RedeemPrintingV2Bid) GetAuctionAccount() *ag_solanago.AccountMeta

GetAuctionAccount gets the "auction" account. Auction

func (*RedeemPrintingV2Bid) GetAuctionManagerAccount 

func (inst *RedeemPrintingV2Bid) GetAuctionManagerAccount() *ag_solanago.AccountMeta

GetAuctionManagerAccount gets the "auctionManager" account. Auction manager

func (*RedeemPrintingV2Bid) GetBidRedemptionKeyAccount 

func (inst *RedeemPrintingV2Bid) GetBidRedemptionKeyAccount() *ag_solanago.AccountMeta

GetBidRedemptionKeyAccount gets the "bidRedemptionKey" account. Bid redemption key - Just a PDA with seed ['metaplex', auction_key, bidder_metadata_key] that we will allocate to mark that you redeemed your bid

func (*RedeemPrintingV2Bid) GetBidderAccount 

func (inst *RedeemPrintingV2Bid) GetBidderAccount() *ag_solanago.AccountMeta

GetBidderAccount gets the "bidder" account. Your Bidder account - Only needs to be signer if payer does not own

func (*RedeemPrintingV2Bid) GetBidderMetadataAccount 

func (inst *RedeemPrintingV2Bid) GetBidderMetadataAccount() *ag_solanago.AccountMeta

GetBidderMetadataAccount gets the "bidderMetadata" account. Your BidderMetadata account

func (*RedeemPrintingV2Bid) GetEditionPDAAccount 

func (inst *RedeemPrintingV2Bid) GetEditionPDAAccount() *ag_solanago.AccountMeta

GetEditionPDAAccount gets the "editionPDA" account. Edition pda to mark creation - will be checked for pre-existence. (pda of ['metadata', program id, master metadata mint id, 'edition', edition_number]) where edition_number is NOT the edition number you pass in args but actually edition_number = floor(edition/EDITION_MARKER_BIT_SIZE). PDA is relative to token metadata.

func (*RedeemPrintingV2Bid) GetMasterEditionAccount 

func (inst *RedeemPrintingV2Bid) GetMasterEditionAccount() *ag_solanago.AccountMeta

GetMasterEditionAccount gets the "masterEdition" account. Master Edition of token in vault V2 (pda of ['metadata', program id, master metadata mint id, 'edition']) PDA is relative to token metadata.

func (*RedeemPrintingV2Bid) GetMetadataAccount 

func (inst *RedeemPrintingV2Bid) GetMetadataAccount() *ag_solanago.AccountMeta

GetMetadataAccount gets the "metadataAccount" account. Metadata account of token in vault

func (*RedeemPrintingV2Bid) GetMintAuthorityAccount 

func (inst *RedeemPrintingV2Bid) GetMintAuthorityAccount() *ag_solanago.AccountMeta

GetMintAuthorityAccount gets the "mintAuthority" account. Mint authority of new mint - THIS WILL TRANSFER AUTHORITY AWAY FROM THIS KEY

func (*RedeemPrintingV2Bid) GetNewEditionPDAAccount 

func (inst *RedeemPrintingV2Bid) GetNewEditionPDAAccount() *ag_solanago.AccountMeta

GetNewEditionPDAAccount gets the "newEditionPDA" account. New Edition (pda of ['metadata', program id, mint id, 'edition'])

func (*RedeemPrintingV2Bid) GetNewMetadataKeyAccount 

func (inst *RedeemPrintingV2Bid) GetNewMetadataKeyAccount() *ag_solanago.AccountMeta

GetNewMetadataKeyAccount gets the "newMetadataKey" account. New Metadata key (pda of ['metadata', program id, mint id])

func (*RedeemPrintingV2Bid) GetNewTokenMintAccount 

func (inst *RedeemPrintingV2Bid) GetNewTokenMintAccount() *ag_solanago.AccountMeta

GetNewTokenMintAccount gets the "newTokenMint" account. Mint of new token

func (*RedeemPrintingV2Bid) GetPayerAccount 

func (inst *RedeemPrintingV2Bid) GetPayerAccount() *ag_solanago.AccountMeta

GetPayerAccount gets the "payer" account. Payer

func (*RedeemPrintingV2Bid) GetPrizeTrackingTicketAccount 

func (inst *RedeemPrintingV2Bid) GetPrizeTrackingTicketAccount() *ag_solanago.AccountMeta

GetPrizeTrackingTicketAccount gets the "prizeTrackingTicket" account. Prize tracking ticket (pda of ['metaplex', program id, auction manager key, metadata mint id])

func (*RedeemPrintingV2Bid) GetRentSysvarAccount 

func (inst *RedeemPrintingV2Bid) GetRentSysvarAccount() *ag_solanago.AccountMeta

GetRentSysvarAccount gets the "rentSysvar" account. Rent sysvar

func (*RedeemPrintingV2Bid) GetSafetyDepositBoxAccount 

func (inst *RedeemPrintingV2Bid) GetSafetyDepositBoxAccount() *ag_solanago.AccountMeta

GetSafetyDepositBoxAccount gets the "safetyDepositBox" account. Safety deposit box account

func (*RedeemPrintingV2Bid) GetSafetyDepositConfigAccount 

func (inst *RedeemPrintingV2Bid) GetSafetyDepositConfigAccount() *ag_solanago.AccountMeta

GetSafetyDepositConfigAccount gets the "safetyDepositConfig" account. Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit] This account will only get used in the event this is an AuctionManagerV2

func (*RedeemPrintingV2Bid) GetSafetyDepositTokenStorageAccount 

func (inst *RedeemPrintingV2Bid) GetSafetyDepositTokenStorageAccount() *ag_solanago.AccountMeta

GetSafetyDepositTokenStorageAccount gets the "safetyDepositTokenStorage" account. Safety deposit token storage account

func (*RedeemPrintingV2Bid) GetSingleItemAccount 

func (inst *RedeemPrintingV2Bid) GetSingleItemAccount() *ag_solanago.AccountMeta

GetSingleItemAccount gets the "singleItemAccount" account. Account containing 1 token of your new mint type. MUST be an associated token account of pda [wallet, token program, mint] relative to ata program.

func (*RedeemPrintingV2Bid) GetStoreAccount 

func (inst *RedeemPrintingV2Bid) GetStoreAccount() *ag_solanago.AccountMeta

GetStoreAccount gets the "store" account. Store

func (*RedeemPrintingV2Bid) GetSystemAccount 

func (inst *RedeemPrintingV2Bid) GetSystemAccount() *ag_solanago.AccountMeta

GetSystemAccount gets the "system" account. System

func (*RedeemPrintingV2Bid) GetTokenMetadataProgramAccount 

func (inst *RedeemPrintingV2Bid) GetTokenMetadataProgramAccount() *ag_solanago.AccountMeta

GetTokenMetadataProgramAccount gets the "tokenMetadataProgram" account. Token metadata program

func (*RedeemPrintingV2Bid) GetTokenProgramAccount 

func (inst *RedeemPrintingV2Bid) GetTokenProgramAccount() *ag_solanago.AccountMeta

GetTokenProgramAccount gets the "tokenProgram" account. Token program

func (*RedeemPrintingV2Bid) GetTokenVaultProgramAccount 

func (inst *RedeemPrintingV2Bid) GetTokenVaultProgramAccount() *ag_solanago.AccountMeta

GetTokenVaultProgramAccount gets the "tokenVaultProgram" account. Token Vault program

func (*RedeemPrintingV2Bid) GetVaultAccount 

func (inst *RedeemPrintingV2Bid) GetVaultAccount() *ag_solanago.AccountMeta

GetVaultAccount gets the "vaultAccount" account. Vault account

func (RedeemPrintingV2Bid) MarshalWithEncoder 

func (obj RedeemPrintingV2Bid) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*RedeemPrintingV2Bid) SetArgs 

func (inst *RedeemPrintingV2Bid) SetArgs(args RedeemPrintingV2BidArgs) *RedeemPrintingV2Bid

SetArgs sets the "args" parameter.

func (*RedeemPrintingV2Bid) SetAuctionAccount 

func (inst *RedeemPrintingV2Bid) SetAuctionAccount(auction ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetAuctionAccount sets the "auction" account. Auction

func (*RedeemPrintingV2Bid) SetAuctionManagerAccount 

func (inst *RedeemPrintingV2Bid) SetAuctionManagerAccount(auctionManager ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetAuctionManagerAccount sets the "auctionManager" account. Auction manager

func (*RedeemPrintingV2Bid) SetBidRedemptionKeyAccount 

func (inst *RedeemPrintingV2Bid) SetBidRedemptionKeyAccount(bidRedemptionKey ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetBidRedemptionKeyAccount sets the "bidRedemptionKey" account. Bid redemption key - Just a PDA with seed ['metaplex', auction_key, bidder_metadata_key] that we will allocate to mark that you redeemed your bid

func (*RedeemPrintingV2Bid) SetBidderAccount 

func (inst *RedeemPrintingV2Bid) SetBidderAccount(bidder ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetBidderAccount sets the "bidder" account. Your Bidder account - Only needs to be signer if payer does not own

func (*RedeemPrintingV2Bid) SetBidderMetadataAccount 

func (inst *RedeemPrintingV2Bid) SetBidderMetadataAccount(bidderMetadata ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetBidderMetadataAccount sets the "bidderMetadata" account. Your BidderMetadata account

func (*RedeemPrintingV2Bid) SetEditionPDAAccount 

func (inst *RedeemPrintingV2Bid) SetEditionPDAAccount(editionPDA ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetEditionPDAAccount sets the "editionPDA" account. Edition pda to mark creation - will be checked for pre-existence. (pda of ['metadata', program id, master metadata mint id, 'edition', edition_number]) where edition_number is NOT the edition number you pass in args but actually edition_number = floor(edition/EDITION_MARKER_BIT_SIZE). PDA is relative to token metadata.

func (*RedeemPrintingV2Bid) SetMasterEditionAccount 

func (inst *RedeemPrintingV2Bid) SetMasterEditionAccount(masterEdition ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetMasterEditionAccount sets the "masterEdition" account. Master Edition of token in vault V2 (pda of ['metadata', program id, master metadata mint id, 'edition']) PDA is relative to token metadata.

func (*RedeemPrintingV2Bid) SetMetadataAccount 

func (inst *RedeemPrintingV2Bid) SetMetadataAccount(metadataAccount ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetMetadataAccount sets the "metadataAccount" account. Metadata account of token in vault

func (*RedeemPrintingV2Bid) SetMintAuthorityAccount 

func (inst *RedeemPrintingV2Bid) SetMintAuthorityAccount(mintAuthority ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetMintAuthorityAccount sets the "mintAuthority" account. Mint authority of new mint - THIS WILL TRANSFER AUTHORITY AWAY FROM THIS KEY

func (*RedeemPrintingV2Bid) SetNewEditionPDAAccount 

func (inst *RedeemPrintingV2Bid) SetNewEditionPDAAccount(newEditionPDA ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetNewEditionPDAAccount sets the "newEditionPDA" account. New Edition (pda of ['metadata', program id, mint id, 'edition'])

func (*RedeemPrintingV2Bid) SetNewMetadataKeyAccount 

func (inst *RedeemPrintingV2Bid) SetNewMetadataKeyAccount(newMetadataKey ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetNewMetadataKeyAccount sets the "newMetadataKey" account. New Metadata key (pda of ['metadata', program id, mint id])

func (*RedeemPrintingV2Bid) SetNewTokenMintAccount 

func (inst *RedeemPrintingV2Bid) SetNewTokenMintAccount(newTokenMint ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetNewTokenMintAccount sets the "newTokenMint" account. Mint of new token

func (*RedeemPrintingV2Bid) SetPayerAccount 

func (inst *RedeemPrintingV2Bid) SetPayerAccount(payer ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetPayerAccount sets the "payer" account. Payer

func (*RedeemPrintingV2Bid) SetPrizeTrackingTicketAccount 

func (inst *RedeemPrintingV2Bid) SetPrizeTrackingTicketAccount(prizeTrackingTicket ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetPrizeTrackingTicketAccount sets the "prizeTrackingTicket" account. Prize tracking ticket (pda of ['metaplex', program id, auction manager key, metadata mint id])

func (*RedeemPrintingV2Bid) SetRentSysvarAccount 

func (inst *RedeemPrintingV2Bid) SetRentSysvarAccount(rentSysvar ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetRentSysvarAccount sets the "rentSysvar" account. Rent sysvar

func (*RedeemPrintingV2Bid) SetSafetyDepositBoxAccount 

func (inst *RedeemPrintingV2Bid) SetSafetyDepositBoxAccount(safetyDepositBox ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetSafetyDepositBoxAccount sets the "safetyDepositBox" account. Safety deposit box account

func (*RedeemPrintingV2Bid) SetSafetyDepositConfigAccount 

func (inst *RedeemPrintingV2Bid) SetSafetyDepositConfigAccount(safetyDepositConfig ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetSafetyDepositConfigAccount sets the "safetyDepositConfig" account. Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit] This account will only get used in the event this is an AuctionManagerV2

func (*RedeemPrintingV2Bid) SetSafetyDepositTokenStorageAccount 

func (inst *RedeemPrintingV2Bid) SetSafetyDepositTokenStorageAccount(safetyDepositTokenStorage ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetSafetyDepositTokenStorageAccount sets the "safetyDepositTokenStorage" account. Safety deposit token storage account

func (*RedeemPrintingV2Bid) SetSingleItemAccount 

func (inst *RedeemPrintingV2Bid) SetSingleItemAccount(singleItemAccount ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetSingleItemAccount sets the "singleItemAccount" account. Account containing 1 token of your new mint type. MUST be an associated token account of pda [wallet, token program, mint] relative to ata program.

func (*RedeemPrintingV2Bid) SetStoreAccount 

func (inst *RedeemPrintingV2Bid) SetStoreAccount(store ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetStoreAccount sets the "store" account. Store

func (*RedeemPrintingV2Bid) SetSystemAccount 

func (inst *RedeemPrintingV2Bid) SetSystemAccount(system ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetSystemAccount sets the "system" account. System

func (*RedeemPrintingV2Bid) SetTokenMetadataProgramAccount 

func (inst *RedeemPrintingV2Bid) SetTokenMetadataProgramAccount(tokenMetadataProgram ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetTokenMetadataProgramAccount sets the "tokenMetadataProgram" account. Token metadata program

func (*RedeemPrintingV2Bid) SetTokenProgramAccount 

func (inst *RedeemPrintingV2Bid) SetTokenProgramAccount(tokenProgram ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetTokenProgramAccount sets the "tokenProgram" account. Token program

func (*RedeemPrintingV2Bid) SetTokenVaultProgramAccount 

func (inst *RedeemPrintingV2Bid) SetTokenVaultProgramAccount(tokenVaultProgram ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetTokenVaultProgramAccount sets the "tokenVaultProgram" account. Token Vault program

func (*RedeemPrintingV2Bid) SetVaultAccount 

func (inst *RedeemPrintingV2Bid) SetVaultAccount(vaultAccount ag_solanago.PublicKey) *RedeemPrintingV2Bid

SetVaultAccount sets the "vaultAccount" account. Vault account

func (*RedeemPrintingV2Bid) UnmarshalWithDecoder 

func (obj *RedeemPrintingV2Bid) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

func (*RedeemPrintingV2Bid) Validate 

func (inst *RedeemPrintingV2Bid) Validate() error

func (RedeemPrintingV2Bid) ValidateAndBuild 

func (inst RedeemPrintingV2Bid) ValidateAndBuild() (*Instruction, error)

ValidateAndBuild validates the instruction parameters and accounts; if there is a validation error, it returns the error. Otherwise, it builds and returns the instruction.

type RedeemPrintingV2BidArgs 

type RedeemPrintingV2BidArgs struct {
	EditionOffset uint64
	WinIndex      uint64
}

func (RedeemPrintingV2BidArgs) MarshalWithEncoder 

func (obj RedeemPrintingV2BidArgs) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*RedeemPrintingV2BidArgs) UnmarshalWithDecoder 

func (obj *RedeemPrintingV2BidArgs) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type RedeemUnusedWinningConfigItemsAsAuctioneer 

type RedeemUnusedWinningConfigItemsAsAuctioneer struct {
	Args *RedeemUnusedWinningConfigItemsAsAuctioneerArgs

	ag_solanago.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

If you are an auctioneer, redeem an unused winning config entry. You provide the winning index, and if the winning index has no winner, then the correct redemption method is called with a special flag set to ignore bidder_metadata checks and a hardcoded winner index to empty this win to you.

All the keys, in exact sequence, should follow the expected call you wish to proxy to, because these will be passed to the process_ method of the next call. This method exists primarily to pass in an additional argument to the other redemption methods that subtly changes their behavior. We made this additional call so that if the auctioneer calls those methods directly, they still act the same as if the auctioneer were a normal bidder, which is be desirable behavior.

An auctioneer should never be in the position where the auction can never work the same for them simply because they are an auctioneer. This special endpoint exists to give them the "out" to unload items via a proxy call once the auction is over.

func NewRedeemUnusedWinningConfigItemsAsAuctioneerInstruction 

func NewRedeemUnusedWinningConfigItemsAsAuctioneerInstruction(

	args RedeemUnusedWinningConfigItemsAsAuctioneerArgs) *RedeemUnusedWinningConfigItemsAsAuctioneer

NewRedeemUnusedWinningConfigItemsAsAuctioneerInstruction declares a new RedeemUnusedWinningConfigItemsAsAuctioneer instruction with the provided parameters and accounts.

func NewRedeemUnusedWinningConfigItemsAsAuctioneerInstructionBuilder 

func NewRedeemUnusedWinningConfigItemsAsAuctioneerInstructionBuilder() *RedeemUnusedWinningConfigItemsAsAuctioneer

NewRedeemUnusedWinningConfigItemsAsAuctioneerInstructionBuilder creates a new `RedeemUnusedWinningConfigItemsAsAuctioneer` instruction builder.

func (RedeemUnusedWinningConfigItemsAsAuctioneer) Build 

func (inst RedeemUnusedWinningConfigItemsAsAuctioneer) Build() *Instruction

func (*RedeemUnusedWinningConfigItemsAsAuctioneer) EncodeToTree 

func (inst *RedeemUnusedWinningConfigItemsAsAuctioneer) EncodeToTree(parent ag_treeout.Branches)

func (RedeemUnusedWinningConfigItemsAsAuctioneer) MarshalWithEncoder 

func (obj RedeemUnusedWinningConfigItemsAsAuctioneer) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*RedeemUnusedWinningConfigItemsAsAuctioneer) SetArgs 

func (inst *RedeemUnusedWinningConfigItemsAsAuctioneer) SetArgs(args RedeemUnusedWinningConfigItemsAsAuctioneerArgs) *RedeemUnusedWinningConfigItemsAsAuctioneer

SetArgs sets the "args" parameter.

func (*RedeemUnusedWinningConfigItemsAsAuctioneer) UnmarshalWithDecoder 

func (obj *RedeemUnusedWinningConfigItemsAsAuctioneer) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

func (*RedeemUnusedWinningConfigItemsAsAuctioneer) Validate 

func (inst *RedeemUnusedWinningConfigItemsAsAuctioneer) Validate() error

func (RedeemUnusedWinningConfigItemsAsAuctioneer) ValidateAndBuild 

func (inst RedeemUnusedWinningConfigItemsAsAuctioneer) ValidateAndBuild() (*Instruction, error)

ValidateAndBuild validates the instruction parameters and accounts; if there is a validation error, it returns the error. Otherwise, it builds and returns the instruction.

type RedeemUnusedWinningConfigItemsAsAuctioneerArgs 

type RedeemUnusedWinningConfigItemsAsAuctioneerArgs struct {
	WinningConfigItemIndex uint8
	ProxyCall              ProxyCallAddress
}

func (RedeemUnusedWinningConfigItemsAsAuctioneerArgs) MarshalWithEncoder 

func (obj RedeemUnusedWinningConfigItemsAsAuctioneerArgs) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*RedeemUnusedWinningConfigItemsAsAuctioneerArgs) UnmarshalWithDecoder 

func (obj *RedeemUnusedWinningConfigItemsAsAuctioneerArgs) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type SafetyDepositConfig 

type SafetyDepositConfig struct {
	Key Key

	// reverse lookup
	AuctionManager ag_solanago.PublicKey

	// safety deposit order
	Order             uint64
	WinningConfigType WinningConfigType
	AmountType        TupleNumericType
	LengthType        TupleNumericType

	// Tuple is (amount of editions or tokens given to people in this range, length of range)
	AmountRanges []AmountRange

	// if winning config type is "Participation" then you use this to parameterize it.
	ParticipationConfig *ParticipationConfigV2 `bin:"optional"`

	// if winning config type is "Participation" then you use this to keep track of it.
	ParticipationState *ParticipationStateV2 `bin:"optional"`
}

func (SafetyDepositConfig) MarshalWithEncoder 

func (obj SafetyDepositConfig) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*SafetyDepositConfig) UnmarshalWithDecoder 

func (obj *SafetyDepositConfig) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type SafetyDepositValidationTicket 

type SafetyDepositValidationTicket struct {
	Key     Key
	Address ag_solanago.PublicKey
}

func (SafetyDepositValidationTicket) MarshalWithEncoder 

func (obj SafetyDepositValidationTicket) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*SafetyDepositValidationTicket) UnmarshalWithDecoder 

func (obj *SafetyDepositValidationTicket) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type SetStore 

type SetStore struct {
	Args *SetStoreArgs

	// [0] = [WRITE] storeKey
	// ··········· The store key, seed of ['metaplex', admin wallet]
	//
	// [1] = [SIGNER] adminWallet
	// ··········· The admin wallet
	//
	// [2] = [SIGNER] payer
	// ··········· Payer
	//
	// [3] = [] tokenProgram
	// ··········· Token program
	//
	// [4] = [] tokenVaultProgram
	// ··········· Token vault program
	//
	// [5] = [] tokenMetadataProgram
	// ··········· Token metadata program
	//
	// [6] = [] auctionProgram
	// ··········· Auction program
	//
	// [7] = [] system
	// ··········· System
	//
	// [8] = [] rentSysvar
	// ··········· Rent sysvar
	ag_solanago.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

Given a signer wallet, create a store with pda ['metaplex', wallet] (if it does not exist) and/or update it (if it already exists). Stores can be set to open (anybody can publish) or closed (publish only via whitelist).

func NewSetStoreInstruction 

func NewSetStoreInstruction(

	args SetStoreArgs,

	storeKey ag_solanago.PublicKey,
	adminWallet ag_solanago.PublicKey,
	payer ag_solanago.PublicKey,
	tokenProgram ag_solanago.PublicKey,
	tokenVaultProgram ag_solanago.PublicKey,
	tokenMetadataProgram ag_solanago.PublicKey,
	auctionProgram ag_solanago.PublicKey,
	system ag_solanago.PublicKey,
	rentSysvar ag_solanago.PublicKey) *SetStore

NewSetStoreInstruction declares a new SetStore instruction with the provided parameters and accounts.

func NewSetStoreInstructionBuilder 

func NewSetStoreInstructionBuilder() *SetStore

NewSetStoreInstructionBuilder creates a new `SetStore` instruction builder.

func (SetStore) Build 

func (inst SetStore) Build() *Instruction

func (*SetStore) EncodeToTree 

func (inst *SetStore) EncodeToTree(parent ag_treeout.Branches)

func (*SetStore) GetAdminWalletAccount 

func (inst *SetStore) GetAdminWalletAccount() *ag_solanago.AccountMeta

GetAdminWalletAccount gets the "adminWallet" account. The admin wallet

func (*SetStore) GetAuctionProgramAccount 

func (inst *SetStore) GetAuctionProgramAccount() *ag_solanago.AccountMeta

GetAuctionProgramAccount gets the "auctionProgram" account. Auction program

func (*SetStore) GetPayerAccount 

func (inst *SetStore) GetPayerAccount() *ag_solanago.AccountMeta

GetPayerAccount gets the "payer" account. Payer

func (*SetStore) GetRentSysvarAccount 

func (inst *SetStore) GetRentSysvarAccount() *ag_solanago.AccountMeta

GetRentSysvarAccount gets the "rentSysvar" account. Rent sysvar

func (*SetStore) GetStoreKeyAccount 

func (inst *SetStore) GetStoreKeyAccount() *ag_solanago.AccountMeta

GetStoreKeyAccount gets the "storeKey" account. The store key, seed of ['metaplex', admin wallet]

func (*SetStore) GetSystemAccount 

func (inst *SetStore) GetSystemAccount() *ag_solanago.AccountMeta

GetSystemAccount gets the "system" account. System

func (*SetStore) GetTokenMetadataProgramAccount 

func (inst *SetStore) GetTokenMetadataProgramAccount() *ag_solanago.AccountMeta

GetTokenMetadataProgramAccount gets the "tokenMetadataProgram" account. Token metadata program

func (*SetStore) GetTokenProgramAccount 

func (inst *SetStore) GetTokenProgramAccount() *ag_solanago.AccountMeta

GetTokenProgramAccount gets the "tokenProgram" account. Token program

func (*SetStore) GetTokenVaultProgramAccount 

func (inst *SetStore) GetTokenVaultProgramAccount() *ag_solanago.AccountMeta

GetTokenVaultProgramAccount gets the "tokenVaultProgram" account. Token vault program

func (SetStore) MarshalWithEncoder 

func (obj SetStore) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*SetStore) SetAdminWalletAccount 

func (inst *SetStore) SetAdminWalletAccount(adminWallet ag_solanago.PublicKey) *SetStore

SetAdminWalletAccount sets the "adminWallet" account. The admin wallet

func (*SetStore) SetArgs 

func (inst *SetStore) SetArgs(args SetStoreArgs) *SetStore

SetArgs sets the "args" parameter.

func (*SetStore) SetAuctionProgramAccount 

func (inst *SetStore) SetAuctionProgramAccount(auctionProgram ag_solanago.PublicKey) *SetStore

SetAuctionProgramAccount sets the "auctionProgram" account. Auction program

func (*SetStore) SetPayerAccount 

func (inst *SetStore) SetPayerAccount(payer ag_solanago.PublicKey) *SetStore

SetPayerAccount sets the "payer" account. Payer

func (*SetStore) SetRentSysvarAccount 

func (inst *SetStore) SetRentSysvarAccount(rentSysvar ag_solanago.PublicKey) *SetStore

SetRentSysvarAccount sets the "rentSysvar" account. Rent sysvar

func (*SetStore) SetStoreKeyAccount 

func (inst *SetStore) SetStoreKeyAccount(storeKey ag_solanago.PublicKey) *SetStore

SetStoreKeyAccount sets the "storeKey" account. The store key, seed of ['metaplex', admin wallet]

func (*SetStore) SetSystemAccount 

func (inst *SetStore) SetSystemAccount(system ag_solanago.PublicKey) *SetStore

SetSystemAccount sets the "system" account. System

func (*SetStore) SetTokenMetadataProgramAccount 

func (inst *SetStore) SetTokenMetadataProgramAccount(tokenMetadataProgram ag_solanago.PublicKey) *SetStore

SetTokenMetadataProgramAccount sets the "tokenMetadataProgram" account. Token metadata program

func (*SetStore) SetTokenProgramAccount 

func (inst *SetStore) SetTokenProgramAccount(tokenProgram ag_solanago.PublicKey) *SetStore

SetTokenProgramAccount sets the "tokenProgram" account. Token program

func (*SetStore) SetTokenVaultProgramAccount 

func (inst *SetStore) SetTokenVaultProgramAccount(tokenVaultProgram ag_solanago.PublicKey) *SetStore

SetTokenVaultProgramAccount sets the "tokenVaultProgram" account. Token vault program

func (*SetStore) UnmarshalWithDecoder 

func (obj *SetStore) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

func (*SetStore) Validate 

func (inst *SetStore) Validate() error

func (SetStore) ValidateAndBuild 

func (inst SetStore) ValidateAndBuild() (*Instruction, error)

ValidateAndBuild validates the instruction parameters and accounts; if there is a validation error, it returns the error. Otherwise, it builds and returns the instruction.

type SetStoreArgs 

type SetStoreArgs struct {
	Public bool
}

func (SetStoreArgs) MarshalWithEncoder 

func (obj SetStoreArgs) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*SetStoreArgs) UnmarshalWithDecoder 

func (obj *SetStoreArgs) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type SetWhitelistedCreator 

type SetWhitelistedCreator struct {
	Args *SetWhitelistedCreatorArgs

	// [0] = [WRITE] whitelistedCreatorPDAKey
	// ··········· The whitelisted creator pda key, seed of ['metaplex', store key, creator key]
	//
	// [1] = [SIGNER] adminWallet
	// ··········· The admin wallet
	//
	// [2] = [SIGNER] payer
	// ··········· Payer
	//
	// [3] = [] creatorKey
	// ··········· The creator key
	//
	// [4] = [] storeKey
	// ··········· The store key, seed of ['metaplex', admin wallet]
	//
	// [5] = [] system
	// ··········· System
	//
	// [6] = [] rentSysvar
	// ··········· Rent sysvar
	ag_solanago.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

Given an existing store, add or update an existing whitelisted creator for the store. This creates a PDA with seed ['metaplex', store key, creator key] if it does not already exist to store attributes there.

func NewSetWhitelistedCreatorInstruction 

func NewSetWhitelistedCreatorInstruction(

	args SetWhitelistedCreatorArgs,

	whitelistedCreatorPDAKey ag_solanago.PublicKey,
	adminWallet ag_solanago.PublicKey,
	payer ag_solanago.PublicKey,
	creatorKey ag_solanago.PublicKey,
	storeKey ag_solanago.PublicKey,
	system ag_solanago.PublicKey,
	rentSysvar ag_solanago.PublicKey) *SetWhitelistedCreator

NewSetWhitelistedCreatorInstruction declares a new SetWhitelistedCreator instruction with the provided parameters and accounts.

func NewSetWhitelistedCreatorInstructionBuilder 

func NewSetWhitelistedCreatorInstructionBuilder() *SetWhitelistedCreator

NewSetWhitelistedCreatorInstructionBuilder creates a new `SetWhitelistedCreator` instruction builder.

func (SetWhitelistedCreator) Build 

func (inst SetWhitelistedCreator) Build() *Instruction

func (*SetWhitelistedCreator) EncodeToTree 

func (inst *SetWhitelistedCreator) EncodeToTree(parent ag_treeout.Branches)

func (*SetWhitelistedCreator) GetAdminWalletAccount 

func (inst *SetWhitelistedCreator) GetAdminWalletAccount() *ag_solanago.AccountMeta

GetAdminWalletAccount gets the "adminWallet" account. The admin wallet

func (*SetWhitelistedCreator) GetCreatorKeyAccount 

func (inst *SetWhitelistedCreator) GetCreatorKeyAccount() *ag_solanago.AccountMeta

GetCreatorKeyAccount gets the "creatorKey" account. The creator key

func (*SetWhitelistedCreator) GetPayerAccount 

func (inst *SetWhitelistedCreator) GetPayerAccount() *ag_solanago.AccountMeta

GetPayerAccount gets the "payer" account. Payer

func (*SetWhitelistedCreator) GetRentSysvarAccount 

func (inst *SetWhitelistedCreator) GetRentSysvarAccount() *ag_solanago.AccountMeta

GetRentSysvarAccount gets the "rentSysvar" account. Rent sysvar

func (*SetWhitelistedCreator) GetStoreKeyAccount 

func (inst *SetWhitelistedCreator) GetStoreKeyAccount() *ag_solanago.AccountMeta

GetStoreKeyAccount gets the "storeKey" account. The store key, seed of ['metaplex', admin wallet]

func (*SetWhitelistedCreator) GetSystemAccount 

func (inst *SetWhitelistedCreator) GetSystemAccount() *ag_solanago.AccountMeta

GetSystemAccount gets the "system" account. System

func (*SetWhitelistedCreator) GetWhitelistedCreatorPDAKeyAccount 

func (inst *SetWhitelistedCreator) GetWhitelistedCreatorPDAKeyAccount() *ag_solanago.AccountMeta

GetWhitelistedCreatorPDAKeyAccount gets the "whitelistedCreatorPDAKey" account. The whitelisted creator pda key, seed of ['metaplex', store key, creator key]

func (SetWhitelistedCreator) MarshalWithEncoder 

func (obj SetWhitelistedCreator) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*SetWhitelistedCreator) SetAdminWalletAccount 

func (inst *SetWhitelistedCreator) SetAdminWalletAccount(adminWallet ag_solanago.PublicKey) *SetWhitelistedCreator

SetAdminWalletAccount sets the "adminWallet" account. The admin wallet

func (*SetWhitelistedCreator) SetArgs 

func (inst *SetWhitelistedCreator) SetArgs(args SetWhitelistedCreatorArgs) *SetWhitelistedCreator

SetArgs sets the "args" parameter.

func (*SetWhitelistedCreator) SetCreatorKeyAccount 

func (inst *SetWhitelistedCreator) SetCreatorKeyAccount(creatorKey ag_solanago.PublicKey) *SetWhitelistedCreator

SetCreatorKeyAccount sets the "creatorKey" account. The creator key

func (*SetWhitelistedCreator) SetPayerAccount 

func (inst *SetWhitelistedCreator) SetPayerAccount(payer ag_solanago.PublicKey) *SetWhitelistedCreator

SetPayerAccount sets the "payer" account. Payer

func (*SetWhitelistedCreator) SetRentSysvarAccount 

func (inst *SetWhitelistedCreator) SetRentSysvarAccount(rentSysvar ag_solanago.PublicKey) *SetWhitelistedCreator

SetRentSysvarAccount sets the "rentSysvar" account. Rent sysvar

func (*SetWhitelistedCreator) SetStoreKeyAccount 

func (inst *SetWhitelistedCreator) SetStoreKeyAccount(storeKey ag_solanago.PublicKey) *SetWhitelistedCreator

SetStoreKeyAccount sets the "storeKey" account. The store key, seed of ['metaplex', admin wallet]

func (*SetWhitelistedCreator) SetSystemAccount 

func (inst *SetWhitelistedCreator) SetSystemAccount(system ag_solanago.PublicKey) *SetWhitelistedCreator

SetSystemAccount sets the "system" account. System

func (*SetWhitelistedCreator) SetWhitelistedCreatorPDAKeyAccount 

func (inst *SetWhitelistedCreator) SetWhitelistedCreatorPDAKeyAccount(whitelistedCreatorPDAKey ag_solanago.PublicKey) *SetWhitelistedCreator

SetWhitelistedCreatorPDAKeyAccount sets the "whitelistedCreatorPDAKey" account. The whitelisted creator pda key, seed of ['metaplex', store key, creator key]

func (*SetWhitelistedCreator) UnmarshalWithDecoder 

func (obj *SetWhitelistedCreator) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

func (*SetWhitelistedCreator) Validate 

func (inst *SetWhitelistedCreator) Validate() error

func (SetWhitelistedCreator) ValidateAndBuild 

func (inst SetWhitelistedCreator) ValidateAndBuild() (*Instruction, error)

ValidateAndBuild validates the instruction parameters and accounts; if there is a validation error, it returns the error. Otherwise, it builds and returns the instruction.

type SetWhitelistedCreatorArgs 

type SetWhitelistedCreatorArgs struct {
	Activated bool
}

func (SetWhitelistedCreatorArgs) MarshalWithEncoder 

func (obj SetWhitelistedCreatorArgs) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*SetWhitelistedCreatorArgs) UnmarshalWithDecoder 

func (obj *SetWhitelistedCreatorArgs) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type StartAuction 

type StartAuction struct {

	// [0] = [WRITE] auctionManager
	// ··········· Auction manager
	//
	// [1] = [WRITE] auction
	// ··········· Auction
	//
	// [2] = [SIGNER] auctionManagerAuthority
	// ··········· Auction manager authority
	//
	// [3] = [] storeKey
	// ··········· Store key
	//
	// [4] = [] auctionProgram
	// ··········· Auction program
	//
	// [5] = [] clockSysvar
	// ··········· Clock sysvar
	ag_solanago.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

If the auction manager is in Validated state, it can invoke the start command via calling this command here.

func NewStartAuctionInstruction 

func NewStartAuctionInstruction(

	auctionManager ag_solanago.PublicKey,
	auction ag_solanago.PublicKey,
	auctionManagerAuthority ag_solanago.PublicKey,
	storeKey ag_solanago.PublicKey,
	auctionProgram ag_solanago.PublicKey,
	clockSysvar ag_solanago.PublicKey) *StartAuction

NewStartAuctionInstruction declares a new StartAuction instruction with the provided parameters and accounts.

func NewStartAuctionInstructionBuilder 

func NewStartAuctionInstructionBuilder() *StartAuction

NewStartAuctionInstructionBuilder creates a new `StartAuction` instruction builder.

func (StartAuction) Build 

func (inst StartAuction) Build() *Instruction

func (*StartAuction) EncodeToTree 

func (inst *StartAuction) EncodeToTree(parent ag_treeout.Branches)

func (*StartAuction) GetAuctionAccount 

func (inst *StartAuction) GetAuctionAccount() *ag_solanago.AccountMeta

GetAuctionAccount gets the "auction" account. Auction

func (*StartAuction) GetAuctionManagerAccount 

func (inst *StartAuction) GetAuctionManagerAccount() *ag_solanago.AccountMeta

GetAuctionManagerAccount gets the "auctionManager" account. Auction manager

func (*StartAuction) GetAuctionManagerAuthorityAccount 

func (inst *StartAuction) GetAuctionManagerAuthorityAccount() *ag_solanago.AccountMeta

GetAuctionManagerAuthorityAccount gets the "auctionManagerAuthority" account. Auction manager authority

func (*StartAuction) GetAuctionProgramAccount 

func (inst *StartAuction) GetAuctionProgramAccount() *ag_solanago.AccountMeta

GetAuctionProgramAccount gets the "auctionProgram" account. Auction program

func (*StartAuction) GetClockSysvarAccount 

func (inst *StartAuction) GetClockSysvarAccount() *ag_solanago.AccountMeta

GetClockSysvarAccount gets the "clockSysvar" account. Clock sysvar

func (*StartAuction) GetStoreKeyAccount 

func (inst *StartAuction) GetStoreKeyAccount() *ag_solanago.AccountMeta

GetStoreKeyAccount gets the "storeKey" account. Store key

func (StartAuction) MarshalWithEncoder 

func (obj StartAuction) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*StartAuction) SetAuctionAccount 

func (inst *StartAuction) SetAuctionAccount(auction ag_solanago.PublicKey) *StartAuction

SetAuctionAccount sets the "auction" account. Auction

func (*StartAuction) SetAuctionManagerAccount 

func (inst *StartAuction) SetAuctionManagerAccount(auctionManager ag_solanago.PublicKey) *StartAuction

SetAuctionManagerAccount sets the "auctionManager" account. Auction manager

func (*StartAuction) SetAuctionManagerAuthorityAccount 

func (inst *StartAuction) SetAuctionManagerAuthorityAccount(auctionManagerAuthority ag_solanago.PublicKey) *StartAuction

SetAuctionManagerAuthorityAccount sets the "auctionManagerAuthority" account. Auction manager authority

func (*StartAuction) SetAuctionProgramAccount 

func (inst *StartAuction) SetAuctionProgramAccount(auctionProgram ag_solanago.PublicKey) *StartAuction

SetAuctionProgramAccount sets the "auctionProgram" account. Auction program

func (*StartAuction) SetClockSysvarAccount 

func (inst *StartAuction) SetClockSysvarAccount(clockSysvar ag_solanago.PublicKey) *StartAuction

SetClockSysvarAccount sets the "clockSysvar" account. Clock sysvar

func (*StartAuction) SetStoreKeyAccount 

func (inst *StartAuction) SetStoreKeyAccount(storeKey ag_solanago.PublicKey) *StartAuction

SetStoreKeyAccount sets the "storeKey" account. Store key

func (*StartAuction) UnmarshalWithDecoder 

func (obj *StartAuction) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

func (*StartAuction) Validate 

func (inst *StartAuction) Validate() error

func (StartAuction) ValidateAndBuild 

func (inst StartAuction) ValidateAndBuild() (*Instruction, error)

ValidateAndBuild validates the instruction parameters and accounts; if there is a validation error, it returns the error. Otherwise, it builds and returns the instruction.

type Store 

type Store struct {
	Key                  Key
	Public               bool
	AuctionProgram       ag_solanago.PublicKey
	TokenVaultProgram    ag_solanago.PublicKey
	TokenMetadataProgram ag_solanago.PublicKey
	TokenProgram         ag_solanago.PublicKey
}

func (Store) MarshalWithEncoder 

func (obj Store) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*Store) UnmarshalWithDecoder 

func (obj *Store) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type TupleNumericType 

type TupleNumericType ag_binary.BorshEnum
const (
	Padding0_TupleNumericType TupleNumericType = iota
	U8_TupleNumericType
	U16_TupleNumericType
	Padding1_TupleNumericType
	U32_TupleNumericType
	Padding2_TupleNumericType
	Padding3_TupleNumericType
	Padding4_TupleNumericType
	U64_TupleNumericType
)

func (TupleNumericType) String added in v0.1.2 

func (value TupleNumericType) String() string

type ValidateSafetyDepositBoxV2 

type ValidateSafetyDepositBoxV2 struct {
	Args *SafetyDepositConfig

	// [0] = [WRITE] uninitializedSafetyDeposit
	// ··········· Uninitialized Safety deposit config, pda of seed ['metaplex', program id, auction manager key, safety deposit key]
	//
	// [1] = [WRITE] auctionWinnerTokenTypeTracker
	// ··········· AuctionWinnerTokenTypeTracker, pda of seed ['metaplex', program id, auction manager key, 'totals']
	//
	// [2] = [WRITE] auctionManager
	// ··········· Auction manager
	//
	// [3] = [WRITE] metadataAccount
	// ··········· Metadata account
	//
	// [4] = [WRITE] originalAuthorityLookup
	// ··········· Original authority lookup - unallocated uninitialized pda account with seed ['metaplex', auction key, metadata key]
	// ··········· We will store original authority here to return it later.
	//
	// [5] = [] whitelistedCreatorEntry
	// ··········· A whitelisted creator entry for the store of this auction manager pda of ['metaplex', store key, creator key]
	// ··········· where creator key comes from creator list of metadata, any will do
	//
	// [6] = [] auctionManagerStore
	// ··········· The auction manager's store key
	//
	// [7] = [] safetyDepositBox
	// ··········· Safety deposit box account
	//
	// [8] = [] safetyDepositBoxStorage
	// ··········· Safety deposit box storage account where the actual nft token is stored
	//
	// [9] = [] mintAccount
	// ··········· Mint account of the token in the safety deposit box
	//
	// [10] = [] editionOrMasteredition
	// ··········· Edition OR MasterEdition record key
	// ··········· Remember this does not need to be an existing account (may not be depending on token), just is a pda with seed
	// ··········· of ['metadata', program id, Printing mint id, 'edition']. - remember PDA is relative to token metadata program.
	//
	// [11] = [] vaultAccount
	// ··········· Vault account
	//
	// [12] = [SIGNER] authority
	// ··········· Authority
	//
	// [13] = [SIGNER] metadataAuthority
	// ··········· Metadata Authority - Signer only required if doing a full ownership txfer
	//
	// [14] = [SIGNER] payer
	// ··········· Payer
	//
	// [15] = [] tokenMetadataProgram
	// ··········· Token metadata program
	//
	// [16] = [] system
	// ··········· System
	//
	// [17] = [] rentSysvar
	// ··········· Rent sysvar
	ag_solanago.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

NOTE: Requires an AuctionManagerV2.

Validates that a given safety deposit box has in it contents that match the given SafetyDepositConfig, and creates said config. A stateful call, this will error out if you call it a second time after validation has occurred.

func NewValidateSafetyDepositBoxV2Instruction 

func NewValidateSafetyDepositBoxV2Instruction(

	args SafetyDepositConfig,

	uninitializedSafetyDeposit ag_solanago.PublicKey,
	auctionWinnerTokenTypeTracker ag_solanago.PublicKey,
	auctionManager ag_solanago.PublicKey,
	metadataAccount ag_solanago.PublicKey,
	originalAuthorityLookup ag_solanago.PublicKey,
	whitelistedCreatorEntry ag_solanago.PublicKey,
	auctionManagerStore ag_solanago.PublicKey,
	safetyDepositBox ag_solanago.PublicKey,
	safetyDepositBoxStorage ag_solanago.PublicKey,
	mintAccount ag_solanago.PublicKey,
	editionOrMasteredition ag_solanago.PublicKey,
	vaultAccount ag_solanago.PublicKey,
	authority ag_solanago.PublicKey,
	metadataAuthority ag_solanago.PublicKey,
	payer ag_solanago.PublicKey,
	tokenMetadataProgram ag_solanago.PublicKey,
	system ag_solanago.PublicKey,
	rentSysvar ag_solanago.PublicKey) *ValidateSafetyDepositBoxV2

NewValidateSafetyDepositBoxV2Instruction declares a new ValidateSafetyDepositBoxV2 instruction with the provided parameters and accounts.

func NewValidateSafetyDepositBoxV2InstructionBuilder 

func NewValidateSafetyDepositBoxV2InstructionBuilder() *ValidateSafetyDepositBoxV2

NewValidateSafetyDepositBoxV2InstructionBuilder creates a new `ValidateSafetyDepositBoxV2` instruction builder.

func (ValidateSafetyDepositBoxV2) Build 

func (inst ValidateSafetyDepositBoxV2) Build() *Instruction

func (*ValidateSafetyDepositBoxV2) EncodeToTree 

func (inst *ValidateSafetyDepositBoxV2) EncodeToTree(parent ag_treeout.Branches)

func (*ValidateSafetyDepositBoxV2) GetAuctionManagerAccount 

func (inst *ValidateSafetyDepositBoxV2) GetAuctionManagerAccount() *ag_solanago.AccountMeta

GetAuctionManagerAccount gets the "auctionManager" account. Auction manager

func (*ValidateSafetyDepositBoxV2) GetAuctionManagerStoreAccount 

func (inst *ValidateSafetyDepositBoxV2) GetAuctionManagerStoreAccount() *ag_solanago.AccountMeta

GetAuctionManagerStoreAccount gets the "auctionManagerStore" account. The auction manager's store key

func (*ValidateSafetyDepositBoxV2) GetAuctionWinnerTokenTypeTrackerAccount 

func (inst *ValidateSafetyDepositBoxV2) GetAuctionWinnerTokenTypeTrackerAccount() *ag_solanago.AccountMeta

GetAuctionWinnerTokenTypeTrackerAccount gets the "auctionWinnerTokenTypeTracker" account. AuctionWinnerTokenTypeTracker, pda of seed ['metaplex', program id, auction manager key, 'totals']

func (*ValidateSafetyDepositBoxV2) GetAuthorityAccount 

func (inst *ValidateSafetyDepositBoxV2) GetAuthorityAccount() *ag_solanago.AccountMeta

GetAuthorityAccount gets the "authority" account. Authority

func (*ValidateSafetyDepositBoxV2) GetEditionOrMastereditionAccount 

func (inst *ValidateSafetyDepositBoxV2) GetEditionOrMastereditionAccount() *ag_solanago.AccountMeta

GetEditionOrMastereditionAccount gets the "editionOrMasteredition" account. Edition OR MasterEdition record key Remember this does not need to be an existing account (may not be depending on token), just is a pda with seed of ['metadata', program id, Printing mint id, 'edition']. - remember PDA is relative to token metadata program.

func (*ValidateSafetyDepositBoxV2) GetMetadataAccount 

func (inst *ValidateSafetyDepositBoxV2) GetMetadataAccount() *ag_solanago.AccountMeta

GetMetadataAccount gets the "metadataAccount" account. Metadata account

func (*ValidateSafetyDepositBoxV2) GetMetadataAuthorityAccount 

func (inst *ValidateSafetyDepositBoxV2) GetMetadataAuthorityAccount() *ag_solanago.AccountMeta

GetMetadataAuthorityAccount gets the "metadataAuthority" account. Metadata Authority - Signer only required if doing a full ownership txfer

func (*ValidateSafetyDepositBoxV2) GetMintAccount 

func (inst *ValidateSafetyDepositBoxV2) GetMintAccount() *ag_solanago.AccountMeta

GetMintAccount gets the "mintAccount" account. Mint account of the token in the safety deposit box

func (*ValidateSafetyDepositBoxV2) GetOriginalAuthorityLookupAccount 

func (inst *ValidateSafetyDepositBoxV2) GetOriginalAuthorityLookupAccount() *ag_solanago.AccountMeta

GetOriginalAuthorityLookupAccount gets the "originalAuthorityLookup" account. Original authority lookup - unallocated uninitialized pda account with seed ['metaplex', auction key, metadata key] We will store original authority here to return it later.

func (*ValidateSafetyDepositBoxV2) GetPayerAccount 

func (inst *ValidateSafetyDepositBoxV2) GetPayerAccount() *ag_solanago.AccountMeta

GetPayerAccount gets the "payer" account. Payer

func (*ValidateSafetyDepositBoxV2) GetRentSysvarAccount 

func (inst *ValidateSafetyDepositBoxV2) GetRentSysvarAccount() *ag_solanago.AccountMeta

GetRentSysvarAccount gets the "rentSysvar" account. Rent sysvar

func (*ValidateSafetyDepositBoxV2) GetSafetyDepositBoxAccount 

func (inst *ValidateSafetyDepositBoxV2) GetSafetyDepositBoxAccount() *ag_solanago.AccountMeta

GetSafetyDepositBoxAccount gets the "safetyDepositBox" account. Safety deposit box account

func (*ValidateSafetyDepositBoxV2) GetSafetyDepositBoxStorageAccount 

func (inst *ValidateSafetyDepositBoxV2) GetSafetyDepositBoxStorageAccount() *ag_solanago.AccountMeta

GetSafetyDepositBoxStorageAccount gets the "safetyDepositBoxStorage" account. Safety deposit box storage account where the actual nft token is stored

func (*ValidateSafetyDepositBoxV2) GetSystemAccount 

func (inst *ValidateSafetyDepositBoxV2) GetSystemAccount() *ag_solanago.AccountMeta

GetSystemAccount gets the "system" account. System

func (*ValidateSafetyDepositBoxV2) GetTokenMetadataProgramAccount 

func (inst *ValidateSafetyDepositBoxV2) GetTokenMetadataProgramAccount() *ag_solanago.AccountMeta

GetTokenMetadataProgramAccount gets the "tokenMetadataProgram" account. Token metadata program

func (*ValidateSafetyDepositBoxV2) GetUninitializedSafetyDepositAccount 

func (inst *ValidateSafetyDepositBoxV2) GetUninitializedSafetyDepositAccount() *ag_solanago.AccountMeta

GetUninitializedSafetyDepositAccount gets the "uninitializedSafetyDeposit" account. Uninitialized Safety deposit config, pda of seed ['metaplex', program id, auction manager key, safety deposit key]

func (*ValidateSafetyDepositBoxV2) GetVaultAccount 

func (inst *ValidateSafetyDepositBoxV2) GetVaultAccount() *ag_solanago.AccountMeta

GetVaultAccount gets the "vaultAccount" account. Vault account

func (*ValidateSafetyDepositBoxV2) GetWhitelistedCreatorEntryAccount 

func (inst *ValidateSafetyDepositBoxV2) GetWhitelistedCreatorEntryAccount() *ag_solanago.AccountMeta

GetWhitelistedCreatorEntryAccount gets the "whitelistedCreatorEntry" account. A whitelisted creator entry for the store of this auction manager pda of ['metaplex', store key, creator key] where creator key comes from creator list of metadata, any will do

func (ValidateSafetyDepositBoxV2) MarshalWithEncoder 

func (obj ValidateSafetyDepositBoxV2) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*ValidateSafetyDepositBoxV2) SetArgs 

func (inst *ValidateSafetyDepositBoxV2) SetArgs(args SafetyDepositConfig) *ValidateSafetyDepositBoxV2

SetArgs sets the "args" parameter.

func (*ValidateSafetyDepositBoxV2) SetAuctionManagerAccount 

func (inst *ValidateSafetyDepositBoxV2) SetAuctionManagerAccount(auctionManager ag_solanago.PublicKey) *ValidateSafetyDepositBoxV2

SetAuctionManagerAccount sets the "auctionManager" account. Auction manager

func (*ValidateSafetyDepositBoxV2) SetAuctionManagerStoreAccount 

func (inst *ValidateSafetyDepositBoxV2) SetAuctionManagerStoreAccount(auctionManagerStore ag_solanago.PublicKey) *ValidateSafetyDepositBoxV2

SetAuctionManagerStoreAccount sets the "auctionManagerStore" account. The auction manager's store key

func (*ValidateSafetyDepositBoxV2) SetAuctionWinnerTokenTypeTrackerAccount 

func (inst *ValidateSafetyDepositBoxV2) SetAuctionWinnerTokenTypeTrackerAccount(auctionWinnerTokenTypeTracker ag_solanago.PublicKey) *ValidateSafetyDepositBoxV2

SetAuctionWinnerTokenTypeTrackerAccount sets the "auctionWinnerTokenTypeTracker" account. AuctionWinnerTokenTypeTracker, pda of seed ['metaplex', program id, auction manager key, 'totals']

func (*ValidateSafetyDepositBoxV2) SetAuthorityAccount 

func (inst *ValidateSafetyDepositBoxV2) SetAuthorityAccount(authority ag_solanago.PublicKey) *ValidateSafetyDepositBoxV2

SetAuthorityAccount sets the "authority" account. Authority

func (*ValidateSafetyDepositBoxV2) SetEditionOrMastereditionAccount 

func (inst *ValidateSafetyDepositBoxV2) SetEditionOrMastereditionAccount(editionOrMasteredition ag_solanago.PublicKey) *ValidateSafetyDepositBoxV2

SetEditionOrMastereditionAccount sets the "editionOrMasteredition" account. Edition OR MasterEdition record key Remember this does not need to be an existing account (may not be depending on token), just is a pda with seed of ['metadata', program id, Printing mint id, 'edition']. - remember PDA is relative to token metadata program.

func (*ValidateSafetyDepositBoxV2) SetMetadataAccount 

func (inst *ValidateSafetyDepositBoxV2) SetMetadataAccount(metadataAccount ag_solanago.PublicKey) *ValidateSafetyDepositBoxV2

SetMetadataAccount sets the "metadataAccount" account. Metadata account

func (*ValidateSafetyDepositBoxV2) SetMetadataAuthorityAccount 

func (inst *ValidateSafetyDepositBoxV2) SetMetadataAuthorityAccount(metadataAuthority ag_solanago.PublicKey) *ValidateSafetyDepositBoxV2

SetMetadataAuthorityAccount sets the "metadataAuthority" account. Metadata Authority - Signer only required if doing a full ownership txfer

func (*ValidateSafetyDepositBoxV2) SetMintAccount 

func (inst *ValidateSafetyDepositBoxV2) SetMintAccount(mintAccount ag_solanago.PublicKey) *ValidateSafetyDepositBoxV2

SetMintAccount sets the "mintAccount" account. Mint account of the token in the safety deposit box

func (*ValidateSafetyDepositBoxV2) SetOriginalAuthorityLookupAccount 

func (inst *ValidateSafetyDepositBoxV2) SetOriginalAuthorityLookupAccount(originalAuthorityLookup ag_solanago.PublicKey) *ValidateSafetyDepositBoxV2

SetOriginalAuthorityLookupAccount sets the "originalAuthorityLookup" account. Original authority lookup - unallocated uninitialized pda account with seed ['metaplex', auction key, metadata key] We will store original authority here to return it later.

func (*ValidateSafetyDepositBoxV2) SetPayerAccount 

func (inst *ValidateSafetyDepositBoxV2) SetPayerAccount(payer ag_solanago.PublicKey) *ValidateSafetyDepositBoxV2

SetPayerAccount sets the "payer" account. Payer

func (*ValidateSafetyDepositBoxV2) SetRentSysvarAccount 

func (inst *ValidateSafetyDepositBoxV2) SetRentSysvarAccount(rentSysvar ag_solanago.PublicKey) *ValidateSafetyDepositBoxV2

SetRentSysvarAccount sets the "rentSysvar" account. Rent sysvar

func (*ValidateSafetyDepositBoxV2) SetSafetyDepositBoxAccount 

func (inst *ValidateSafetyDepositBoxV2) SetSafetyDepositBoxAccount(safetyDepositBox ag_solanago.PublicKey) *ValidateSafetyDepositBoxV2

SetSafetyDepositBoxAccount sets the "safetyDepositBox" account. Safety deposit box account

func (*ValidateSafetyDepositBoxV2) SetSafetyDepositBoxStorageAccount 

func (inst *ValidateSafetyDepositBoxV2) SetSafetyDepositBoxStorageAccount(safetyDepositBoxStorage ag_solanago.PublicKey) *ValidateSafetyDepositBoxV2

SetSafetyDepositBoxStorageAccount sets the "safetyDepositBoxStorage" account. Safety deposit box storage account where the actual nft token is stored

func (*ValidateSafetyDepositBoxV2) SetSystemAccount 

func (inst *ValidateSafetyDepositBoxV2) SetSystemAccount(system ag_solanago.PublicKey) *ValidateSafetyDepositBoxV2

SetSystemAccount sets the "system" account. System

func (*ValidateSafetyDepositBoxV2) SetTokenMetadataProgramAccount 

func (inst *ValidateSafetyDepositBoxV2) SetTokenMetadataProgramAccount(tokenMetadataProgram ag_solanago.PublicKey) *ValidateSafetyDepositBoxV2

SetTokenMetadataProgramAccount sets the "tokenMetadataProgram" account. Token metadata program

func (*ValidateSafetyDepositBoxV2) SetUninitializedSafetyDepositAccount 

func (inst *ValidateSafetyDepositBoxV2) SetUninitializedSafetyDepositAccount(uninitializedSafetyDeposit ag_solanago.PublicKey) *ValidateSafetyDepositBoxV2

SetUninitializedSafetyDepositAccount sets the "uninitializedSafetyDeposit" account. Uninitialized Safety deposit config, pda of seed ['metaplex', program id, auction manager key, safety deposit key]

func (*ValidateSafetyDepositBoxV2) SetVaultAccount 

func (inst *ValidateSafetyDepositBoxV2) SetVaultAccount(vaultAccount ag_solanago.PublicKey) *ValidateSafetyDepositBoxV2

SetVaultAccount sets the "vaultAccount" account. Vault account

func (*ValidateSafetyDepositBoxV2) SetWhitelistedCreatorEntryAccount 

func (inst *ValidateSafetyDepositBoxV2) SetWhitelistedCreatorEntryAccount(whitelistedCreatorEntry ag_solanago.PublicKey) *ValidateSafetyDepositBoxV2

SetWhitelistedCreatorEntryAccount sets the "whitelistedCreatorEntry" account. A whitelisted creator entry for the store of this auction manager pda of ['metaplex', store key, creator key] where creator key comes from creator list of metadata, any will do

func (*ValidateSafetyDepositBoxV2) UnmarshalWithDecoder 

func (obj *ValidateSafetyDepositBoxV2) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

func (*ValidateSafetyDepositBoxV2) Validate 

func (inst *ValidateSafetyDepositBoxV2) Validate() error

func (ValidateSafetyDepositBoxV2) ValidateAndBuild 

func (inst ValidateSafetyDepositBoxV2) ValidateAndBuild() (*Instruction, error)

ValidateAndBuild validates the instruction parameters and accounts; if there is a validation error, it returns the error. Otherwise, it builds and returns the instruction.

type WhitelistedCreator 

type WhitelistedCreator struct {
	Key       Key
	Address   ag_solanago.PublicKey
	Activated bool
}

func (WhitelistedCreator) MarshalWithEncoder 

func (obj WhitelistedCreator) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*WhitelistedCreator) UnmarshalWithDecoder 

func (obj *WhitelistedCreator) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type WinningConfig 

type WinningConfig struct {
	// For now these are just array-of-array proxies but wanted to make them first class
	// structs in case we want to attach other top level metadata someday.
	Items []WinningConfigItem
}

func (WinningConfig) MarshalWithEncoder 

func (obj WinningConfig) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*WinningConfig) UnmarshalWithDecoder 

func (obj *WinningConfig) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type WinningConfigItem 

type WinningConfigItem struct {
	SafetyDepositBoxIndex uint8
	Amount                uint8
	WinningConfigType     WinningConfigType
}

func (WinningConfigItem) MarshalWithEncoder 

func (obj WinningConfigItem) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*WinningConfigItem) UnmarshalWithDecoder 

func (obj *WinningConfigItem) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type WinningConfigState 

type WinningConfigState struct {
	Items []WinningConfigStateItem

	// Ticked to true when money is pushed to accept_payment account from auction bidding pot
	MoneyPushedToAcceptPayment bool
}

func (WinningConfigState) MarshalWithEncoder 

func (obj WinningConfigState) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*WinningConfigState) UnmarshalWithDecoder 

func (obj *WinningConfigState) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type WinningConfigStateItem 

type WinningConfigStateItem struct {
	// Record of primary sale or not at time of auction creation, set during validation step
	PrimarySaleHappened bool

	// Ticked to true when a prize is claimed by person who won it
	Claimed bool
}

func (WinningConfigStateItem) MarshalWithEncoder 

func (obj WinningConfigStateItem) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*WinningConfigStateItem) UnmarshalWithDecoder 

func (obj *WinningConfigStateItem) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

type WinningConfigType 

type WinningConfigType ag_binary.BorshEnum
const (
	// You may be selling your one-of-a-kind NFT for the first time, but not it's accompanying Metadata,
	// of which you would like to retain ownership. You get 100% of the payment the first sale, then
	// royalties forever after.
	//
	// You may be re-selling something like a Limited/Open Edition print from another auction,
	// a master edition record token by itself (Without accompanying metadata/printing ownership), etc.
	// This means artists will get royalty fees according to the top level royalty % on the metadata
	// split according to their percentages of contribution.
	//
	// No metadata ownership is transferred in this instruction, which means while you may be transferring
	// the token for a limited/open edition away, you would still be (nominally) the owner of the limited edition
	// metadata, though it confers no rights or privileges of any kind.
	TokenOnlyTransfer_WinningConfigType WinningConfigType = iota

	// Means you are auctioning off the master edition record and it's metadata ownership as well as the
	// token itself. The other person will be able to mint authorization tokens and make changes to the
	// artwork.
	FullRightsTransfer_WinningConfigType

	// Means you are using authorization tokens to print off editions during the auction using
	// from a MasterEditionV1
	PrintingV1_WinningConfigType

	// Means you are using the MasterEditionV2 to print off editions
	PrintingV2_WinningConfigType

	// Means you are using a MasterEditionV2 as a participation prize.
	Participation_WinningConfigType
)

func (WinningConfigType) String added in v0.1.2 

func (value WinningConfigType) String() string

type WinningConstraint 

type WinningConstraint ag_binary.BorshEnum
const (
	NoParticipationPrize_WinningConstraint WinningConstraint = iota
	ParticipationPrizeGiven_WinningConstraint
)

func (WinningConstraint) String added in v0.1.2 

func (value WinningConstraint) String() string

type WithdrawMasterEdition 

type WithdrawMasterEdition struct {

	// [0] = [WRITE] auctionManager
	// ··········· Auction manager
	//
	// [1] = [WRITE] safetyDepositTokenStorage
	// ··········· Safety deposit token storage account
	//
	// [2] = [WRITE] associatedTokenAccount
	// ··········· Associated token account owned by auction manager authority of same mint as token storage account
	//
	// [3] = [WRITE] safetyDepositBox
	// ··········· Safety deposit box account
	//
	// [4] = [WRITE] vaultAccount
	// ··········· Vault account
	//
	// [5] = [WRITE] fractionMint
	// ··········· Fraction mint of the vault
	//
	// [6] = [] prizeTrackingTicket
	// ··········· Prize tracking ticket (pda of ['metaplex', program id, auction manager key, metadata mint id])
	//
	// [7] = [] pdaBasedVaultTransferAuthority
	// ··········· PDA-based Vault transfer authority ['vault', program_id, vault key]
	// ··········· but please note that this is a PDA relative to the Token Vault program, with the 'vault' prefix
	//
	// [8] = [] auction
	// ··········· Auction
	//
	// [9] = [] auctionDataExtended
	// ··········· Auction data extended (pda relative to auction of ['auction', program id, vault key, 'extended'])
	//
	// [10] = [] tokenProgram
	// ··········· Token program
	//
	// [11] = [] tokenVaultProgram
	// ··········· Token Vault program
	//
	// [12] = [] store
	// ··········· Store
	//
	// [13] = [] rentSysvar
	// ··········· Rent sysvar
	//
	// [14] = [] safetyDepositConfig
	// ··········· Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit]
	// ··········· This account will only get used in the event this is an AuctionManagerV2
	ag_solanago.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

Permissionless call to redeem the master edition in a given safety deposit for a PrintingV2 winning config to the ATA of the Auctioneer. Can only be called once all redemptions have been met.

func NewWithdrawMasterEditionInstruction 

func NewWithdrawMasterEditionInstruction(

	auctionManager ag_solanago.PublicKey,
	safetyDepositTokenStorage ag_solanago.PublicKey,
	associatedTokenAccount ag_solanago.PublicKey,
	safetyDepositBox ag_solanago.PublicKey,
	vaultAccount ag_solanago.PublicKey,
	fractionMint ag_solanago.PublicKey,
	prizeTrackingTicket ag_solanago.PublicKey,
	pdaBasedVaultTransferAuthority ag_solanago.PublicKey,
	auction ag_solanago.PublicKey,
	auctionDataExtended ag_solanago.PublicKey,
	tokenProgram ag_solanago.PublicKey,
	tokenVaultProgram ag_solanago.PublicKey,
	store ag_solanago.PublicKey,
	rentSysvar ag_solanago.PublicKey,
	safetyDepositConfig ag_solanago.PublicKey) *WithdrawMasterEdition

NewWithdrawMasterEditionInstruction declares a new WithdrawMasterEdition instruction with the provided parameters and accounts.

func NewWithdrawMasterEditionInstructionBuilder 

func NewWithdrawMasterEditionInstructionBuilder() *WithdrawMasterEdition

NewWithdrawMasterEditionInstructionBuilder creates a new `WithdrawMasterEdition` instruction builder.

func (WithdrawMasterEdition) Build 

func (inst WithdrawMasterEdition) Build() *Instruction

func (*WithdrawMasterEdition) EncodeToTree 

func (inst *WithdrawMasterEdition) EncodeToTree(parent ag_treeout.Branches)

func (*WithdrawMasterEdition) GetAssociatedTokenAccount 

func (inst *WithdrawMasterEdition) GetAssociatedTokenAccount() *ag_solanago.AccountMeta

GetAssociatedTokenAccount gets the "associatedTokenAccount" account. Associated token account owned by auction manager authority of same mint as token storage account

func (*WithdrawMasterEdition) GetAuctionAccount 

func (inst *WithdrawMasterEdition) GetAuctionAccount() *ag_solanago.AccountMeta

GetAuctionAccount gets the "auction" account. Auction

func (*WithdrawMasterEdition) GetAuctionDataExtendedAccount 

func (inst *WithdrawMasterEdition) GetAuctionDataExtendedAccount() *ag_solanago.AccountMeta

GetAuctionDataExtendedAccount gets the "auctionDataExtended" account. Auction data extended (pda relative to auction of ['auction', program id, vault key, 'extended'])

func (*WithdrawMasterEdition) GetAuctionManagerAccount 

func (inst *WithdrawMasterEdition) GetAuctionManagerAccount() *ag_solanago.AccountMeta

GetAuctionManagerAccount gets the "auctionManager" account. Auction manager

func (*WithdrawMasterEdition) GetFractionMintAccount 

func (inst *WithdrawMasterEdition) GetFractionMintAccount() *ag_solanago.AccountMeta

GetFractionMintAccount gets the "fractionMint" account. Fraction mint of the vault

func (*WithdrawMasterEdition) GetPdaBasedVaultTransferAuthorityAccount 

func (inst *WithdrawMasterEdition) GetPdaBasedVaultTransferAuthorityAccount() *ag_solanago.AccountMeta

GetPdaBasedVaultTransferAuthorityAccount gets the "pdaBasedVaultTransferAuthority" account. PDA-based Vault transfer authority ['vault', program_id, vault key] but please note that this is a PDA relative to the Token Vault program, with the 'vault' prefix

func (*WithdrawMasterEdition) GetPrizeTrackingTicketAccount 

func (inst *WithdrawMasterEdition) GetPrizeTrackingTicketAccount() *ag_solanago.AccountMeta

GetPrizeTrackingTicketAccount gets the "prizeTrackingTicket" account. Prize tracking ticket (pda of ['metaplex', program id, auction manager key, metadata mint id])

func (*WithdrawMasterEdition) GetRentSysvarAccount 

func (inst *WithdrawMasterEdition) GetRentSysvarAccount() *ag_solanago.AccountMeta

GetRentSysvarAccount gets the "rentSysvar" account. Rent sysvar

func (*WithdrawMasterEdition) GetSafetyDepositBoxAccount 

func (inst *WithdrawMasterEdition) GetSafetyDepositBoxAccount() *ag_solanago.AccountMeta

GetSafetyDepositBoxAccount gets the "safetyDepositBox" account. Safety deposit box account

func (*WithdrawMasterEdition) GetSafetyDepositConfigAccount 

func (inst *WithdrawMasterEdition) GetSafetyDepositConfigAccount() *ag_solanago.AccountMeta

GetSafetyDepositConfigAccount gets the "safetyDepositConfig" account. Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit] This account will only get used in the event this is an AuctionManagerV2

func (*WithdrawMasterEdition) GetSafetyDepositTokenStorageAccount 

func (inst *WithdrawMasterEdition) GetSafetyDepositTokenStorageAccount() *ag_solanago.AccountMeta

GetSafetyDepositTokenStorageAccount gets the "safetyDepositTokenStorage" account. Safety deposit token storage account

func (*WithdrawMasterEdition) GetStoreAccount 

func (inst *WithdrawMasterEdition) GetStoreAccount() *ag_solanago.AccountMeta

GetStoreAccount gets the "store" account. Store

func (*WithdrawMasterEdition) GetTokenProgramAccount 

func (inst *WithdrawMasterEdition) GetTokenProgramAccount() *ag_solanago.AccountMeta

GetTokenProgramAccount gets the "tokenProgram" account. Token program

func (*WithdrawMasterEdition) GetTokenVaultProgramAccount 

func (inst *WithdrawMasterEdition) GetTokenVaultProgramAccount() *ag_solanago.AccountMeta

GetTokenVaultProgramAccount gets the "tokenVaultProgram" account. Token Vault program

func (*WithdrawMasterEdition) GetVaultAccount 

func (inst *WithdrawMasterEdition) GetVaultAccount() *ag_solanago.AccountMeta

GetVaultAccount gets the "vaultAccount" account. Vault account

func (WithdrawMasterEdition) MarshalWithEncoder 

func (obj WithdrawMasterEdition) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error)

func (*WithdrawMasterEdition) SetAssociatedTokenAccount 

func (inst *WithdrawMasterEdition) SetAssociatedTokenAccount(associatedTokenAccount ag_solanago.PublicKey) *WithdrawMasterEdition

SetAssociatedTokenAccount sets the "associatedTokenAccount" account. Associated token account owned by auction manager authority of same mint as token storage account

func (*WithdrawMasterEdition) SetAuctionAccount 

func (inst *WithdrawMasterEdition) SetAuctionAccount(auction ag_solanago.PublicKey) *WithdrawMasterEdition

SetAuctionAccount sets the "auction" account. Auction

func (*WithdrawMasterEdition) SetAuctionDataExtendedAccount 

func (inst *WithdrawMasterEdition) SetAuctionDataExtendedAccount(auctionDataExtended ag_solanago.PublicKey) *WithdrawMasterEdition

SetAuctionDataExtendedAccount sets the "auctionDataExtended" account. Auction data extended (pda relative to auction of ['auction', program id, vault key, 'extended'])

func (*WithdrawMasterEdition) SetAuctionManagerAccount 

func (inst *WithdrawMasterEdition) SetAuctionManagerAccount(auctionManager ag_solanago.PublicKey) *WithdrawMasterEdition

SetAuctionManagerAccount sets the "auctionManager" account. Auction manager

func (*WithdrawMasterEdition) SetFractionMintAccount 

func (inst *WithdrawMasterEdition) SetFractionMintAccount(fractionMint ag_solanago.PublicKey) *WithdrawMasterEdition

SetFractionMintAccount sets the "fractionMint" account. Fraction mint of the vault

func (*WithdrawMasterEdition) SetPdaBasedVaultTransferAuthorityAccount 

func (inst *WithdrawMasterEdition) SetPdaBasedVaultTransferAuthorityAccount(pdaBasedVaultTransferAuthority ag_solanago.PublicKey) *WithdrawMasterEdition

SetPdaBasedVaultTransferAuthorityAccount sets the "pdaBasedVaultTransferAuthority" account. PDA-based Vault transfer authority ['vault', program_id, vault key] but please note that this is a PDA relative to the Token Vault program, with the 'vault' prefix

func (*WithdrawMasterEdition) SetPrizeTrackingTicketAccount 

func (inst *WithdrawMasterEdition) SetPrizeTrackingTicketAccount(prizeTrackingTicket ag_solanago.PublicKey) *WithdrawMasterEdition

SetPrizeTrackingTicketAccount sets the "prizeTrackingTicket" account. Prize tracking ticket (pda of ['metaplex', program id, auction manager key, metadata mint id])

func (*WithdrawMasterEdition) SetRentSysvarAccount 

func (inst *WithdrawMasterEdition) SetRentSysvarAccount(rentSysvar ag_solanago.PublicKey) *WithdrawMasterEdition

SetRentSysvarAccount sets the "rentSysvar" account. Rent sysvar

func (*WithdrawMasterEdition) SetSafetyDepositBoxAccount 

func (inst *WithdrawMasterEdition) SetSafetyDepositBoxAccount(safetyDepositBox ag_solanago.PublicKey) *WithdrawMasterEdition

SetSafetyDepositBoxAccount sets the "safetyDepositBox" account. Safety deposit box account

func (*WithdrawMasterEdition) SetSafetyDepositConfigAccount 

func (inst *WithdrawMasterEdition) SetSafetyDepositConfigAccount(safetyDepositConfig ag_solanago.PublicKey) *WithdrawMasterEdition

SetSafetyDepositConfigAccount sets the "safetyDepositConfig" account. Safety deposit config pda of ['metaplex', program id, auction manager, safety deposit] This account will only get used in the event this is an AuctionManagerV2

func (*WithdrawMasterEdition) SetSafetyDepositTokenStorageAccount 

func (inst *WithdrawMasterEdition) SetSafetyDepositTokenStorageAccount(safetyDepositTokenStorage ag_solanago.PublicKey) *WithdrawMasterEdition

SetSafetyDepositTokenStorageAccount sets the "safetyDepositTokenStorage" account. Safety deposit token storage account

func (*WithdrawMasterEdition) SetStoreAccount 

func (inst *WithdrawMasterEdition) SetStoreAccount(store ag_solanago.PublicKey) *WithdrawMasterEdition

SetStoreAccount sets the "store" account. Store

func (*WithdrawMasterEdition) SetTokenProgramAccount 

func (inst *WithdrawMasterEdition) SetTokenProgramAccount(tokenProgram ag_solanago.PublicKey) *WithdrawMasterEdition

SetTokenProgramAccount sets the "tokenProgram" account. Token program

func (*WithdrawMasterEdition) SetTokenVaultProgramAccount 

func (inst *WithdrawMasterEdition) SetTokenVaultProgramAccount(tokenVaultProgram ag_solanago.PublicKey) *WithdrawMasterEdition

SetTokenVaultProgramAccount sets the "tokenVaultProgram" account. Token Vault program

func (*WithdrawMasterEdition) SetVaultAccount 

func (inst *WithdrawMasterEdition) SetVaultAccount(vaultAccount ag_solanago.PublicKey) *WithdrawMasterEdition

SetVaultAccount sets the "vaultAccount" account. Vault account

func (*WithdrawMasterEdition) UnmarshalWithDecoder 

func (obj *WithdrawMasterEdition) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error)

func (*WithdrawMasterEdition) Validate 

func (inst *WithdrawMasterEdition) Validate() error

func (WithdrawMasterEdition) ValidateAndBuild 

func (inst WithdrawMasterEdition) ValidateAndBuild() (*Instruction, error)

ValidateAndBuild validates the instruction parameters and accounts; if there is a validation error, it returns the error. Otherwise, it builds and returns the instruction.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.