certusone
/
metaplex
mirror of https://github.com/certusone/metaplex.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge branch 'master' of github.com:metaplex-foundation/metaplex into instant-sale

This commit is contained in:
Jordan Prince 2021-08-13 21:11:04 -05:00
parent 6b30563b93 81023eb3e5
commit 0dfdcaa7d4
95 changed files with 2009 additions and 1950 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
js/packages/common/src/actions/account.ts
View File

@ -275,7 +275,7 @@ export function ensureWrappedAccount(
signers.push(account);
return account.publicKey;
return account.publicKey.toBase58();
}
// TODO: check if one of to accounts needs to be native sol ... if yes unwrap it ...
@ -290,6 +290,7 @@ export function findOrCreateAccountByMint(
excluded?: Set<string>,
): PublicKey {
const accountToFind = mint.toBase58();
const ownerKey = owner.toBase58();
const account = cache
.byParser(TokenAccountParser)
.map(id => cache.get(id))
@ -297,14 +298,14 @@ export function findOrCreateAccountByMint(
acc =>
acc !== undefined &&
acc.info.mint.toBase58() === accountToFind &&
acc.info.owner.toBase58() === owner.toBase58() &&
(excluded === undefined || !excluded.has(acc.pubkey.toBase58())),
acc.info.owner.toBase58() === ownerKey &&
(excluded === undefined || !excluded.has(acc.pubkey)),
);
const isWrappedSol = accountToFind === WRAPPED_SOL_MINT.toBase58();
let toAccount: PublicKey;
if (account && !isWrappedSol) {
toAccount = account.pubkey;
toAccount = new PublicKey(account.pubkey);
} else {
// creating depositor pool account
toAccount = createTokenAccount(

297
js/packages/common/src/actions/auction.ts
View File

@ -1,6 +1,5 @@
import {
AccountInfo,
PublicKey,
SystemProgram,
SYSVAR_CLOCK_PUBKEY,
SYSVAR_RENT_PUBKEY,
@ -11,7 +10,7 @@ import { deserializeUnchecked, serialize } from 'borsh';
import BN from 'bn.js';
import { AccountParser } from '../contexts';
import moment from 'moment';
import { findProgramAddress } from '../utils';
import { findProgramAddress, StringPublicKey, toPublicKey } from '../utils';
export const AUCTION_PREFIX = 'auction';
export const METADATA = 'metadata';
export const EXTENDED = 'extended';
@ -29,9 +28,9 @@ export enum BidStateType {
}
export class Bid {
key: PublicKey;
key: StringPublicKey;
amount: BN;
constructor(args: { key: PublicKey; amount: BN }) {
constructor(args: { key: StringPublicKey; amount: BN }) {
this.key = args.key;
this.amount = args.amount;
}
@ -42,7 +41,7 @@ export class BidState {
bids: Bid[];
max: BN;
public getWinnerAt(winnerIndex: number): PublicKey | null {
public getWinnerAt(winnerIndex: number): StringPublicKey | null {
const convertedIndex = this.bids.length - winnerIndex - 1;
if (convertedIndex >= 0 && convertedIndex < this.bids.length) {
@ -62,12 +61,10 @@ export class BidState {
}
}
public getWinnerIndex(bidder: PublicKey): number | null {
public getWinnerIndex(bidder: StringPublicKey): number | null {
if (!this.bids) return null;
const index = this.bids.findIndex(
b => b.key.toBase58() === bidder.toBase58(),
);
const index = this.bids.findIndex(b => b.key === bidder);
// auction stores data in reverse order
if (index !== -1) {
const zeroBased = this.bids.length - index - 1;
@ -83,7 +80,7 @@ export class BidState {
}
export const AuctionParser: AccountParser = (
pubkey: PublicKey,
pubkey: StringPublicKey,
account: AccountInfo<Buffer>,
) => ({
pubkey,
@ -100,7 +97,7 @@ export const decodeAuction = (buffer: Buffer) => {
};
export const BidderPotParser: AccountParser = (
pubkey: PublicKey,
pubkey: StringPublicKey,
account: AccountInfo<Buffer>,
) => ({
pubkey,
@ -113,7 +110,7 @@ export const decodeBidderPot = (buffer: Buffer) => {
};
export const AuctionDataExtendedParser: AccountParser = (
pubkey: PublicKey,
pubkey: StringPublicKey,
account: AccountInfo<Buffer>,
) => ({
pubkey,
@ -130,7 +127,7 @@ export const decodeAuctionDataExtended = (buffer: Buffer) => {
};
export const BidderMetadataParser: AccountParser = (
pubkey: PublicKey,
pubkey: StringPublicKey,
account: AccountInfo<Buffer>,
) => ({
pubkey,
@ -208,9 +205,9 @@ export interface CountdownState {
export class AuctionData {
/// Pubkey of the authority with permission to modify this auction.
authority: PublicKey;
authority: StringPublicKey;
/// Token mint for the SPL token being used to bid
tokenMint: PublicKey;
tokenMint: StringPublicKey;
/// The time the last bid was placed, used to keep track of auction timing.
lastBid: BN | null;
/// Slot time the auction was officially ended by.
@ -226,7 +223,7 @@ export class AuctionData {
/// Auction Bids, each user may have one bid open at a time.
bidState: BidState;
/// Used for precalculation on the front end, not a backend key
bidRedemptionKey?: PublicKey;
bidRedemptionKey?: StringPublicKey;
public timeToEnd(): CountdownState {
const now = moment().unix();
@ -273,8 +270,8 @@ export class AuctionData {
}
constructor(args: {
authority: PublicKey;
tokenMint: PublicKey;
authority: StringPublicKey;
tokenMint: StringPublicKey;
lastBid: BN | null;
endedAt: BN | null;
endAuctionAt: BN | null;
@ -299,9 +296,9 @@ export class AuctionData {
export const BIDDER_METADATA_LEN = 32 + 32 + 8 + 8 + 1;
export class BidderMetadata {
// Relationship with the bidder who's metadata this covers.
bidderPubkey: PublicKey;
bidderPubkey: StringPublicKey;
// Relationship with the auction this bid was placed on.
auctionPubkey: PublicKey;
auctionPubkey: StringPublicKey;
// Amount that the user bid.
lastBid: BN;
// Tracks the last time this user bid.
@ -310,8 +307,8 @@ export class BidderMetadata {
// user is a winner, as if cancelled it implies previous bids were also cancelled.
cancelled: boolean;
constructor(args: {
bidderPubkey: PublicKey;
auctionPubkey: PublicKey;
bidderPubkey: StringPublicKey;
auctionPubkey: StringPublicKey;
lastBid: BN;
lastBidTimestamp: BN;
cancelled: boolean;
@ -327,14 +324,14 @@ export class BidderMetadata {
export const BIDDER_POT_LEN = 32 + 32 + 32 + 1;
export class BidderPot {
/// Points at actual pot that is a token account
bidderPot: PublicKey;
bidderAct: PublicKey;
auctionAct: PublicKey;
bidderPot: StringPublicKey;
bidderAct: StringPublicKey;
auctionAct: StringPublicKey;
emptied: boolean;
constructor(args: {
bidderPot: PublicKey;
bidderAct: PublicKey;
auctionAct: PublicKey;
bidderPot: StringPublicKey;
bidderAct: StringPublicKey;
auctionAct: StringPublicKey;
emptied: boolean;
}) {
this.bidderPot = args.bidderPot;
@ -366,7 +363,7 @@ export interface IPartialCreateAuctionArgs {
/// Gap time is how much time after the previous bid where the auction ends. See AuctionData.
auctionGap: BN | null;
/// Token mint for the SPL token used for bidding.
tokenMint: PublicKey;
tokenMint: StringPublicKey;
priceFloor: PriceFloor;
@ -388,11 +385,11 @@ export class CreateAuctionArgs implements IPartialCreateAuctionArgs {
/// Gap time is how much time after the previous bid where the auction ends. See AuctionData.
auctionGap: BN | null;
/// Token mint for the SPL token used for bidding.
tokenMint: PublicKey;
tokenMint: StringPublicKey;
/// Authority
authority: PublicKey;
authority: StringPublicKey;
/// The resource being auctioned. See AuctionData.
resource: PublicKey;
resource: StringPublicKey;
priceFloor: PriceFloor;
@ -408,9 +405,9 @@ export class CreateAuctionArgs implements IPartialCreateAuctionArgs {
winners: WinnerLimit;
endAuctionAt: BN | null;
auctionGap: BN | null;
tokenMint: PublicKey;
authority: PublicKey;
resource: PublicKey;
tokenMint: StringPublicKey;
authority: StringPublicKey;
resource: StringPublicKey;
priceFloor: PriceFloor;
tickSize: BN | null;
gapTickSizePercentage: number | null;
@ -433,19 +430,19 @@ export class CreateAuctionArgs implements IPartialCreateAuctionArgs {
class StartAuctionArgs {
instruction: number = 4;
resource: PublicKey;
resource: StringPublicKey;
constructor(args: { resource: PublicKey }) {
constructor(args: { resource: StringPublicKey }) {
this.resource = args.resource;
}
}
class PlaceBidArgs {
instruction: number = 6;
resource: PublicKey;
resource: StringPublicKey;
amount: BN;
constructor(args: { resource: PublicKey; amount: BN }) {
constructor(args: { resource: StringPublicKey; amount: BN }) {
this.resource = args.resource;
this.amount = args.amount;
}
@ -453,9 +450,9 @@ class PlaceBidArgs {
class CancelBidArgs {
instruction: number = 0;
resource: PublicKey;
resource: StringPublicKey;
constructor(args: { resource: PublicKey }) {
constructor(args: { resource: StringPublicKey }) {
this.resource = args.resource;
}
}
@ -474,9 +471,9 @@ export const AUCTION_SCHEMA = new Map<any, any>([
['winners', WinnerLimit],
['endAuctionAt', { kind: 'option', type: 'u64' }],
['auctionGap', { kind: 'option', type: 'u64' }],
['tokenMint', 'pubkey'],
['authority', 'pubkey'],
['resource', 'pubkey'],
['tokenMint', 'pubkeyAsString'],
['authority', 'pubkeyAsString'],
['resource', 'pubkeyAsString'],
['priceFloor', PriceFloor],
['tickSize', { kind: 'option', type: 'u64' }],
['gapTickSizePercentage', { kind: 'option', type: 'u8' }],
@ -501,7 +498,7 @@ export const AUCTION_SCHEMA = new Map<any, any>([
kind: 'struct',
fields: [
['instruction', 'u8'],
['resource', 'pubkey'],
['resource', 'pubkeyAsString'],
],
},
],
@ -512,7 +509,7 @@ export const AUCTION_SCHEMA = new Map<any, any>([
fields: [
['instruction', 'u8'],
['amount', 'u64'],
['resource', 'pubkey'],
['resource', 'pubkeyAsString'],
],
},
],
@ -522,7 +519,7 @@ export const AUCTION_SCHEMA = new Map<any, any>([
kind: 'struct',
fields: [
['instruction', 'u8'],
['resource', 'pubkey'],
['resource', 'pubkeyAsString'],
],
},
],
@ -539,8 +536,8 @@ export const AUCTION_SCHEMA = new Map<any, any>([
{
kind: 'struct',
fields: [
['authority', 'pubkey'],
['tokenMint', 'pubkey'],
['authority', 'pubkeyAsString'],
['tokenMint', 'pubkeyAsString'],
['lastBid', { kind: 'option', type: 'u64' }],
['endedAt', { kind: 'option', type: 'u64' }],
['endAuctionAt', { kind: 'option', type: 'u64' }],
@ -590,7 +587,7 @@ export const AUCTION_SCHEMA = new Map<any, any>([
{
kind: 'struct',
fields: [
['key', 'pubkey'],
['key', 'pubkeyAsString'],
['amount', 'u64'],
],
},
@ -600,8 +597,8 @@ export const AUCTION_SCHEMA = new Map<any, any>([
{
kind: 'struct',
fields: [
['bidderPubkey', 'pubkey'],
['auctionPubkey', 'pubkey'],
['bidderPubkey', 'pubkeyAsString'],
['auctionPubkey', 'pubkeyAsString'],
['lastBid', 'u64'],
['lastBidTimestamp', 'u64'],
['cancelled', 'u8'],
@ -613,9 +610,9 @@ export const AUCTION_SCHEMA = new Map<any, any>([
{
kind: 'struct',
fields: [
['bidderPot', 'pubkey'],
['bidderAct', 'pubkey'],
['auctionAct', 'pubkey'],
['bidderPot', 'pubkeyAsString'],
['bidderAct', 'pubkeyAsString'],
['auctionAct', 'pubkeyAsString'],
['emptied', 'u8'],
],
},
@ -632,40 +629,42 @@ export const decodeAuctionData = (buffer: Buffer) => {
export async function createAuction(
settings: CreateAuctionArgs,
creator: PublicKey,
creator: StringPublicKey,
instructions: TransactionInstruction[],
) {
const auctionProgramId = programIds().auction;
const data = Buffer.from(serialize(AUCTION_SCHEMA, settings));
const auctionKey: PublicKey = (
const auctionKey: StringPublicKey = (
await findProgramAddress(
[
Buffer.from(AUCTION_PREFIX),
auctionProgramId.toBuffer(),
settings.resource.toBuffer(),
toPublicKey(auctionProgramId).toBuffer(),
toPublicKey(settings.resource).toBuffer(),
],
auctionProgramId,
toPublicKey(auctionProgramId),
)
)[0];
const keys = [
{
pubkey: creator,
pubkey: toPublicKey(creator),
isSigner: true,
isWritable: true,
},
{
pubkey: auctionKey,
pubkey: toPublicKey(auctionKey),
isSigner: false,
isWritable: true,
},
{
pubkey: await getAuctionExtended({
auctionProgramId,
resource: settings.resource,
}),
pubkey: toPublicKey(
await getAuctionExtended({
auctionProgramId,
resource: settings.resource,
}),
),
isSigner: false,
isWritable: true,
},
@ -683,15 +682,15 @@ export async function createAuction(
instructions.push(
new TransactionInstruction({
keys,
programId: auctionProgramId,
programId: toPublicKey(auctionProgramId),
data: data,
}),
);
}
export async function startAuction(
resource: PublicKey,
creator: PublicKey,
resource: StringPublicKey,
creator: StringPublicKey,
instructions: TransactionInstruction[],
) {
const auctionProgramId = programIds().auction;
@ -705,25 +704,25 @@ export async function startAuction(
),
);
const auctionKey: PublicKey = (
const auctionKey: StringPublicKey = (
await findProgramAddress(
[
Buffer.from(AUCTION_PREFIX),
auctionProgramId.toBuffer(),
resource.toBuffer(),
toPublicKey(auctionProgramId).toBuffer(),
toPublicKey(resource).toBuffer(),
],
auctionProgramId,
toPublicKey(auctionProgramId),
)
)[0];
const keys = [
{
pubkey: creator,
pubkey: toPublicKey(creator),
isSigner: false,
isWritable: true,
},
{
pubkey: auctionKey,
pubkey: toPublicKey(auctionKey),
isSigner: false,
isWritable: true,
},
@ -736,16 +735,16 @@ export async function startAuction(
instructions.push(
new TransactionInstruction({
keys,
programId: auctionProgramId,
programId: toPublicKey(auctionProgramId),
data: data,
}),
);
}
export async function setAuctionAuthority(
auction: PublicKey,
currentAuthority: PublicKey,
newAuthority: PublicKey,
auction: StringPublicKey,
currentAuthority: StringPublicKey,
newAuthority: StringPublicKey,
instructions: TransactionInstruction[],
) {
const auctionProgramId = programIds().auction;
@ -754,17 +753,17 @@ export async function setAuctionAuthority(
const keys = [
{
pubkey: auction,
pubkey: toPublicKey(auction),
isSigner: false,
isWritable: true,
},
{
pubkey: currentAuthority,
pubkey: toPublicKey(currentAuthority),
isSigner: true,
isWritable: false,
},
{
pubkey: newAuthority,
pubkey: toPublicKey(newAuthority),
isSigner: false,
isWritable: false,
},
@ -772,20 +771,20 @@ export async function setAuctionAuthority(
instructions.push(
new TransactionInstruction({
keys,
programId: auctionProgramId,
programId: toPublicKey(auctionProgramId),
data: data,
}),
);
}
export async function placeBid(
bidderPubkey: PublicKey,
bidderTokenPubkey: PublicKey,
bidderPotTokenPubkey: PublicKey,
tokenMintPubkey: PublicKey,
transferAuthority: PublicKey,
payer: PublicKey,
resource: PublicKey,
bidderPubkey: StringPublicKey,
bidderTokenPubkey: StringPublicKey,
bidderPotTokenPubkey: StringPublicKey,
tokenMintPubkey: StringPublicKey,
transferAuthority: StringPublicKey,
payer: StringPublicKey,
resource: StringPublicKey,
amount: BN,
instructions: TransactionInstruction[],
) {
@ -801,14 +800,14 @@ export async function placeBid(
),
);
const auctionKey: PublicKey = (
const auctionKey: StringPublicKey = (
await findProgramAddress(
[
Buffer.from(AUCTION_PREFIX),
auctionProgramId.toBuffer(),
resource.toBuffer(),
toPublicKey(auctionProgramId).toBuffer(),
toPublicKey(resource).toBuffer(),
],
auctionProgramId,
toPublicKey(auctionProgramId),
)
)[0];
@ -818,67 +817,69 @@ export async function placeBid(
bidderPubkey,
});
const bidderMetaKey: PublicKey = (
const bidderMetaKey: StringPublicKey = (
await findProgramAddress(
[
Buffer.from(AUCTION_PREFIX),
auctionProgramId.toBuffer(),
auctionKey.toBuffer(),
bidderPubkey.toBuffer(),
toPublicKey(auctionProgramId).toBuffer(),
toPublicKey(auctionKey).toBuffer(),
toPublicKey(bidderPubkey).toBuffer(),
Buffer.from('metadata'),
],
auctionProgramId,
toPublicKey(auctionProgramId),
)
)[0];
const keys = [
{
pubkey: bidderPubkey,
pubkey: toPublicKey(bidderPubkey),
isSigner: true,
isWritable: false,
},
{
pubkey: bidderTokenPubkey,
pubkey: toPublicKey(bidderTokenPubkey),
isSigner: false,
isWritable: true,
},
{
pubkey: bidderPotKey,
pubkey: toPublicKey(bidderPotKey),
isSigner: false,
isWritable: true,
},
{
pubkey: bidderPotTokenPubkey,
pubkey: toPublicKey(bidderPotTokenPubkey),
isSigner: false,
isWritable: true,
},
{
pubkey: bidderMetaKey,
pubkey: toPublicKey(bidderMetaKey),
isSigner: false,
isWritable: true,
},
{
pubkey: auctionKey,
pubkey: toPublicKey(auctionKey),
isSigner: false,
isWritable: true,
},
{
pubkey: await getAuctionExtended({ auctionProgramId, resource }),
pubkey: toPublicKey(
await getAuctionExtended({ auctionProgramId, resource }),
),
isSigner: false,
isWritable: true,
},
{
pubkey: tokenMintPubkey,
pubkey: toPublicKey(tokenMintPubkey),
isSigner: false,
isWritable: true,
},
{
pubkey: transferAuthority,
pubkey: toPublicKey(transferAuthority),
isSigner: true,
isWritable: false,
},
{
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: false,
},
@ -906,7 +907,7 @@ export async function placeBid(
instructions.push(
new TransactionInstruction({
keys,
programId: auctionProgramId,
programId: toPublicKey(auctionProgramId),
data: data,
}),
);
@ -921,19 +922,19 @@ export async function getBidderPotKey({
auctionKey,
bidderPubkey,
}: {
auctionProgramId: PublicKey;
auctionKey: PublicKey;
bidderPubkey: PublicKey;
}): Promise<PublicKey> {
auctionProgramId: StringPublicKey;
auctionKey: StringPublicKey;
bidderPubkey: StringPublicKey;
}): Promise<StringPublicKey> {
return (
await findProgramAddress(
[
Buffer.from(AUCTION_PREFIX),
auctionProgramId.toBuffer(),
auctionKey.toBuffer(),
bidderPubkey.toBuffer(),
toPublicKey(auctionProgramId).toBuffer(),
toPublicKey(auctionKey).toBuffer(),
toPublicKey(bidderPubkey).toBuffer(),
],
auctionProgramId,
toPublicKey(auctionProgramId),
)
)[0];
}
@ -942,28 +943,28 @@ export async function getAuctionExtended({
auctionProgramId,
resource,
}: {
auctionProgramId: PublicKey;
resource: PublicKey;
}): Promise<PublicKey> {
auctionProgramId: StringPublicKey;
resource: StringPublicKey;
}): Promise<StringPublicKey> {
return (
await findProgramAddress(
[
Buffer.from(AUCTION_PREFIX),
auctionProgramId.toBuffer(),
resource.toBuffer(),
toPublicKey(auctionProgramId).toBuffer(),
toPublicKey(resource).toBuffer(),
Buffer.from(EXTENDED),
],
auctionProgramId,
toPublicKey(auctionProgramId),
)
)[0];
}
export async function cancelBid(
bidderPubkey: PublicKey,
bidderTokenPubkey: PublicKey,
bidderPotTokenPubkey: PublicKey,
tokenMintPubkey: PublicKey,
resource: PublicKey,
bidderPubkey: StringPublicKey,
bidderTokenPubkey: StringPublicKey,
bidderPotTokenPubkey: StringPublicKey,
tokenMintPubkey: StringPublicKey,
resource: StringPublicKey,
instructions: TransactionInstruction[],
) {
const auctionProgramId = programIds().auction;
@ -977,14 +978,14 @@ export async function cancelBid(
),
);
const auctionKey: PublicKey = (
const auctionKey = (
await findProgramAddress(
[
Buffer.from(AUCTION_PREFIX),
auctionProgramId.toBuffer(),
resource.toBuffer(),
toPublicKey(auctionProgramId).toBuffer(),
toPublicKey(resource).toBuffer(),
],
auctionProgramId,
toPublicKey(auctionProgramId),
)
)[0];
@ -994,57 +995,59 @@ export async function cancelBid(
bidderPubkey,
});
const bidderMetaKey: PublicKey = (
const bidderMetaKey = (
await findProgramAddress(
[
Buffer.from(AUCTION_PREFIX),
auctionProgramId.toBuffer(),
auctionKey.toBuffer(),
bidderPubkey.toBuffer(),
toPublicKey(auctionProgramId).toBuffer(),
toPublicKey(auctionKey).toBuffer(),
toPublicKey(bidderPubkey).toBuffer(),
Buffer.from('metadata'),
],
auctionProgramId,
toPublicKey(auctionProgramId),
)
)[0];
const keys = [
{
pubkey: bidderPubkey,
pubkey: toPublicKey(bidderPubkey),
isSigner: true,
isWritable: false,
},
{
pubkey: bidderTokenPubkey,
pubkey: toPublicKey(bidderTokenPubkey),
isSigner: false,
isWritable: true,
},
{
pubkey: bidderPotKey,
pubkey: toPublicKey(bidderPotKey),
isSigner: false,
isWritable: true,
},
{
pubkey: bidderPotTokenPubkey,
pubkey: toPublicKey(bidderPotTokenPubkey),
isSigner: false,
isWritable: true,
},
{
pubkey: bidderMetaKey,
pubkey: toPublicKey(bidderMetaKey),
isSigner: false,
isWritable: true,
},
{
pubkey: auctionKey,
pubkey: toPublicKey(auctionKey),
isSigner: false,
isWritable: true,
},
{
pubkey: await getAuctionExtended({ auctionProgramId, resource }),
pubkey: toPublicKey(
await getAuctionExtended({ auctionProgramId, resource }),
),
isSigner: false,
isWritable: true,
},
{
pubkey: tokenMintPubkey,
pubkey: toPublicKey(tokenMintPubkey),
isSigner: false,
isWritable: true,
},
@ -1072,7 +1075,7 @@ export async function cancelBid(
instructions.push(
new TransactionInstruction({
keys,
programId: auctionProgramId,
programId: toPublicKey(auctionProgramId),
data: data,
}),
);

347
js/packages/common/src/actions/metadata.ts
View File

@ -1,5 +1,4 @@
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction,
@ -7,7 +6,7 @@ import {
import { programIds } from '../utils/programIds';
import { deserializeUnchecked, serialize } from 'borsh';
import BN from 'bn.js';
import { findProgramAddress } from '../utils';
import { findProgramAddress, StringPublicKey, toPublicKey } from '../utils';
export const METADATA_PREFIX = 'metadata';
export const EDITION = 'edition';
export const RESERVATION = 'reservation';
@ -92,7 +91,7 @@ export class MasterEditionV1 {
supply: BN;
maxSupply?: BN;
/// Can be used to mint tokens that give one-time permission to mint a single limited edition.
printingMint: PublicKey;
printingMint: StringPublicKey;
/// If you don't know how many printing tokens you are going to need, but you do know
/// you are going to need some amount in the future, you can use a token from this mint.
/// Coming back to token metadata with one of these tokens allows you to mint (one time)
@ -103,14 +102,14 @@ export class MasterEditionV1 {
/// but at the end we will. At the end it then burns this token with token-metadata to
/// get the printing tokens it needs to give to bidders. Each bidder then redeems a printing token
/// to get their limited editions.
oneTimePrintingAuthorizationMint: PublicKey;
oneTimePrintingAuthorizationMint: StringPublicKey;
constructor(args: {
key: MetadataKey;
supply: BN;
maxSupply?: BN;
printingMint: PublicKey;
oneTimePrintingAuthorizationMint: PublicKey;
printingMint: StringPublicKey;
oneTimePrintingAuthorizationMint: StringPublicKey;
}) {
this.key = MetadataKey.MasterEditionV1;
this.supply = args.supply;
@ -163,22 +162,30 @@ export class EditionMarker {
export class Edition {
key: MetadataKey;
/// Points at MasterEdition struct
parent: PublicKey;
parent: StringPublicKey;
/// Starting at 0 for master record, this is incremented for each edition minted.
edition: BN;
constructor(args: { key: MetadataKey; parent: PublicKey; edition: BN }) {
constructor(args: {
key: MetadataKey;
parent: StringPublicKey;
edition: BN;
}) {
this.key = MetadataKey.EditionV1;
this.parent = args.parent;
this.edition = args.edition;
}
}
export class Creator {
address: PublicKey;
address: StringPublicKey;
verified: boolean;
share: number;
constructor(args: { address: PublicKey; verified: boolean; share: number }) {
constructor(args: {
address: StringPublicKey;
verified: boolean;
share: number;
}) {
this.address = args.address;
this.verified = args.verified;
this.share = args.share;
@ -208,20 +215,20 @@ export class Data {
export class Metadata {
key: MetadataKey;
updateAuthority: PublicKey;
mint: PublicKey;
updateAuthority: StringPublicKey;
mint: StringPublicKey;
data: Data;
primarySaleHappened: boolean;
isMutable: boolean;
editionNonce: number | null;
// set lazy
masterEdition?: PublicKey;
edition?: PublicKey;
masterEdition?: StringPublicKey;
edition?: StringPublicKey;
constructor(args: {
updateAuthority: PublicKey;
mint: PublicKey;
updateAuthority: StringPublicKey;
mint: StringPublicKey;
data: Data;
primarySaleHappened: boolean;
isMutable: boolean;
@ -270,7 +277,7 @@ class UpdateMetadataArgs {
instruction: number = 1;
data: Data | null;
// Not used by this app, just required for instruction
updateAuthority: PublicKey | null;
updateAuthority: StringPublicKey | null;
primarySaleHappened: boolean | null;
constructor(args: {
data?: Data;
@ -278,9 +285,7 @@ class UpdateMetadataArgs {
primarySaleHappened: boolean | null;
}) {
this.data = args.data ? args.data : null;
this.updateAuthority = args.updateAuthority
? new PublicKey(args.updateAuthority)
: null;
this.updateAuthority = args.updateAuthority ? args.updateAuthority : null;
this.primarySaleHappened = args.primarySaleHappened;
}
}
@ -321,7 +326,7 @@ export const METADATA_SCHEMA = new Map<any, any>([
fields: [
['instruction', 'u8'],
['data', { kind: 'option', type: Data }],
['updateAuthority', { kind: 'option', type: 'pubkey' }],
['updateAuthority', { kind: 'option', type: 'pubkeyAsString' }],
['primarySaleHappened', { kind: 'option', type: 'u8' }],
],
},
@ -355,8 +360,8 @@ export const METADATA_SCHEMA = new Map<any, any>([
['key', 'u8'],
['supply', 'u64'],
['maxSupply', { kind: 'option', type: 'u64' }],
['printingMint', 'pubkey'],
['oneTimePrintingAuthorizationMint', 'pubkey'],
['printingMint', 'pubkeyAsString'],
['oneTimePrintingAuthorizationMint', 'pubkeyAsString'],
],
},
],
@ -377,7 +382,7 @@ export const METADATA_SCHEMA = new Map<any, any>([
kind: 'struct',
fields: [
['key', 'u8'],
['parent', 'pubkey'],
['parent', 'pubkeyAsString'],
['edition', 'u64'],
],
},
@ -400,7 +405,7 @@ export const METADATA_SCHEMA = new Map<any, any>([
{
kind: 'struct',
fields: [
['address', 'pubkey'],
['address', 'pubkeyAsString'],
['verified', 'u8'],
['share', 'u8'],
],
@ -412,8 +417,8 @@ export const METADATA_SCHEMA = new Map<any, any>([
kind: 'struct',
fields: [
['key', 'u8'],
['updateAuthority', 'pubkey'],
['mint', 'pubkey'],
['updateAuthority', 'pubkeyAsString'],
['mint', 'pubkeyAsString'],
['data', Data],
['primarySaleHappened', 'u8'], // bool
['isMutable', 'u8'], // bool
@ -476,10 +481,10 @@ export async function updateMetadata(
data: Data | undefined,
newUpdateAuthority: string | undefined,
primarySaleHappened: boolean | null | undefined,
mintKey: PublicKey,
updateAuthority: PublicKey,
mintKey: StringPublicKey,
updateAuthority: StringPublicKey,
instructions: TransactionInstruction[],
metadataAccount?: PublicKey,
metadataAccount?: StringPublicKey,
) {
const metadataProgramId = programIds().metadata;
@ -489,10 +494,10 @@ export async function updateMetadata(
await findProgramAddress(
[
Buffer.from('metadata'),
metadataProgramId.toBuffer(),
mintKey.toBuffer(),
toPublicKey(metadataProgramId).toBuffer(),
toPublicKey(mintKey).toBuffer(),
],
metadataProgramId,
toPublicKey(metadataProgramId),
)
)[0];
@ -507,12 +512,12 @@ export async function updateMetadata(
const txnData = Buffer.from(serialize(METADATA_SCHEMA, value));
const keys = [
{
pubkey: metadataAccount,
pubkey: toPublicKey(metadataAccount),
isSigner: false,
isWritable: true,
},
{
pubkey: updateAuthority,
pubkey: toPublicKey(updateAuthority),
isSigner: true,
isWritable: false,
},
@ -520,7 +525,7 @@ export async function updateMetadata(
instructions.push(
new TransactionInstruction({
keys,
programId: metadataProgramId,
programId: toPublicKey(metadataProgramId),
data: txnData,
}),
);
@ -530,11 +535,11 @@ export async function updateMetadata(
export async function createMetadata(
data: Data,
updateAuthority: PublicKey,
mintKey: PublicKey,
mintAuthorityKey: PublicKey,
updateAuthority: StringPublicKey,
mintKey: StringPublicKey,
mintAuthorityKey: StringPublicKey,
instructions: TransactionInstruction[],
payer: PublicKey,
payer: StringPublicKey,
) {
const metadataProgramId = programIds().metadata;
@ -542,10 +547,10 @@ export async function createMetadata(
await findProgramAddress(
[
Buffer.from('metadata'),
metadataProgramId.toBuffer(),
mintKey.toBuffer(),
toPublicKey(metadataProgramId).toBuffer(),
toPublicKey(mintKey).toBuffer(),
],
metadataProgramId,
toPublicKey(metadataProgramId),
)
)[0];
console.log('Data', data);
@ -554,27 +559,27 @@ export async function createMetadata(
const keys = [
{
pubkey: metadataAccount,
pubkey: toPublicKey(metadataAccount),
isSigner: false,
isWritable: true,
},
{
pubkey: mintKey,
pubkey: toPublicKey(mintKey),
isSigner: false,
isWritable: false,
},
{
pubkey: mintAuthorityKey,
pubkey: toPublicKey(mintAuthorityKey),
isSigner: true,
isWritable: false,
},
{
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: false,
},
{
pubkey: updateAuthority,
pubkey: toPublicKey(updateAuthority),
isSigner: false,
isWritable: false,
},
@ -592,7 +597,7 @@ export async function createMetadata(
instructions.push(
new TransactionInstruction({
keys,
programId: metadataProgramId,
programId: toPublicKey(metadataProgramId),
data: txnData,
}),
);
@ -602,10 +607,10 @@ export async function createMetadata(
export async function createMasterEdition(
maxSupply: BN | undefined,
mintKey: PublicKey,
updateAuthorityKey: PublicKey,
mintAuthorityKey: PublicKey,
payer: PublicKey,
mintKey: StringPublicKey,
updateAuthorityKey: StringPublicKey,
mintAuthorityKey: StringPublicKey,
payer: StringPublicKey,
instructions: TransactionInstruction[],
) {
const metadataProgramId = programIds().metadata;
@ -614,10 +619,10 @@ export async function createMasterEdition(
await findProgramAddress(
[
Buffer.from(METADATA_PREFIX),
metadataProgramId.toBuffer(),
mintKey.toBuffer(),
toPublicKey(metadataProgramId).toBuffer(),
toPublicKey(mintKey).toBuffer(),
],
metadataProgramId,
toPublicKey(metadataProgramId),
)
)[0];
@ -625,11 +630,11 @@ export async function createMasterEdition(
await findProgramAddress(
[
Buffer.from(METADATA_PREFIX),
metadataProgramId.toBuffer(),
mintKey.toBuffer(),
toPublicKey(metadataProgramId).toBuffer(),
toPublicKey(mintKey).toBuffer(),
Buffer.from(EDITION),
],
metadataProgramId,
toPublicKey(metadataProgramId),
)
)[0];
@ -638,32 +643,32 @@ export async function createMasterEdition(
const keys = [
{
pubkey: editionAccount,
pubkey: toPublicKey(editionAccount),
isSigner: false,
isWritable: true,
},
{
pubkey: mintKey,
pubkey: toPublicKey(mintKey),
isSigner: false,
isWritable: true,
},
{
pubkey: updateAuthorityKey,
pubkey: toPublicKey(updateAuthorityKey),
isSigner: true,
isWritable: false,
},
{
pubkey: mintAuthorityKey,
pubkey: toPublicKey(mintAuthorityKey),
isSigner: true,
isWritable: false,
},
{
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: false,
},
{
pubkey: metadataAccount,
pubkey: toPublicKey(metadataAccount),
isSigner: false,
isWritable: false,
},
@ -688,23 +693,23 @@ export async function createMasterEdition(
instructions.push(
new TransactionInstruction({
keys,
programId: metadataProgramId,
programId: toPublicKey(metadataProgramId),
data,
}),
);
}
export async function deprecatedMintNewEditionFromMasterEditionViaPrintingToken(
newMint: PublicKey,
tokenMint: PublicKey,
newMintAuthority: PublicKey,
printingMint: PublicKey,
authorizationTokenHoldingAccount: PublicKey,
burnAuthority: PublicKey,
updateAuthorityOfMaster: PublicKey,
reservationList: PublicKey | undefined,
newMint: StringPublicKey,
tokenMint: StringPublicKey,
newMintAuthority: StringPublicKey,
printingMint: StringPublicKey,
authorizationTokenHoldingAccount: StringPublicKey,
burnAuthority: StringPublicKey,
updateAuthorityOfMaster: StringPublicKey,
reservationList: StringPublicKey | undefined,
instructions: TransactionInstruction[],
payer: PublicKey,
payer: StringPublicKey,
) {
const metadataProgramId = programIds().metadata;
@ -717,57 +722,57 @@ export async function deprecatedMintNewEditionFromMasterEditionViaPrintingToken(
const keys = [
{
pubkey: newMetadataKey,
pubkey: toPublicKey(newMetadataKey),
isSigner: false,
isWritable: true,
},
{
pubkey: newEdition,
pubkey: toPublicKey(newEdition),
isSigner: false,
isWritable: true,
},
{
pubkey: masterEdition,
pubkey: toPublicKey(masterEdition),
isSigner: false,
isWritable: true,
},
{
pubkey: newMint,
pubkey: toPublicKey(newMint),
isSigner: false,
isWritable: true,
},
{
pubkey: newMintAuthority,
pubkey: toPublicKey(newMintAuthority),
isSigner: true,
isWritable: false,
},
{
pubkey: printingMint,
pubkey: toPublicKey(printingMint),
isSigner: false,
isWritable: true,
},
{
pubkey: authorizationTokenHoldingAccount,
pubkey: toPublicKey(authorizationTokenHoldingAccount),
isSigner: false,
isWritable: true,
},
{
pubkey: burnAuthority,
pubkey: toPublicKey(burnAuthority),
isSigner: true,
isWritable: false,
},
{
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: false,
},
{
pubkey: updateAuthorityOfMaster,
pubkey: toPublicKey(updateAuthorityOfMaster),
isSigner: false,
isWritable: false,
},
{
pubkey: masterMetadataKey,
pubkey: toPublicKey(masterMetadataKey),
isSigner: false,
isWritable: false,
},
@ -790,7 +795,7 @@ export async function deprecatedMintNewEditionFromMasterEditionViaPrintingToken(
if (reservationList) {
keys.push({
pubkey: reservationList,
pubkey: toPublicKey(reservationList),
isSigner: false,
isWritable: true,
});
@ -798,21 +803,21 @@ export async function deprecatedMintNewEditionFromMasterEditionViaPrintingToken(
instructions.push(
new TransactionInstruction({
keys,
programId: metadataProgramId,
programId: toPublicKey(metadataProgramId),
data,
}),
);
}
export async function mintNewEditionFromMasterEditionViaToken(
newMint: PublicKey,
tokenMint: PublicKey,
newMintAuthority: PublicKey,
newUpdateAuthority: PublicKey,
tokenOwner: PublicKey,
tokenAccount: PublicKey,
newMint: StringPublicKey,
tokenMint: StringPublicKey,
newMintAuthority: StringPublicKey,
newUpdateAuthority: StringPublicKey,
tokenOwner: StringPublicKey,
tokenAccount: StringPublicKey,
instructions: TransactionInstruction[],
payer: PublicKey,
payer: StringPublicKey,
edition: BN,
) {
const metadataProgramId = programIds().metadata;
@ -827,57 +832,57 @@ export async function mintNewEditionFromMasterEditionViaToken(
const keys = [
{
pubkey: newMetadataKey,
pubkey: toPublicKey(newMetadataKey),
isSigner: false,
isWritable: true,
},
{
pubkey: newEdition,
pubkey: toPublicKey(newEdition),
isSigner: false,
isWritable: true,
},
{
pubkey: masterEdition,
pubkey: toPublicKey(masterEdition),
isSigner: false,
isWritable: true,
},
{
pubkey: newMint,
pubkey: toPublicKey(newMint),
isSigner: false,
isWritable: true,
},
{
pubkey: editionMarkPda,
pubkey: toPublicKey(editionMarkPda),
isSigner: false,
isWritable: true,
},
{
pubkey: newMintAuthority,
pubkey: toPublicKey(newMintAuthority),
isSigner: true,
isWritable: false,
},
{
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: false,
},
{
pubkey: tokenOwner,
pubkey: toPublicKey(tokenOwner),
isSigner: true,
isWritable: false,
},
{
pubkey: tokenAccount,
pubkey: toPublicKey(tokenAccount),
isSigner: false,
isWritable: false,
},
{
pubkey: newUpdateAuthority,
pubkey: toPublicKey(newUpdateAuthority),
isSigner: false,
isWritable: false,
},
{
pubkey: masterMetadataKey,
pubkey: toPublicKey(masterMetadataKey),
isSigner: false,
isWritable: false,
},
@ -901,16 +906,16 @@ export async function mintNewEditionFromMasterEditionViaToken(
instructions.push(
new TransactionInstruction({
keys,
programId: metadataProgramId,
programId: toPublicKey(metadataProgramId),
data,
}),
);
}
export async function updatePrimarySaleHappenedViaToken(
metadata: PublicKey,
owner: PublicKey,
tokenAccount: PublicKey,
metadata: StringPublicKey,
owner: StringPublicKey,
tokenAccount: StringPublicKey,
instructions: TransactionInstruction[],
) {
const metadataProgramId = programIds().metadata;
@ -919,17 +924,17 @@ export async function updatePrimarySaleHappenedViaToken(
const keys = [
{
pubkey: metadata,
pubkey: toPublicKey(metadata),
isSigner: false,
isWritable: true,
},
{
pubkey: owner,
pubkey: toPublicKey(owner),
isSigner: true,
isWritable: false,
},
{
pubkey: tokenAccount,
pubkey: toPublicKey(tokenAccount),
isSigner: false,
isWritable: false,
},
@ -937,18 +942,18 @@ export async function updatePrimarySaleHappenedViaToken(
instructions.push(
new TransactionInstruction({
keys,
programId: metadataProgramId,
programId: toPublicKey(metadataProgramId),
data,
}),
);
}
export async function deprecatedCreateReservationList(
metadata: PublicKey,
masterEdition: PublicKey,
resource: PublicKey,
updateAuthority: PublicKey,
payer: PublicKey,
metadata: StringPublicKey,
masterEdition: StringPublicKey,
resource: StringPublicKey,
updateAuthority: StringPublicKey,
payer: StringPublicKey,
instructions: TransactionInstruction[],
) {
const metadataProgramId = programIds().metadata;
@ -961,33 +966,33 @@ export async function deprecatedCreateReservationList(
const keys = [
{
pubkey: reservationList,
pubkey: toPublicKey(reservationList),
isSigner: false,
isWritable: true,
},
{
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: false,
},
{
pubkey: updateAuthority,
pubkey: toPublicKey(updateAuthority),
isSigner: true,
isWritable: false,
},
{
pubkey: masterEdition,
pubkey: toPublicKey(masterEdition),
isSigner: false,
isWritable: false,
},
{
pubkey: resource,
pubkey: toPublicKey(resource),
isSigner: false,
isWritable: false,
},
{
pubkey: metadata,
pubkey: toPublicKey(metadata),
isSigner: false,
isWritable: false,
},
@ -1005,15 +1010,15 @@ export async function deprecatedCreateReservationList(
instructions.push(
new TransactionInstruction({
keys,
programId: metadataProgramId,
programId: toPublicKey(metadataProgramId),
data,
}),
);
}
export async function signMetadata(
metadata: PublicKey,
creator: PublicKey,
metadata: StringPublicKey,
creator: StringPublicKey,
instructions: TransactionInstruction[],
) {
const metadataProgramId = programIds().metadata;
@ -1022,12 +1027,12 @@ export async function signMetadata(
const keys = [
{
pubkey: metadata,
pubkey: toPublicKey(metadata),
isSigner: false,
isWritable: true,
},
{
pubkey: creator,
pubkey: toPublicKey(creator),
isSigner: true,
isWritable: false,
},
@ -1035,18 +1040,18 @@ export async function signMetadata(
instructions.push(
new TransactionInstruction({
keys,
programId: metadataProgramId,
programId: toPublicKey(metadataProgramId),
data,
}),
);
}
export async function deprecatedMintPrintingTokens(
destination: PublicKey,
printingMint: PublicKey,
updateAuthority: PublicKey,
metadata: PublicKey,
masterEdition: PublicKey,
destination: StringPublicKey,
printingMint: StringPublicKey,
updateAuthority: StringPublicKey,
metadata: StringPublicKey,
masterEdition: StringPublicKey,
supply: BN,
instructions: TransactionInstruction[],
) {
@ -1058,27 +1063,27 @@ export async function deprecatedMintPrintingTokens(
const keys = [
{
pubkey: destination,
pubkey: toPublicKey(destination),
isSigner: false,
isWritable: true,
},
{
pubkey: printingMint,
pubkey: toPublicKey(printingMint),
isSigner: false,
isWritable: true,
},
{
pubkey: updateAuthority,
pubkey: toPublicKey(updateAuthority),
isSigner: true,
isWritable: false,
},
{
pubkey: metadata,
pubkey: toPublicKey(metadata),
isSigner: false,
isWritable: false,
},
{
pubkey: masterEdition,
pubkey: toPublicKey(masterEdition),
isSigner: false,
isWritable: false,
},
@ -1096,16 +1101,16 @@ export async function deprecatedMintPrintingTokens(
instructions.push(
new TransactionInstruction({
keys,
programId: metadataProgramId,
programId: toPublicKey(metadataProgramId),
data,
}),
);
}
export async function convertMasterEditionV1ToV2(
masterEdition: PublicKey,
oneTimeAuthMint: PublicKey,
printingMint: PublicKey,
masterEdition: StringPublicKey,
oneTimeAuthMint: StringPublicKey,
printingMint: StringPublicKey,
instructions: TransactionInstruction[],
) {
const metadataProgramId = programIds().metadata;
@ -1114,17 +1119,17 @@ export async function convertMasterEditionV1ToV2(
const keys = [
{
pubkey: masterEdition,
pubkey: toPublicKey(masterEdition),
isSigner: false,
isWritable: true,
},
{
pubkey: oneTimeAuthMint,
pubkey: toPublicKey(oneTimeAuthMint),
isSigner: false,
isWritable: true,
},
{
pubkey: printingMint,
pubkey: toPublicKey(printingMint),
isSigner: false,
isWritable: true,
},
@ -1132,67 +1137,71 @@ export async function convertMasterEditionV1ToV2(
instructions.push(
new TransactionInstruction({
keys,
programId: metadataProgramId,
programId: toPublicKey(metadataProgramId),
data,
}),
);
}
export async function getEdition(tokenMint: PublicKey): Promise<PublicKey> {
export async function getEdition(
tokenMint: StringPublicKey,
): Promise<StringPublicKey> {
const PROGRAM_IDS = programIds();
return (
await findProgramAddress(
[
Buffer.from(METADATA_PREFIX),
PROGRAM_IDS.metadata.toBuffer(),
tokenMint.toBuffer(),
toPublicKey(PROGRAM_IDS.metadata).toBuffer(),
toPublicKey(tokenMint).toBuffer(),
Buffer.from(EDITION),
],
PROGRAM_IDS.metadata,
toPublicKey(PROGRAM_IDS.metadata),
)
)[0];
}
export async function getMetadata(tokenMint: PublicKey): Promise<PublicKey> {
export async function getMetadata(
tokenMint: StringPublicKey,
): Promise<StringPublicKey> {
const PROGRAM_IDS = programIds();
return (
await findProgramAddress(
[
Buffer.from(METADATA_PREFIX),
PROGRAM_IDS.metadata.toBuffer(),
tokenMint.toBuffer(),
toPublicKey(PROGRAM_IDS.metadata).toBuffer(),
toPublicKey(tokenMint).toBuffer(),
],
PROGRAM_IDS.metadata,
toPublicKey(PROGRAM_IDS.metadata),
)
)[0];
}
export async function deprecatedGetReservationList(
masterEdition: PublicKey,
resource: PublicKey,
): Promise<PublicKey> {
masterEdition: StringPublicKey,
resource: StringPublicKey,
): Promise<StringPublicKey> {
const PROGRAM_IDS = programIds();
return (
await findProgramAddress(
[
Buffer.from(METADATA_PREFIX),
PROGRAM_IDS.metadata.toBuffer(),
masterEdition.toBuffer(),
toPublicKey(PROGRAM_IDS.metadata).toBuffer(),
toPublicKey(masterEdition).toBuffer(),
Buffer.from(RESERVATION),
resource.toBuffer(),
toPublicKey(resource).toBuffer(),
],
PROGRAM_IDS.metadata,
toPublicKey(PROGRAM_IDS.metadata),
)
)[0];
}
export async function getEditionMarkPda(
mint: PublicKey,
mint: StringPublicKey,
edition: BN,
): Promise<PublicKey> {
): Promise<StringPublicKey> {
const PROGRAM_IDS = programIds();
const editionNumber = Math.floor(edition.toNumber() / 248);
@ -1200,12 +1209,12 @@ export async function getEditionMarkPda(
await findProgramAddress(
[
Buffer.from(METADATA_PREFIX),
PROGRAM_IDS.metadata.toBuffer(),
mint.toBuffer(),
toPublicKey(PROGRAM_IDS.metadata).toBuffer(),
toPublicKey(mint).toBuffer(),
Buffer.from(EDITION),
Buffer.from(editionNumber.toString()),
],
PROGRAM_IDS.metadata,
toPublicKey(PROGRAM_IDS.metadata),
)
)[0];
}

288
js/packages/common/src/actions/vault.ts
View File

@ -1,5 +1,4 @@
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction,
@ -7,7 +6,7 @@ import {
import { programIds } from '../utils/programIds';
import { deserializeUnchecked, serialize } from 'borsh';
import BN from 'bn.js';
import { findProgramAddress } from '../utils';
import { findProgramAddress, StringPublicKey, toPublicKey } from '../utils';
export const VAULT_PREFIX = 'vault';
export enum VaultKey {
@ -31,20 +30,20 @@ export const MAX_EXTERNAL_ACCOUNT_SIZE = 1 + 8 + 32 + 1;
export class Vault {
key: VaultKey;
/// Store token program used
tokenProgram: PublicKey;
tokenProgram: StringPublicKey;
/// Mint that produces the fractional shares
fractionMint: PublicKey;
fractionMint: StringPublicKey;
/// Authority who can make changes to the vault
authority: PublicKey;
authority: StringPublicKey;
/// treasury where fractional shares are held for redemption by authority
fractionTreasury: PublicKey;
fractionTreasury: StringPublicKey;
/// treasury where monies are held for fractional share holders to redeem(burn) shares once buyout is made
redeemTreasury: PublicKey;
redeemTreasury: StringPublicKey;
/// Can authority mint more shares from fraction_mint after activation
allowFurtherShareCreation: boolean;
/// Must point at an ExternalPriceAccount, which gives permission and price for buyout.
pricingLookupAddress: PublicKey;
pricingLookupAddress: StringPublicKey;
/// In inactive state, we use this to set the order key on Safety Deposit Boxes being added and
/// then we increment it and save so the next safety deposit box gets the next number.
/// In the Combined state during token redemption by authority, we use it as a decrementing counter each time
@ -59,13 +58,13 @@ export class Vault {
lockedPricePerShare: BN;
constructor(args: {
tokenProgram: PublicKey;
fractionMint: PublicKey;
authority: PublicKey;
fractionTreasury: PublicKey;
redeemTreasury: PublicKey;
tokenProgram: StringPublicKey;
fractionMint: StringPublicKey;
authority: StringPublicKey;
fractionTreasury: StringPublicKey;
redeemTreasury: StringPublicKey;
allowFurtherShareCreation: boolean;
pricingLookupAddress: PublicKey;
pricingLookupAddress: StringPublicKey;
tokenTypeCount: number;
state: VaultState;
lockedPricePerShare: BN;
@ -87,18 +86,18 @@ export class SafetyDepositBox {
/// Each token type in a vault has it's own box that contains it's mint and a look-back
key: VaultKey;
/// VaultKey pointing to the parent vault
vault: PublicKey;
vault: StringPublicKey;
/// This particular token's mint
tokenMint: PublicKey;
tokenMint: StringPublicKey;
/// Account that stores the tokens under management
store: PublicKey;
store: StringPublicKey;
/// the order in the array of registries
order: number;
constructor(args: {
vault: PublicKey;
tokenMint: PublicKey;
store: PublicKey;
vault: StringPublicKey;
tokenMint: StringPublicKey;
store: StringPublicKey;
order: number;
}) {
this.key = VaultKey.SafetyDepositBoxV1;
@ -114,13 +113,13 @@ export class ExternalPriceAccount {
pricePerShare: BN;
/// Mint of the currency we are pricing the shares against, should be same as redeem_treasury.
/// Most likely will be USDC mint most of the time.
priceMint: PublicKey;
priceMint: StringPublicKey;
/// Whether or not combination has been allowed for this vault.
allowedToCombine: boolean;
constructor(args: {
pricePerShare: BN;
priceMint: PublicKey;
priceMint: StringPublicKey;
allowedToCombine: boolean;
}) {
this.key = VaultKey.ExternalPriceAccountV1;
@ -215,13 +214,13 @@ export const VAULT_SCHEMA = new Map<any, any>([
kind: 'struct',
fields: [
['key', 'u8'],
['tokenProgram', 'pubkey'],
['fractionMint', 'pubkey'],
['authority', 'pubkey'],
['fractionTreasury', 'pubkey'],
['redeemTreasury', 'pubkey'],
['tokenProgram', 'pubkeyAsString'],
['fractionMint', 'pubkeyAsString'],
['authority', 'pubkeyAsString'],
['fractionTreasury', 'pubkeyAsString'],
['redeemTreasury', 'pubkeyAsString'],
['allowFurtherShareCreation', 'u8'],
['pricingLookupAddress', 'pubkey'],
['pricingLookupAddress', 'pubkeyAsString'],
['tokenTypeCount', 'u8'],
['state', 'u8'],
['lockedPricePerShare', 'u64'],
@ -234,9 +233,9 @@ export const VAULT_SCHEMA = new Map<any, any>([
kind: 'struct',
fields: [
['key', 'u8'],
['vault', 'pubkey'],
['tokenMint', 'pubkey'],
['store', 'pubkey'],
['vault', 'pubkeyAsString'],
['tokenMint', 'pubkeyAsString'],
['store', 'pubkeyAsString'],
['order', 'u8'],
],
},
@ -248,7 +247,7 @@ export const VAULT_SCHEMA = new Map<any, any>([
fields: [
['key', 'u8'],
['pricePerShare', 'u64'],
['priceMint', 'pubkey'],
['priceMint', 'pubkeyAsString'],
['allowedToCombine', 'u8'],
],
},
@ -276,9 +275,9 @@ export const decodeSafetyDeposit = (buffer: Buffer) => {
};
export async function setVaultAuthority(
vault: PublicKey,
currentAuthority: PublicKey,
newAuthority: PublicKey,
vault: StringPublicKey,
currentAuthority: StringPublicKey,
newAuthority: StringPublicKey,
instructions: TransactionInstruction[],
) {
const vaultProgramId = programIds().vault;
@ -287,17 +286,17 @@ export async function setVaultAuthority(
const keys = [
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: true,
},
{
pubkey: currentAuthority,
pubkey: toPublicKey(currentAuthority),
isSigner: true,
isWritable: false,
},
{
pubkey: newAuthority,
pubkey: toPublicKey(newAuthority),
isSigner: false,
isWritable: false,
},
@ -305,7 +304,7 @@ export async function setVaultAuthority(
instructions.push(
new TransactionInstruction({
keys,
programId: vaultProgramId,
programId: toPublicKey(vaultProgramId),
data: data,
}),
);
@ -313,12 +312,12 @@ export async function setVaultAuthority(
export async function initVault(
allowFurtherShareCreation: boolean,
fractionalMint: PublicKey,
redeemTreasury: PublicKey,
fractionalTreasury: PublicKey,
vault: PublicKey,
vaultAuthority: PublicKey,
pricingLookupAddress: PublicKey,
fractionalMint: StringPublicKey,
redeemTreasury: StringPublicKey,
fractionalTreasury: StringPublicKey,
vault: StringPublicKey,
vaultAuthority: StringPublicKey,
pricingLookupAddress: StringPublicKey,
instructions: TransactionInstruction[],
) {
const vaultProgramId = programIds().vault;
@ -329,32 +328,32 @@ export async function initVault(
const keys = [
{
pubkey: fractionalMint,
pubkey: toPublicKey(fractionalMint),
isSigner: false,
isWritable: true,
},
{
pubkey: redeemTreasury,
pubkey: toPublicKey(redeemTreasury),
isSigner: false,
isWritable: true,
},
{
pubkey: fractionalTreasury,
pubkey: toPublicKey(fractionalTreasury),
isSigner: false,
isWritable: true,
},
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: true,
},
{
pubkey: vaultAuthority,
pubkey: toPublicKey(vaultAuthority),
isSigner: false,
isWritable: false,
},
{
pubkey: pricingLookupAddress,
pubkey: toPublicKey(pricingLookupAddress),
isSigner: false,
isWritable: false,
},
@ -373,43 +372,44 @@ export async function initVault(
instructions.push(
new TransactionInstruction({
keys,
programId: vaultProgramId,
programId: toPublicKey(vaultProgramId),
data: data,
}),
);
}
export async function getSafetyDepositBox(
vault: PublicKey,
tokenMint: PublicKey,
): Promise<PublicKey> {
vault: StringPublicKey,
tokenMint: StringPublicKey,
): Promise<StringPublicKey> {
const vaultProgramId = programIds().vault;
return (
await findProgramAddress(
[Buffer.from(VAULT_PREFIX), vault.toBuffer(), tokenMint.toBuffer()],
vaultProgramId,
[
Buffer.from(VAULT_PREFIX),
toPublicKey(vault).toBuffer(),
toPublicKey(tokenMint).toBuffer(),
],
toPublicKey(vaultProgramId),
)
)[0];
}
export async function addTokenToInactiveVault(
amount: BN,
tokenMint: PublicKey,
tokenAccount: PublicKey,
tokenStoreAccount: PublicKey,
vault: PublicKey,
vaultAuthority: PublicKey,
payer: PublicKey,
transferAuthority: PublicKey,
tokenMint: StringPublicKey,
tokenAccount: StringPublicKey,
tokenStoreAccount: StringPublicKey,
vault: StringPublicKey,
vaultAuthority: StringPublicKey,
payer: StringPublicKey,
transferAuthority: StringPublicKey,
instructions: TransactionInstruction[],
) {
const vaultProgramId = programIds().vault;
const safetyDepositBox: PublicKey = await getSafetyDepositBox(
vault,
tokenMint,
);
const safetyDepositBox = await getSafetyDepositBox(vault, tokenMint);
const value = new AmountArgs({
instruction: 1,
@ -419,37 +419,37 @@ export async function addTokenToInactiveVault(
const data = Buffer.from(serialize(VAULT_SCHEMA, value));
const keys = [
{
pubkey: safetyDepositBox,
pubkey: toPublicKey(safetyDepositBox),
isSigner: false,
isWritable: true,
},
{
pubkey: tokenAccount,
pubkey: toPublicKey(tokenAccount),
isSigner: false,
isWritable: true,
},
{
pubkey: tokenStoreAccount,
pubkey: toPublicKey(tokenStoreAccount),
isSigner: false,
isWritable: true,
},
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: true,
},
{
pubkey: vaultAuthority,
pubkey: toPublicKey(vaultAuthority),
isSigner: true,
isWritable: false,
},
{
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: false,
},
{
pubkey: transferAuthority,
pubkey: toPublicKey(transferAuthority),
isSigner: true,
isWritable: false,
},
@ -472,7 +472,7 @@ export async function addTokenToInactiveVault(
instructions.push(
new TransactionInstruction({
keys,
programId: vaultProgramId,
programId: toPublicKey(vaultProgramId),
data,
}),
);
@ -480,18 +480,22 @@ export async function addTokenToInactiveVault(
export async function activateVault(
numberOfShares: BN,
vault: PublicKey,
fractionMint: PublicKey,
fractionTreasury: PublicKey,
vaultAuthority: PublicKey,
vault: StringPublicKey,
fractionMint: StringPublicKey,
fractionTreasury: StringPublicKey,
vaultAuthority: StringPublicKey,
instructions: TransactionInstruction[],
) {
const vaultProgramId = programIds().vault;
const fractionMintAuthority = (
await findProgramAddress(
[Buffer.from(VAULT_PREFIX), vaultProgramId.toBuffer(), vault.toBuffer()],
vaultProgramId,
[
Buffer.from(VAULT_PREFIX),
toPublicKey(vaultProgramId).toBuffer(),
toPublicKey(vault).toBuffer(),
],
toPublicKey(vaultProgramId),
)
)[0];
@ -500,27 +504,27 @@ export async function activateVault(
const keys = [
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: true,
},
{
pubkey: fractionMint,
pubkey: toPublicKey(fractionMint),
isSigner: false,
isWritable: true,
},
{
pubkey: fractionTreasury,
pubkey: toPublicKey(fractionTreasury),
isSigner: false,
isWritable: true,
},
{
pubkey: fractionMintAuthority,
pubkey: toPublicKey(fractionMintAuthority),
isSigner: false,
isWritable: false,
},
{
pubkey: vaultAuthority,
pubkey: toPublicKey(vaultAuthority),
isSigner: true,
isWritable: false,
},
@ -533,31 +537,35 @@ export async function activateVault(
instructions.push(
new TransactionInstruction({
keys,
programId: vaultProgramId,
programId: toPublicKey(vaultProgramId),
data,
}),
);
}
export async function combineVault(
vault: PublicKey,
outstandingShareTokenAccount: PublicKey,
payingTokenAccount: PublicKey,
fractionMint: PublicKey,
fractionTreasury: PublicKey,
redeemTreasury: PublicKey,
newVaultAuthority: PublicKey | undefined,
vaultAuthority: PublicKey,
transferAuthority: PublicKey,
externalPriceAccount: PublicKey,
vault: StringPublicKey,
outstandingShareTokenAccount: StringPublicKey,
payingTokenAccount: StringPublicKey,
fractionMint: StringPublicKey,
fractionTreasury: StringPublicKey,
redeemTreasury: StringPublicKey,
newVaultAuthority: StringPublicKey | undefined,
vaultAuthority: StringPublicKey,
transferAuthority: StringPublicKey,
externalPriceAccount: StringPublicKey,
instructions: TransactionInstruction[],
) {
const vaultProgramId = programIds().vault;
const burnAuthority = (
await findProgramAddress(
[Buffer.from(VAULT_PREFIX), vaultProgramId.toBuffer(), vault.toBuffer()],
vaultProgramId,
[
Buffer.from(VAULT_PREFIX),
toPublicKey(vaultProgramId).toBuffer(),
toPublicKey(vault).toBuffer(),
],
toPublicKey(vaultProgramId),
)
)[0];
@ -565,57 +573,57 @@ export async function combineVault(
const keys = [
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: true,
},
{
pubkey: outstandingShareTokenAccount,
pubkey: toPublicKey(outstandingShareTokenAccount),
isSigner: false,
isWritable: true,
},
{
pubkey: payingTokenAccount,
pubkey: toPublicKey(payingTokenAccount),
isSigner: false,
isWritable: true,
},
{
pubkey: fractionMint,
pubkey: toPublicKey(fractionMint),
isSigner: false,
isWritable: true,
},
{
pubkey: fractionTreasury,
pubkey: toPublicKey(fractionTreasury),
isSigner: false,
isWritable: true,
},
{
pubkey: redeemTreasury,
pubkey: toPublicKey(redeemTreasury),
isSigner: false,
isWritable: true,
},
{
pubkey: newVaultAuthority || vaultAuthority,
pubkey: toPublicKey(newVaultAuthority || vaultAuthority),
isSigner: false,
isWritable: false,
},
{
pubkey: vaultAuthority,
pubkey: toPublicKey(vaultAuthority),
isSigner: true,
isWritable: false,
},
{
pubkey: transferAuthority,
pubkey: toPublicKey(transferAuthority),
isSigner: true,
isWritable: false,
},
{
pubkey: burnAuthority,
pubkey: toPublicKey(burnAuthority),
isSigner: false,
isWritable: false,
},
{
pubkey: externalPriceAccount,
pubkey: toPublicKey(externalPriceAccount),
isSigner: false,
isWritable: false,
},
@ -628,7 +636,7 @@ export async function combineVault(
instructions.push(
new TransactionInstruction({
keys,
programId: vaultProgramId,
programId: toPublicKey(vaultProgramId),
data,
}),
);
@ -636,20 +644,24 @@ export async function combineVault(
export async function withdrawTokenFromSafetyDepositBox(
amount: BN,
destination: PublicKey,
safetyDepositBox: PublicKey,
storeKey: PublicKey,
vault: PublicKey,
fractionMint: PublicKey,
vaultAuthority: PublicKey,
destination: StringPublicKey,
safetyDepositBox: StringPublicKey,
storeKey: StringPublicKey,
vault: StringPublicKey,
fractionMint: StringPublicKey,
vaultAuthority: StringPublicKey,
instructions: TransactionInstruction[],
) {
const vaultProgramId = programIds().vault;
const transferAuthority = (
await findProgramAddress(
[Buffer.from(VAULT_PREFIX), vaultProgramId.toBuffer(), vault.toBuffer()],
vaultProgramId,
[
Buffer.from(VAULT_PREFIX),
toPublicKey(vaultProgramId).toBuffer(),
toPublicKey(vault).toBuffer(),
],
toPublicKey(vaultProgramId),
)
)[0];
@ -658,37 +670,37 @@ export async function withdrawTokenFromSafetyDepositBox(
const keys = [
{
pubkey: destination,
pubkey: toPublicKey(destination),
isSigner: false,
isWritable: true,
},
{
pubkey: safetyDepositBox,
pubkey: toPublicKey(safetyDepositBox),
isSigner: false,
isWritable: true,
},
{
pubkey: storeKey,
pubkey: toPublicKey(storeKey),
isSigner: false,
isWritable: true,
},
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: true,
},
{
pubkey: fractionMint,
pubkey: toPublicKey(fractionMint),
isSigner: false,
isWritable: true,
},
{
pubkey: vaultAuthority,
pubkey: toPublicKey(vaultAuthority),
isSigner: true,
isWritable: false,
},
{
pubkey: transferAuthority,
pubkey: toPublicKey(transferAuthority),
isSigner: false,
isWritable: false,
},
@ -706,14 +718,14 @@ export async function withdrawTokenFromSafetyDepositBox(
instructions.push(
new TransactionInstruction({
keys,
programId: vaultProgramId,
programId: toPublicKey(vaultProgramId),
data,
}),
);
}
export async function updateExternalPriceAccount(
externalPriceAccountKey: PublicKey,
externalPriceAccountKey: StringPublicKey,
externalPriceAccount: ExternalPriceAccount,
instructions: TransactionInstruction[],
) {
@ -725,7 +737,7 @@ export async function updateExternalPriceAccount(
const keys = [
{
pubkey: externalPriceAccountKey,
pubkey: toPublicKey(externalPriceAccountKey),
isSigner: false,
isWritable: true,
},
@ -733,21 +745,25 @@ export async function updateExternalPriceAccount(
instructions.push(
new TransactionInstruction({
keys,
programId: vaultProgramId,
programId: toPublicKey(vaultProgramId),
data,
}),
);
}
export async function getSafetyDepositBoxAddress(
vault: PublicKey,
tokenMint: PublicKey,
): Promise<PublicKey> {
vault: StringPublicKey,
tokenMint: StringPublicKey,
): Promise<StringPublicKey> {
const PROGRAM_IDS = programIds();
return (
await findProgramAddress(
[Buffer.from(VAULT_PREFIX), vault.toBuffer(), tokenMint.toBuffer()],
PROGRAM_IDS.vault,
[
Buffer.from(VAULT_PREFIX),
toPublicKey(vault).toBuffer(),
toPublicKey(tokenMint).toBuffer(),
],
toPublicKey(PROGRAM_IDS.vault),
)
)[0];
}

31
js/packages/common/src/contexts/accounts.tsx
View File

@ -12,10 +12,8 @@ import { AccountLayout, MintInfo, MintLayout, u64 } from '@solana/spl-token';
import { TokenAccount } from '../models';
import { chunks } from '../utils/utils';
import { EventEmitter } from '../utils/eventEmitter';
import { useUserAccounts } from '../hooks/useUserAccounts';
import { WRAPPED_SOL_MINT } from '../utils/ids';
import { StringPublicKey, WRAPPED_SOL_MINT } from '../utils/ids';
import { programIds } from '../utils/programIds';
import { AuctionParser } from '../actions';
const AccountsContext = React.createContext<any>(null);
@ -25,13 +23,13 @@ const pendingMintCalls = new Map<string, Promise<MintInfo>>();
const mintCache = new Map<string, MintInfo>();
export interface ParsedAccountBase {
pubkey: PublicKey;
pubkey: StringPublicKey;
account: AccountInfo<Buffer>;
info: any; // TODO: change to unkown
info: any; // TODO: change to unknown
}
export type AccountParser = (
pubkey: PublicKey,
pubkey: StringPublicKey,
data: AccountInfo<Buffer>,
) => ParsedAccountBase | undefined;
@ -50,7 +48,7 @@ const getMintInfo = async (connection: Connection, pubKey: PublicKey) => {
return deserializeMint(data);
};
export const MintParser = (pubKey: PublicKey, info: AccountInfo<Buffer>) => {
export const MintParser = (pubKey: string, info: AccountInfo<Buffer>) => {
const buffer = Buffer.from(info.data);
const data = deserializeMint(buffer);
@ -67,7 +65,7 @@ export const MintParser = (pubKey: PublicKey, info: AccountInfo<Buffer>) => {
};
export const TokenAccountParser = (
pubKey: PublicKey,
pubKey: string,
info: AccountInfo<Buffer>,
) => {
// Sometimes a wrapped sol account gets closed, goes to 0 length,
@ -90,7 +88,7 @@ export const TokenAccountParser = (
};
export const GenericAccountParser = (
pubKey: PublicKey,
pubKey: string,
info: AccountInfo<Buffer>,
) => {
const buffer = Buffer.from(info.data);
@ -162,7 +160,7 @@ export const cache = {
cache.registerParser(id, deserialize);
pendingCalls.delete(address);
const account = deserialize(new PublicKey(address), obj);
const account = deserialize(address, obj);
if (!account) {
return;
}
@ -274,20 +272,22 @@ export const useAccountsContext = () => {
};
function wrapNativeAccount(
pubkey: PublicKey,
pubkey: string,
account?: AccountInfo<Buffer>,
): TokenAccount | undefined {
if (!account) {
return undefined;
}
const key = new PublicKey(pubkey);
return {
pubkey: pubkey,
account,
info: {
address: pubkey,
address: key,
mint: WRAPPED_SOL_MINT,
owner: pubkey,
owner: key,
amount: new u64(account.lamports),
delegate: null,
delegatedAmount: new u64(0),
@ -319,7 +319,7 @@ const UseNativeAccount = () => {
const updateCache = useCallback(
account => {
if (wallet && wallet.publicKey) {
const wrapped = wrapNativeAccount(wallet.publicKey, account);
const wrapped = wrapNativeAccount(wallet.publicKey?.toBase58(), account);
if (wrapped !== undefined && wallet) {
const id = wallet.publicKey?.toBase58();
cache.registerParser(id, TokenAccountParser);
@ -388,13 +388,14 @@ export function AccountsProvider({ children = null as any }) {
const [tokenAccounts, setTokenAccounts] = useState<TokenAccount[]>([]);
const [userAccounts, setUserAccounts] = useState<TokenAccount[]>([]);
const { nativeAccount } = UseNativeAccount();
const walletKey = wallet?.publicKey?.toBase58();
const selectUserAccounts = useCallback(() => {
return cache
.byParser(TokenAccountParser)
.map(id => cache.get(id))
.filter(
a => a && a.info.owner.toBase58() === wallet?.publicKey?.toBase58(),
a => a && a.info.owner.toBase58() === walletKey,
)
.map(a => a as TokenAccount);
}, [wallet]);

2
js/packages/common/src/models/account.ts
View File

@ -10,7 +10,7 @@ import { TOKEN_PROGRAM_ID } from '../utils/ids';
import BufferLayout from 'buffer-layout';
export interface TokenAccount {
pubkey: PublicKey;
pubkey: string;
account: AccountInfo<Buffer>;
info: TokenAccountInfo;
}

15
js/packages/common/src/utils/borsh.ts
View File

@ -1,5 +1,7 @@
import { PublicKey } from '@solana/web3.js';
import { BinaryReader, BinaryWriter } from 'borsh';
import base58 from 'bs58';
import { StringPublicKey } from './ids';
export const extendBorsh = () => {
(BinaryReader.prototype as any).readPubkey = function () {
@ -12,6 +14,19 @@ export const extendBorsh = () => {
const writer = this as unknown as BinaryWriter;
writer.writeFixedArray(value.toBuffer());
};
(BinaryReader.prototype as any).readPubkeyAsString = function () {
const reader = this as unknown as BinaryReader;
const array = reader.readFixedArray(32);
return base58.encode(array) as StringPublicKey;
};
(BinaryWriter.prototype as any).writePubkeyAsString = function (
value: StringPublicKey,
) {
const writer = this as unknown as BinaryWriter;
writer.writeFixedArray(base58.decode(value));
};
};
extendBorsh();

69
js/packages/common/src/utils/ids.ts
View File

@ -1,4 +1,45 @@
import { PublicKey } from '@solana/web3.js';
import { PublicKey, AccountInfo, Account } from '@solana/web3.js';
export type StringPublicKey = string;
export class LazyAccountInfoProxy<T> {
executable: boolean = false;
owner: StringPublicKey = '';
lamports: number = 0;
get data() {
//
return undefined as unknown as T;
}
}
export interface LazyAccountInfo {
executable: boolean;
owner: StringPublicKey;
lamports: number;
data: [string, string];
}
const PubKeysInternedMap = new Map<string, PublicKey>();
export const toPublicKey = (key: string | PublicKey) => {
if (typeof key !== 'string') {
return key;
}
let result = PubKeysInternedMap.get(key);
if (!result) {
result = new PublicKey(key);
PubKeysInternedMap.set(key, result);
}
return result;
};
export interface PublicKeyStringAndAccount<T> {
pubkey: string;
account: AccountInfo<T>;
}
export const WRAPPED_SOL_MINT = new PublicKey(
'So11111111111111111111111111111111111111112',
@ -16,28 +57,20 @@ export const BPF_UPGRADE_LOADER_ID = new PublicKey(
'BPFLoaderUpgradeab1e11111111111111111111111',
);
export const METADATA_PROGRAM_ID = new PublicKey(
'metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s',
//'GCUQ7oWCzgtRKnHnuJGxpr5XVeEkxYUXwTKYcqGtxLv4',
);
export const MEMO_ID = new PublicKey(
'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr',
);
export const VAULT_ID = new PublicKey(
'vau1zxA2LbssAUEF7Gpw91zMM1LvXrvpzJtmZ58rPsn',
//'41cCnZ1Z1upJdtsS1tzFGR34cPFgJLzvJFmgYKpCqkz7',
);
export const METADATA_PROGRAM_ID =
'metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s' as StringPublicKey;
export const AUCTION_ID = new PublicKey(
'auctxRXPeJoc4817jDhf4HbjnhEcr1cCXenosMhK5R8',
//'6u5XVthCStUfmNrYhFsST94oKxzwEZfZFHFhiCnB2nR1',
);
export const VAULT_ID =
'vau1zxA2LbssAUEF7Gpw91zMM1LvXrvpzJtmZ58rPsn' as StringPublicKey;
export const METAPLEX_ID = new PublicKey(
'p1exdMJcjVao65QdewkaZRUnU6VPSXhus9n2GzWfh98',
//'98jcGaKLKx9vv33H9edLUXAydrSipHhJGDQuPXBVPVGp',
);
export const AUCTION_ID =
'auctxRXPeJoc4817jDhf4HbjnhEcr1cCXenosMhK5R8' as StringPublicKey;
export const METAPLEX_ID =
'p1exdMJcjVao65QdewkaZRUnU6VPSXhus9n2GzWfh98' as StringPublicKey;
export const SYSTEM = new PublicKey('11111111111111111111111111111111');

26
js/packages/common/src/utils/programIds.ts
View File

@ -11,6 +11,7 @@ import {
MEMO_ID,
VAULT_ID,
AUCTION_ID,
toPublicKey,
} from './ids';
export const ENABLE_FEES_INPUT = false;
@ -42,21 +43,33 @@ export const setStoreID = (storeId: any) => {
};
const getStoreID = async () => {
console.log(`STORE_OWNER_ADDRESS: ${STORE_OWNER_ADDRESS?.toBase58()}`);
if (!STORE_OWNER_ADDRESS) {
return undefined;
}
let urlStoreId: PublicKey | null = null;
try {
const urlParams = new URLSearchParams(window.location.search);
const text = urlParams.get('store');
if (text) {
urlStoreId = new PublicKey(text);
}
} catch {
// ignore
}
const storeOwnerAddress = urlStoreId || STORE_OWNER_ADDRESS;
console.log(`STORE_OWNER_ADDRESS: ${storeOwnerAddress?.toBase58()}`);
const programs = await findProgramAddress(
[
Buffer.from('metaplex'),
METAPLEX_ID.toBuffer(),
STORE_OWNER_ADDRESS.toBuffer(),
toPublicKey(METAPLEX_ID).toBuffer(),
storeOwnerAddress.toBuffer(),
],
METAPLEX_ID,
toPublicKey(METAPLEX_ID),
);
const CUSTOM = programs[0];
console.log(`CUSTOM STORE: ${CUSTOM.toBase58()}`);
console.log(`CUSTOM STORE: ${CUSTOM}`);
return CUSTOM;
};
@ -68,7 +81,8 @@ export const setProgramIds = async (envName: string) => {
}
if (!STORE) {
STORE = await getStoreID();
const potential_store = await getStoreID();
STORE = potential_store ? toPublicKey(potential_store) : undefined;
}
};

7
js/packages/common/src/utils/utils.ts
View File

@ -60,10 +60,7 @@ export const findProgramAddress = async (
if (cached) {
const value = JSON.parse(cached);
return [new PublicKey(value.key), parseInt(value.nonce)] as [
PublicKey,
number,
];
return [value.key, parseInt(value.nonce)] as [string, number];
}
const result = await PublicKey.findProgramAddress(seeds, programId);
@ -80,7 +77,7 @@ export const findProgramAddress = async (
// ignore
}
return result;
return [result[0].toBase58(), result[1]] as [string, number];
};
// shorten the checksummed version of the input address to have 4 characters at start and end

1
js/packages/web/.env
View File

@ -1 +1,2 @@
REACT_APP_STORE_OWNER_ADDRESS_ADDRESS=
REACT_APP_BIG_STORE=FALSE

1
js/packages/web/next.config.js
View File

@ -29,6 +29,7 @@ module.exports = withPlugins(plugins, {
},
env:{
NEXT_PUBLIC_STORE_OWNER_ADDRESS_ADDRESS: process.env.REACT_APP_STORE_OWNER_ADDRESS_ADDRESS,
NEXT_PUBLIC_BIG_STORE: process.env.REACT_APP_BIG_STORE,
},
async rewrites() {
return [

41
js/packages/web/src/actions/addTokensToVault.ts
View File

@ -1,15 +1,12 @@
import {
Keypair,
Connection,
PublicKey,
TransactionInstruction,
} from '@solana/web3.js';
import { Keypair, Connection, TransactionInstruction } from '@solana/web3.js';
import {
utils,
actions,
models,
findProgramAddress,
MetadataKey,
StringPublicKey,
toPublicKey,
} from '@oyster/common';
import { AccountLayout } from '@solana/spl-token';
@ -21,8 +18,8 @@ const { approve } = models;
export interface SafetyDepositInstructionTemplate {
box: {
tokenAccount?: PublicKey;
tokenMint: PublicKey;
tokenAccount?: StringPublicKey;
tokenMint: StringPublicKey;
amount: BN;
};
draft: SafetyDepositDraft;
@ -35,12 +32,12 @@ const BATCH_SIZE = 1;
export async function addTokensToVault(
connection: Connection,
wallet: any,
vault: PublicKey,
vault: StringPublicKey,
nfts: SafetyDepositInstructionTemplate[],
): Promise<{
instructions: Array<TransactionInstruction[]>;
signers: Array<Keypair[]>;
safetyDepositTokenStores: PublicKey[];
safetyDepositTokenStores: StringPublicKey[];
}> {
const PROGRAM_IDS = utils.programIds();
@ -52,10 +49,10 @@ export async function addTokensToVault(
await findProgramAddress(
[
Buffer.from(VAULT_PREFIX),
PROGRAM_IDS.vault.toBuffer(),
vault.toBuffer(),
toPublicKey(PROGRAM_IDS.vault).toBuffer(),
toPublicKey(vault).toBuffer(),
],
PROGRAM_IDS.vault,
toPublicKey(PROGRAM_IDS.vault),
)
)[0];
@ -63,7 +60,7 @@ export async function addTokensToVault(
let signers: Array<Keypair[]> = [];
let instructions: Array<TransactionInstruction[]> = [];
let newStores: PublicKey[] = [];
let newStores: StringPublicKey[] = [];
let currSigners: Keypair[] = [];
let currInstructions: TransactionInstruction[] = [];
@ -74,16 +71,16 @@ export async function addTokensToVault(
currInstructions,
wallet.publicKey,
accountRentExempt,
nft.box.tokenMint,
vaultAuthority,
toPublicKey(nft.box.tokenMint),
toPublicKey(vaultAuthority),
currSigners,
);
newStores.push(newStoreAccount);
newStores.push(newStoreAccount.toBase58());
const transferAuthority = approve(
currInstructions,
[],
nft.box.tokenAccount,
toPublicKey(nft.box.tokenAccount),
wallet.publicKey,
nft.box.amount.toNumber(),
);
@ -97,11 +94,11 @@ export async function addTokensToVault(
: nft.box.amount,
nft.box.tokenMint,
nft.box.tokenAccount,
newStoreAccount,
newStoreAccount.toBase58(),
vault,
wallet.publicKey,
wallet.publicKey,
transferAuthority.publicKey,
wallet.publicKey.toBase58(),
wallet.publicKey.toBase58(),
transferAuthority.publicKey.toBase58(),
currInstructions,
);

16
js/packages/web/src/actions/cancelBid.ts
View File

@ -9,14 +9,10 @@ import {
sendTransactions,
ParsedAccount,
BidderMetadata,
StringPublicKey,
} from '@oyster/common';
import { AccountLayout } from '@solana/spl-token';
import {
TransactionInstruction,
Keypair,
Connection,
PublicKey,
} from '@solana/web3.js';
import { TransactionInstruction, Keypair, Connection } from '@solana/web3.js';
import { AuctionView } from '../hooks';
import { BidRedemptionTicket, PrizeTrackingTicket } from '../models/metaplex';
import { claimUnusedPrizes } from './claimUnusedPrizes';
@ -25,7 +21,7 @@ import { setupPlaceBid } from './sendPlaceBid';
export async function sendCancelBid(
connection: Connection,
wallet: any,
payingAccount: PublicKey,
payingAccount: StringPublicKey,
auctionView: AuctionView,
accountsByMint: Map<string, TokenAccount>,
bids: ParsedAccount<BidderMetadata>[],
@ -110,9 +106,7 @@ export async function setupCancelBid(
let cancelInstructions: TransactionInstruction[] = [];
let cleanupInstructions: TransactionInstruction[] = [];
let tokenAccount = accountsByMint.get(
auctionView.auction.info.tokenMint.toBase58(),
);
let tokenAccount = accountsByMint.get(auctionView.auction.info.tokenMint);
const mint = cache.get(auctionView.auction.info.tokenMint);
if (mint && auctionView.myBidderPot) {
@ -126,7 +120,7 @@ export async function setupCancelBid(
);
await cancelBid(
wallet.publicKey,
wallet.publicKey.toBase58(),
receivingSolAccount,
auctionView.myBidderPot.info.bidderPot,
auctionView.auction.info.tokenMint,

72
js/packages/web/src/actions/claimUnusedPrizes.ts
View File

@ -1,9 +1,4 @@
import {
Keypair,
Connection,
TransactionInstruction,
PublicKey,
} from '@solana/web3.js';
import { Keypair, Connection, TransactionInstruction } from '@solana/web3.js';
import {
actions,
ParsedAccount,
@ -17,6 +12,7 @@ import {
createAssociatedTokenAccountInstruction,
MetadataKey,
BidderMetadata,
toPublicKey,
} from '@oyster/common';
import { AccountLayout, MintLayout } from '@solana/spl-token';
@ -35,7 +31,6 @@ import {
setupRedeemParticipationInstructions,
setupRedeemPrintingV2Instructions,
} from './sendRedeemBid';
import { WinningConfigStateItem } from '../models/metaplex/deprecatedStates';
const { createTokenAccount } = actions;
export async function findEligibleParticipationBidsForRedemption(
@ -60,9 +55,7 @@ export async function findEligibleParticipationBidsForRedemption(
);
const bidRedemption =
bidRedemptions[
(
await getBidRedemption(auctionView.auction.pubkey, bid.pubkey)
).toBase58()
await getBidRedemption(auctionView.auction.pubkey, bid.pubkey)
];
const eligible = eligibleForParticipationPrizeGivenWinningIndex(
winnerIndex,
@ -70,7 +63,7 @@ export async function findEligibleParticipationBidsForRedemption(
bid,
bidRedemption,
);
console.log(bid.pubkey.toBase58(), 'eligible?', eligible);
console.log(bid.pubkey, 'eligible?', eligible);
if (eligible) {
unredeemedParticipations.push({ bid, bidRedemption });
}
@ -104,7 +97,7 @@ export async function claimUnusedPrizes(
MetadataKey.MasterEditionV2
) {
const balance = await connection.getTokenAccountBalance(
auctionView.participationItem.safetyDeposit.info.store,
toPublicKey(auctionView.participationItem.safetyDeposit.info.store),
);
if (balance.value.uiAmount || 0 > 0) {
// before we can redeem, check if we need to print other people's stuff.
@ -164,7 +157,7 @@ export async function claimUnusedPrizes(
const safetyDeposit = item.safetyDeposit;
const tokenBalance = await connection.getTokenAccountBalance(
safetyDeposit.info.store,
toPublicKey(safetyDeposit.info.store),
);
// If box is empty, we cant redeem this. Could be broken AM we are claiming against.
if (tokenBalance.value.uiAmount === 0) {
@ -199,14 +192,11 @@ export async function claimUnusedPrizes(
const winningBidder =
auctionView.auction.info.bidState.getWinnerAt(winnerIndex);
if (winningBidder) {
const bidderMetadata = bids.find(b =>
b.info.bidderPubkey.equals(winningBidder),
const bidderMetadata = bids.find(
b => b.info.bidderPubkey === winningBidder,
);
if (bidderMetadata) {
console.log(
'Redeeming v2 for bid by wallet',
winningBidder.toBase58(),
);
console.log('Redeeming v2 for bid by wallet', winningBidder);
await setupRedeemPrintingV2Instructions(
connection,
auctionView,
@ -222,7 +212,7 @@ export async function claimUnusedPrizes(
);
}
}
printingV2ByMint[item.metadata.info.mint.toBase58()] = item;
printingV2ByMint[item.metadata.info.mint] = item;
break;
case WinningConfigType.FullRightsTransfer:
console.log('Redeeming Full Rights');
@ -292,17 +282,17 @@ async function setupRedeemInstructions(
if (!claimed) {
let newTokenAccount = accountsByMint.get(
safetyDeposit.info.tokenMint.toBase58(),
safetyDeposit.info.tokenMint,
)?.pubkey;
if (!newTokenAccount)
newTokenAccount = createTokenAccount(
winningPrizeInstructions,
wallet.publicKey,
accountRentExempt,
safetyDeposit.info.tokenMint,
toPublicKey(safetyDeposit.info.tokenMint),
wallet.publicKey,
winningPrizeSigner,
);
).toBase58();
await redeemBid(
auctionView.auctionManager.vault,
@ -310,8 +300,8 @@ async function setupRedeemInstructions(
newTokenAccount,
safetyDeposit.pubkey,
auctionView.vault.info.fractionMint,
wallet.publicKey,
wallet.publicKey,
wallet.publicKey.toBase58(),
wallet.publicKey.toBase58(),
undefined,
undefined,
false,
@ -342,17 +332,17 @@ async function setupRedeemFullRightsTransferInstructions(
instructions.push(winningPrizeInstructions);
if (!claimed) {
let newTokenAccount = accountsByMint.get(
safetyDeposit.info.tokenMint.toBase58(),
safetyDeposit.info.tokenMint,
)?.pubkey;
if (!newTokenAccount)
newTokenAccount = createTokenAccount(
winningPrizeInstructions,
wallet.publicKey,
accountRentExempt,
safetyDeposit.info.tokenMint,
toPublicKey(safetyDeposit.info.tokenMint),
wallet.publicKey,
winningPrizeSigner,
);
).toBase58();
await redeemFullRightsTransferBid(
auctionView.auctionManager.vault,
@ -360,11 +350,11 @@ async function setupRedeemFullRightsTransferInstructions(
newTokenAccount,
safetyDeposit.pubkey,
auctionView.vault.info.fractionMint,
wallet.publicKey,
wallet.publicKey,
wallet.publicKey.toBase58(),
wallet.publicKey.toBase58(),
winningPrizeInstructions,
item.metadata.pubkey,
wallet.publicKey,
wallet.publicKey.toBase58(),
winningConfigIndex,
);
}
@ -390,21 +380,21 @@ async function setupWithdrawMasterEditionInstructions(
[
wallet.publicKey.toBuffer(),
programIds().token.toBuffer(),
item.metadata.info.mint.toBuffer(),
toPublicKey(item.metadata.info.mint).toBuffer(),
],
programIds().associatedToken,
)
)[0];
const existingAta = await connection.getAccountInfo(ata);
const existingAta = await connection.getAccountInfo(toPublicKey(ata));
console.log('Existing ata?', existingAta);
if (!existingAta) {
createAssociatedTokenAccountInstruction(
myInstructions,
ata,
toPublicKey(ata),
wallet.publicKey,
wallet.publicKey,
item.metadata.info.mint,
toPublicKey(item.metadata.info.mint),
);
}
@ -443,8 +433,8 @@ async function deprecatedSetupRedeemPrintingInstructions(
auctionView.auctionManager.pubkey,
);
const newTokenAccount = accountsByMint.get(me.info.printingMint.toBase58());
let newTokenAccountKey: PublicKey | undefined = newTokenAccount?.pubkey;
const newTokenAccount = accountsByMint.get(me.info.printingMint);
let newTokenAccountKey = newTokenAccount?.pubkey;
if (updateAuth) {
const claimed = auctionView.auctionManager.isItemClaimed(
@ -464,10 +454,10 @@ async function deprecatedSetupRedeemPrintingInstructions(
winningPrizeInstructions,
wallet.publicKey,
accountRentExempt,
me.info.printingMint,
toPublicKey(me.info.printingMint),
wallet.publicKey,
winningPrizeSigner,
);
).toBase58();
await redeemBid(
auctionView.auctionManager.vault,
@ -475,8 +465,8 @@ async function deprecatedSetupRedeemPrintingInstructions(
newTokenAccountKey,
safetyDeposit.pubkey,
auctionView.vault.info.fractionMint,
wallet.publicKey,
wallet.publicKey,
wallet.publicKey.toBase58(),
wallet.publicKey.toBase58(),
item.masterEdition.pubkey,
reservationList,
true,

16
js/packages/web/src/actions/closePersonalEscrow.ts
View File

@ -1,10 +1,10 @@
import { Connection, Keypair, TransactionInstruction } from '@solana/web3.js';
import {
Connection,
Keypair,
PublicKey,
TransactionInstruction,
} from '@solana/web3.js';
import { utils, sendTransactionWithRetry } from '@oyster/common';
utils,
sendTransactionWithRetry,
StringPublicKey,
toPublicKey,
} from '@oyster/common';
import { Token } from '@solana/spl-token';
// When you are an artist and you receive royalties, due to the design of the system
@ -16,7 +16,7 @@ import { Token } from '@solana/spl-token';
export async function closePersonalEscrow(
connection: Connection,
wallet: any,
ata: PublicKey,
ata: StringPublicKey,
) {
const PROGRAM_IDS = utils.programIds();
@ -25,7 +25,7 @@ export async function closePersonalEscrow(
let instructions: TransactionInstruction[] = [
Token.createCloseAccountInstruction(
PROGRAM_IDS.token,
ata,
toPublicKey(ata),
wallet.publicKey,
wallet.publicKey,
[],

35
js/packages/web/src/actions/closeVault.ts
View File

@ -1,10 +1,5 @@
import {
Keypair,
Connection,
PublicKey,
TransactionInstruction,
} from '@solana/web3.js';
import { actions, models } from '@oyster/common';
import { Keypair, Connection, TransactionInstruction } from '@solana/web3.js';
import { actions, models, StringPublicKey, toPublicKey } from '@oyster/common';
import { AccountLayout } from '@solana/spl-token';
import BN from 'bn.js';
@ -16,12 +11,12 @@ const { approve } = models;
export async function closeVault(
connection: Connection,
wallet: any,
vault: PublicKey,
fractionMint: PublicKey,
fractionTreasury: PublicKey,
redeemTreasury: PublicKey,
priceMint: PublicKey,
externalPriceAccount: PublicKey,
vault: StringPublicKey,
fractionMint: StringPublicKey,
fractionTreasury: StringPublicKey,
redeemTreasury: StringPublicKey,
priceMint: StringPublicKey,
externalPriceAccount: StringPublicKey,
): Promise<{
instructions: TransactionInstruction[];
signers: Keypair[];
@ -45,7 +40,7 @@ export async function closeVault(
instructions,
wallet.publicKey,
accountRentExempt,
fractionMint,
toPublicKey(fractionMint),
wallet.publicKey,
signers,
);
@ -54,7 +49,7 @@ export async function closeVault(
instructions,
wallet.publicKey,
accountRentExempt,
priceMint,
toPublicKey(priceMint),
wallet.publicKey,
signers,
);
@ -89,14 +84,14 @@ export async function closeVault(
await combineVault(
vault,
outstandingShareAccount,
payingTokenAccount,
outstandingShareAccount.toBase58(),
payingTokenAccount.toBase58(),
fractionMint,
fractionTreasury,
redeemTreasury,
wallet.publicKey,
wallet.publicKey,
transferAuthority.publicKey,
wallet.publicKey.toBase58(),
wallet.publicKey.toBase58(),
transferAuthority.publicKey.toBase58(),
externalPriceAccount,
instructions,
);

37
js/packages/web/src/actions/convertMasterEditions.ts
View File

@ -11,6 +11,7 @@ import {
convertMasterEditionV1ToV2,
TokenAccount,
programIds,
toPublicKey,
} from '@oyster/common';
import { Token } from '@solana/spl-token';
const BATCH_SIZE = 10;
@ -35,7 +36,7 @@ export async function filterMetadata(
for (let i = 0; i < metadata.length; i++) {
const md = metadata[i];
const masterEdition = masterEditions[
md.info.masterEdition?.toBase58() || ''
md.info.masterEdition || ''
] as ParsedAccount<MasterEditionV1>;
if (
masterEdition &&
@ -46,20 +47,18 @@ export async function filterMetadata(
await new Promise(resolve => setTimeout(resolve, 10000));
batchWaitCounter = 0;
}
console.log('Reviewing', masterEdition.pubkey.toBase58());
console.log('Reviewing', masterEdition.pubkey);
let printingBal = 0;
try {
let printingBalResp = await connection.getTokenSupply(
masterEdition.info.printingMint,
toPublicKey(masterEdition.info.printingMint),
);
printingBal = printingBalResp.value.uiAmount || 0;
} catch (e) {
console.error(e);
}
const myAcct = accountsByMint.get(
masterEdition.info.printingMint.toBase58(),
);
const myAcct = accountsByMint.get(masterEdition.info.printingMint);
if (myAcct) {
console.log(
'Existing print account subtracts',
@ -73,7 +72,7 @@ export async function filterMetadata(
if (printingBal > 0) {
console.log(
'Reject',
masterEdition.pubkey.toBase58(),
masterEdition.pubkey,
'due to printing bal of',
printingBal,
);
@ -82,7 +81,7 @@ export async function filterMetadata(
let oneTimeBal = 0;
try {
let oneTimeBalResp = await connection.getTokenSupply(
masterEdition.info.oneTimePrintingAuthorizationMint,
toPublicKey(masterEdition.info.oneTimePrintingAuthorizationMint),
);
oneTimeBal = oneTimeBalResp.value.uiAmount || 0;
} catch (e) {
@ -90,7 +89,7 @@ export async function filterMetadata(
}
const myAcct = accountsByMint.get(
masterEdition.info.oneTimePrintingAuthorizationMint.toBase58(),
masterEdition.info.oneTimePrintingAuthorizationMint,
);
if (myAcct) {
console.log(
@ -105,7 +104,7 @@ export async function filterMetadata(
if (oneTimeBal > 0) {
console.log(
'Reject',
masterEdition.pubkey.toBase58(),
masterEdition.pubkey,
'due to one time auth bal of',
oneTimeBal,
);
@ -143,20 +142,20 @@ export async function convertMasterEditions(
for (let i = 0; i < masterEditions.length; i++) {
const masterEdition = masterEditions[i] as ParsedAccount<MasterEditionV1>;
console.log('Converting', masterEdition.pubkey.toBase58());
console.log('Converting', masterEdition.pubkey);
const printingMintAcct = accountsByMint.get(
masterEdition.info.printingMint.toBase58(),
masterEdition.info.printingMint,
);
const oneTimeAuthMintAcct = accountsByMint.get(
masterEdition.info.oneTimePrintingAuthorizationMint.toBase58(),
masterEdition.info.oneTimePrintingAuthorizationMint,
);
if (printingMintAcct) {
if (printingMintAcct.info.amount.toNumber() > 0) {
convertInstructions.push(
Token.createBurnInstruction(
PROGRAM_IDS.token,
masterEdition.info.printingMint,
printingMintAcct.pubkey,
toPublicKey(masterEdition.info.printingMint),
toPublicKey(printingMintAcct.pubkey),
wallet.publicKey,
[],
printingMintAcct.info.amount,
@ -167,7 +166,7 @@ export async function convertMasterEditions(
convertInstructions.push(
Token.createCloseAccountInstruction(
PROGRAM_IDS.token,
printingMintAcct.pubkey,
toPublicKey(printingMintAcct.pubkey),
wallet.publicKey,
wallet.publicKey,
[],
@ -180,8 +179,8 @@ export async function convertMasterEditions(
convertInstructions.push(
Token.createBurnInstruction(
PROGRAM_IDS.token,
masterEdition.info.oneTimePrintingAuthorizationMint,
oneTimeAuthMintAcct.pubkey,
toPublicKey(masterEdition.info.oneTimePrintingAuthorizationMint),
toPublicKey(oneTimeAuthMintAcct.pubkey),
wallet.publicKey,
[],
oneTimeAuthMintAcct.info.amount,
@ -192,7 +191,7 @@ export async function convertMasterEditions(
convertInstructions.push(
Token.createCloseAccountInstruction(
PROGRAM_IDS.token,
oneTimeAuthMintAcct.pubkey,
toPublicKey(oneTimeAuthMintAcct.pubkey),
wallet.publicKey,
wallet.publicKey,
[],

104
js/packages/web/src/actions/createAuctionManager.ts
View File

@ -1,7 +1,6 @@
import {
Keypair,
Connection,
PublicKey,
TransactionInstruction,
SystemProgram,
} from '@solana/web3.js';
@ -24,6 +23,8 @@ import {
findProgramAddress,
IPartialCreateAuctionArgs,
MetadataKey,
StringPublicKey,
toPublicKey,
} from '@oyster/common';
import { AccountLayout, Token } from '@solana/spl-token';
@ -87,8 +88,8 @@ export interface SafetyDepositDraft {
metadata: ParsedAccount<Metadata>;
masterEdition?: ParsedAccount<MasterEditionV1 | MasterEditionV2>;
edition?: ParsedAccount<Edition>;
holding: PublicKey;
printingMintHolding?: PublicKey;
holding: StringPublicKey;
printingMintHolding?: StringPublicKey;
winningConfigType: WinningConfigType;
amountRanges: AmountRange[];
participationConfig?: ParticipationConfigV2;
@ -106,11 +107,11 @@ export async function createAuctionManager(
auctionSettings: IPartialCreateAuctionArgs,
safetyDepositDrafts: SafetyDepositDraft[],
participationSafetyDepositDraft: SafetyDepositDraft | undefined,
paymentMint: PublicKey,
paymentMint: StringPublicKey,
): Promise<{
vault: PublicKey;
auction: PublicKey;
auctionManager: PublicKey;
vault: StringPublicKey;
auction: StringPublicKey;
auctionManager: StringPublicKey;
}> {
const accountRentExempt = await connection.getMinimumBalanceForRentExemption(
AccountLayout.span,
@ -260,9 +261,8 @@ export async function createAuctionManager(
// Only V1s need to skip normal validation and use special endpoint
(participationSafetyDepositDraft.masterEdition?.info.key ==
MetadataKey.MasterEditionV1 &&
!c.draft.metadata.pubkey.equals(
participationSafetyDepositDraft.metadata.pubkey,
)) ||
c.draft.metadata.pubkey !==
participationSafetyDepositDraft.metadata.pubkey) ||
participationSafetyDepositDraft.masterEdition?.info.key ==
MetadataKey.MasterEditionV2,
),
@ -405,7 +405,7 @@ async function buildSafetyDepositArray(
},
config: new SafetyDepositConfig({
directArgs: {
auctionManager: SystemProgram.programId,
auctionManager: SystemProgram.programId.toBase58(),
order: new BN(i),
amountRanges: s.amountRanges,
amountType: maxAmount.gte(new BN(254))
@ -439,7 +439,7 @@ async function buildSafetyDepositArray(
.reverse()[0];
const config = new SafetyDepositConfig({
directArgs: {
auctionManager: SystemProgram.programId,
auctionManager: SystemProgram.programId.toBase58(),
order: new BN(safetyDeposits.length),
amountRanges: participationSafetyDepositDraft.amountRanges,
amountType: maxAmount?.gte(new BN(255))
@ -470,7 +470,9 @@ async function buildSafetyDepositArray(
[
wallet.publicKey.toBuffer(),
programIds().token.toBuffer(),
me?.info.oneTimePrintingAuthorizationMint.toBuffer(),
toPublicKey(
me?.info.oneTimePrintingAuthorizationMint,
).toBuffer(),
],
programIds().associatedToken,
)
@ -499,17 +501,17 @@ async function buildSafetyDepositArray(
async function setupAuctionManagerInstructions(
wallet: any,
vault: PublicKey,
paymentMint: PublicKey,
vault: StringPublicKey,
paymentMint: StringPublicKey,
accountRentExempt: number,
safetyDeposits: SafetyDepositInstructionTemplate[],
auctionSettings: IPartialCreateAuctionArgs,
): Promise<{
instructions: TransactionInstruction[];
signers: Keypair[];
auctionManager: PublicKey;
auctionManager: StringPublicKey;
}> {
let store = programIds().store;
let store = programIds().store?.toBase58();
if (!store) {
throw new Error('Store not initialized');
}
@ -523,10 +525,10 @@ async function setupAuctionManagerInstructions(
instructions,
wallet.publicKey,
accountRentExempt,
paymentMint,
auctionManagerKey,
toPublicKey(paymentMint),
toPublicKey(auctionManagerKey),
signers,
);
).toBase58();
let maxRanges = [
auctionSettings.winners.usize.toNumber(),
@ -539,8 +541,8 @@ async function setupAuctionManagerInstructions(
await initAuctionManagerV2(
vault,
wallet.publicKey,
wallet.publicKey,
wallet.publicKey.toBase58(),
wallet.publicKey.toBase58(),
acceptPayment,
store,
safetyDeposits.length >= 254 ? TupleNumericType.U16 : TupleNumericType.U8,
@ -556,7 +558,7 @@ async function setupAuctionManagerInstructions(
async function setupStartAuction(
wallet: any,
vault: PublicKey,
vault: StringPublicKey,
): Promise<{
instructions: TransactionInstruction[];
signers: Keypair[];
@ -571,17 +573,17 @@ async function setupStartAuction(
async function deprecatedValidateParticipationHelper(
wallet: any,
auctionManager: PublicKey,
auctionManager: StringPublicKey,
whitelistedCreatorsByCreator: Record<
string,
ParsedAccount<WhitelistedCreator>
>,
vault: PublicKey,
tokenStore: PublicKey,
vault: StringPublicKey,
tokenStore: StringPublicKey,
participationSafetyDepositDraft: SafetyDepositDraft,
accountRentExempt: number,
): Promise<{ instructions: TransactionInstruction[]; signers: Keypair[] }> {
const store = programIds().store;
const store = programIds().store?.toBase58();
if (!store) {
throw new Error('Store not initialized');
}
@ -611,16 +613,16 @@ async function deprecatedValidateParticipationHelper(
instructions,
wallet.publicKey,
accountRentExempt,
me.info.printingMint,
auctionManagerKey,
toPublicKey(me.info.printingMint),
toPublicKey(auctionManagerKey),
signers,
);
).toBase58();
await deprecatedValidateParticipation(
auctionManager,
participationSafetyDepositDraft.metadata.pubkey,
participationSafetyDepositDraft.masterEdition?.pubkey,
printingTokenHoldingAccount,
wallet.publicKey,
wallet.publicKey.toBase58(),
whitelistedCreator,
store,
await getSafetyDepositBoxAddress(
@ -642,14 +644,12 @@ async function findValidWhitelistedCreator(
ParsedAccount<WhitelistedCreator>
>,
creators: Creator[],
): Promise<PublicKey> {
): Promise<StringPublicKey> {
for (let i = 0; i < creators.length; i++) {
const creator = creators[i];
if (
whitelistedCreatorsByCreator[creator.address.toBase58()]?.info.activated
)
return whitelistedCreatorsByCreator[creator.address.toBase58()].pubkey;
if (whitelistedCreatorsByCreator[creator.address]?.info.activated)
return whitelistedCreatorsByCreator[creator.address].pubkey;
}
return await getWhitelistedCreator(creators[0]?.address);
}
@ -660,14 +660,14 @@ async function validateBoxes(
string,
ParsedAccount<WhitelistedCreator>
>,
vault: PublicKey,
vault: StringPublicKey,
safetyDeposits: SafetyDepositInstructionTemplate[],
safetyDepositTokenStores: PublicKey[],
safetyDepositTokenStores: StringPublicKey[],
): Promise<{
instructions: TransactionInstruction[][];
signers: Keypair[][];
}> {
const store = programIds().store;
const store = programIds().store?.toBase58();
if (!store) {
throw new Error('Store not initialized');
}
@ -678,7 +678,7 @@ async function validateBoxes(
let tokenSigners: Keypair[] = [];
let tokenInstructions: TransactionInstruction[] = [];
let safetyDepositBox: PublicKey;
let safetyDepositBox: StringPublicKey;
const me = safetyDeposits[i].draft
.masterEdition as ParsedAccount<MasterEditionV1>;
@ -699,7 +699,7 @@ async function validateBoxes(
safetyDeposits[i].draft.metadata.info.mint,
);
}
const edition: PublicKey = await getEdition(
const edition: StringPublicKey = await getEdition(
safetyDeposits[i].draft.metadata.info.mint,
);
@ -721,9 +721,9 @@ async function validateBoxes(
WinningConfigType.PrintingV1
? me?.info.printingMint
: safetyDeposits[i].draft.metadata.info.mint,
wallet.publicKey,
wallet.publicKey,
wallet.publicKey,
wallet.publicKey.toBase58(),
wallet.publicKey.toBase58(),
wallet.publicKey.toBase58(),
tokenInstructions,
edition,
whitelistedCreator,
@ -740,7 +740,7 @@ async function validateBoxes(
async function deprecatedBuildAndPopulateOneTimeAuthorizationAccount(
connection: Connection,
wallet: any,
oneTimePrintingAuthorizationMint: PublicKey | undefined,
oneTimePrintingAuthorizationMint: StringPublicKey | undefined,
): Promise<{
instructions: TransactionInstruction[];
signers: Keypair[];
@ -749,32 +749,32 @@ async function deprecatedBuildAndPopulateOneTimeAuthorizationAccount(
return { instructions: [], signers: [] };
let signers: Keypair[] = [];
let instructions: TransactionInstruction[] = [];
const recipientKey: PublicKey = (
const recipientKey: StringPublicKey = (
await findProgramAddress(
[
wallet.publicKey.toBuffer(),
programIds().token.toBuffer(),
oneTimePrintingAuthorizationMint.toBuffer(),
toPublicKey(oneTimePrintingAuthorizationMint).toBuffer(),
],
programIds().associatedToken,
)
)[0];
if (!(await connection.getAccountInfo(recipientKey))) {
if (!(await connection.getAccountInfo(toPublicKey(recipientKey)))) {
createAssociatedTokenAccountInstruction(
instructions,
recipientKey,
toPublicKey(recipientKey),
wallet.publicKey,
wallet.publicKey,
oneTimePrintingAuthorizationMint,
toPublicKey(oneTimePrintingAuthorizationMint),
);
}
instructions.push(
Token.createMintToInstruction(
programIds().token,
oneTimePrintingAuthorizationMint,
recipientKey,
toPublicKey(oneTimePrintingAuthorizationMint),
toPublicKey(recipientKey),
wallet.publicKey,
[],
1,

22
js/packages/web/src/actions/createExternalPriceAccount.ts
View File

@ -1,11 +1,10 @@
import {
Keypair,
Connection,
PublicKey,
SystemProgram,
TransactionInstruction,
} from '@solana/web3.js';
import { utils, actions } from '@oyster/common';
import { utils, actions, StringPublicKey, toPublicKey } from '@oyster/common';
import BN from 'bn.js';
import { QUOTE_MINT } from '../constants';
@ -20,8 +19,8 @@ export async function createExternalPriceAccount(
connection: Connection,
wallet: any,
): Promise<{
priceMint: PublicKey;
externalPriceAccount: PublicKey;
priceMint: StringPublicKey;
externalPriceAccount: StringPublicKey;
instructions: TransactionInstruction[];
signers: Keypair[];
}> {
@ -35,10 +34,11 @@ export async function createExternalPriceAccount(
);
let externalPriceAccount = Keypair.generate();
let key = externalPriceAccount.publicKey.toBase58();
let epaStruct = new ExternalPriceAccount({
pricePerShare: new BN(0),
priceMint: QUOTE_MINT,
priceMint: QUOTE_MINT.toBase58(),
allowedToCombine: true,
});
@ -47,20 +47,16 @@ export async function createExternalPriceAccount(
newAccountPubkey: externalPriceAccount.publicKey,
lamports: epaRentExempt,
space: MAX_EXTERNAL_ACCOUNT_SIZE,
programId: PROGRAM_IDS.vault,
programId: toPublicKey(PROGRAM_IDS.vault),
});
instructions.push(uninitializedEPA);
signers.push(externalPriceAccount);
await updateExternalPriceAccount(
externalPriceAccount.publicKey,
epaStruct,
instructions,
);
await updateExternalPriceAccount(key, epaStruct, instructions);
return {
externalPriceAccount: externalPriceAccount.publicKey,
priceMint: QUOTE_MINT,
externalPriceAccount: key,
priceMint: QUOTE_MINT.toBase58(),
instructions,
signers,
};

52
js/packages/web/src/actions/createVault.ts
View File

@ -1,11 +1,17 @@
import {
Keypair,
Connection,
PublicKey,
SystemProgram,
TransactionInstruction,
} from '@solana/web3.js';
import { utils, actions, createMint, findProgramAddress } from '@oyster/common';
import {
utils,
actions,
createMint,
findProgramAddress,
StringPublicKey,
toPublicKey,
} from '@oyster/common';
import { AccountLayout, MintLayout } from '@solana/spl-token';
const { createTokenAccount, initVault, MAX_VAULT_SIZE, VAULT_PREFIX } = actions;
@ -15,13 +21,13 @@ const { createTokenAccount, initVault, MAX_VAULT_SIZE, VAULT_PREFIX } = actions;
export async function createVault(
connection: Connection,
wallet: any,
priceMint: PublicKey,
externalPriceAccount: PublicKey,
priceMint: StringPublicKey,
externalPriceAccount: StringPublicKey,
): Promise<{
vault: PublicKey;
fractionalMint: PublicKey;
redeemTreasury: PublicKey;
fractionTreasury: PublicKey;
vault: StringPublicKey;
fractionalMint: StringPublicKey;
redeemTreasury: StringPublicKey;
fractionTreasury: StringPublicKey;
instructions: TransactionInstruction[];
signers: Keypair[];
}> {
@ -48,10 +54,10 @@ export async function createVault(
await findProgramAddress(
[
Buffer.from(VAULT_PREFIX),
PROGRAM_IDS.vault.toBuffer(),
toPublicKey(PROGRAM_IDS.vault).toBuffer(),
vault.publicKey.toBuffer(),
],
PROGRAM_IDS.vault,
toPublicKey(PROGRAM_IDS.vault),
)
)[0];
@ -60,35 +66,35 @@ export async function createVault(
wallet.publicKey,
mintRentExempt,
0,
vaultAuthority,
vaultAuthority,
toPublicKey(vaultAuthority),
toPublicKey(vaultAuthority),
signers,
);
).toBase58();
const redeemTreasury = createTokenAccount(
instructions,
wallet.publicKey,
accountRentExempt,
priceMint,
vaultAuthority,
toPublicKey(priceMint),
toPublicKey(vaultAuthority),
signers,
);
).toBase58();
const fractionTreasury = createTokenAccount(
instructions,
wallet.publicKey,
accountRentExempt,
fractionalMint,
vaultAuthority,
toPublicKey(fractionalMint),
toPublicKey(vaultAuthority),
signers,
);
).toBase58();
const uninitializedVault = SystemProgram.createAccount({
fromPubkey: wallet.publicKey,
newAccountPubkey: vault.publicKey,
lamports: vaultRentExempt,
space: MAX_VAULT_SIZE,
programId: PROGRAM_IDS.vault,
programId: toPublicKey(PROGRAM_IDS.vault),
});
instructions.push(uninitializedVault);
signers.push(vault);
@ -98,14 +104,14 @@ export async function createVault(
fractionalMint,
redeemTreasury,
fractionTreasury,
vault.publicKey,
wallet.publicKey,
vault.publicKey.toBase58(),
wallet.publicKey.toBase58(),
externalPriceAccount,
instructions,
);
return {
vault: vault.publicKey,
vault: vault.publicKey.toBase58(),
fractionalMint,
redeemTreasury,
fractionTreasury,

18
js/packages/web/src/actions/decommAuctionManagerAndReturnPrizes.ts
View File

@ -1,7 +1,5 @@
import { Keypair, Connection, TransactionInstruction } from '@solana/web3.js';
import {
BidderMetadata,
ParsedAccount,
sendTransactionsWithManualRetry,
setAuctionAuthority,
setVaultAuthority,
@ -9,11 +7,7 @@ import {
} from '@oyster/common';
import { AuctionView } from '../hooks';
import {
AuctionManagerStatus,
BidRedemptionTicket,
PrizeTrackingTicket,
} from '../models/metaplex';
import { AuctionManagerStatus } from '../models/metaplex';
import { decommissionAuctionManager } from '../models/metaplex/decommissionAuctionManager';
import { claimUnusedPrizes } from './claimUnusedPrizes';
@ -30,18 +24,18 @@ export async function decommAuctionManagerAndReturnPrizes(
let decomSigners: Keypair[] = [];
let decomInstructions: TransactionInstruction[] = [];
if (auctionView.auction.info.authority.equals(wallet.publicKey)) {
if (auctionView.auction.info.authority === wallet.publicKey.toBase58()) {
await setAuctionAuthority(
auctionView.auction.pubkey,
wallet.publicKey,
wallet.publicKey.toBase58(),
auctionView.auctionManager.pubkey,
decomInstructions,
);
}
if (auctionView.vault.info.authority.equals(wallet.publicKey)) {
if (auctionView.vault.info.authority === wallet.publicKey.toBase58()) {
await setVaultAuthority(
auctionView.vault.pubkey,
wallet.publicKey,
wallet.publicKey.toBase58(),
auctionView.auctionManager.pubkey,
decomInstructions,
);
@ -49,7 +43,7 @@ export async function decommAuctionManagerAndReturnPrizes(
await decommissionAuctionManager(
auctionView.auctionManager.pubkey,
auctionView.auction.pubkey,
wallet.publicKey,
wallet.publicKey.toBase58(),
auctionView.vault.pubkey,
decomInstructions,
);

13
js/packages/web/src/actions/deprecatedCreateReservationListsForTokens.ts
View File

@ -1,5 +1,8 @@
import { Keypair, PublicKey, TransactionInstruction } from '@solana/web3.js';
import { deprecatedCreateReservationList } from '@oyster/common';
import { Keypair, TransactionInstruction } from '@solana/web3.js';
import {
deprecatedCreateReservationList,
StringPublicKey,
} from '@oyster/common';
import { SafetyDepositInstructionTemplate } from './addTokensToVault';
import { WinningConfigType } from '../models/metaplex';
@ -9,7 +12,7 @@ const BATCH_SIZE = 10;
// Reservation lists are used to insure printing order among limited editions.
export async function deprecatedCreateReservationListForTokens(
wallet: any,
auctionManager: PublicKey,
auctionManager: StringPublicKey,
safetyDepositInstructionTemplates: SafetyDepositInstructionTemplate[],
): Promise<{
instructions: Array<TransactionInstruction[]>;
@ -33,8 +36,8 @@ export async function deprecatedCreateReservationListForTokens(
safetyDeposit.draft.metadata.pubkey,
safetyDeposit.draft.masterEdition.pubkey,
auctionManager,
wallet.publicKey,
wallet.publicKey,
wallet.publicKey.toBase58(),
wallet.publicKey.toBase58(),
currInstructions,
);

29
js/packages/web/src/actions/deprecatedPopulatePrintingTokens.ts
View File

@ -1,9 +1,4 @@
import {
Keypair,
Connection,
PublicKey,
TransactionInstruction,
} from '@solana/web3.js';
import { Keypair, Connection, TransactionInstruction } from '@solana/web3.js';
import {
utils,
createAssociatedTokenAccountInstruction,
@ -12,6 +7,7 @@ import {
MasterEditionV1,
ParsedAccount,
MetadataKey,
toPublicKey,
} from '@oyster/common';
import BN from 'bn.js';
@ -46,13 +42,13 @@ export async function deprecatedPopulatePrintingTokens(
const printingMint = (
nft.draft.masterEdition as ParsedAccount<MasterEditionV1>
)?.info.printingMint;
if (nft.box.tokenMint.equals(printingMint) && !nft.box.tokenAccount) {
const holdingKey: PublicKey = (
if (nft.box.tokenMint === printingMint && !nft.box.tokenAccount) {
const holdingKey = (
await findProgramAddress(
[
wallet.publicKey.toBuffer(),
PROGRAM_IDS.token.toBuffer(),
printingMint.toBuffer(),
toPublicKey(printingMint).toBuffer(),
],
PROGRAM_IDS.associatedToken,
)
@ -60,22 +56,25 @@ export async function deprecatedPopulatePrintingTokens(
createAssociatedTokenAccountInstruction(
currInstructions,
holdingKey,
toPublicKey(holdingKey),
wallet.publicKey,
wallet.publicKey,
printingMint,
toPublicKey(printingMint),
);
console.log('Making atas');
nft.draft.printingMintHolding = holdingKey;
nft.box.tokenAccount = holdingKey;
}
if (nft.box.tokenAccount && nft.box.tokenMint.equals(printingMint)) {
if (nft.box.tokenAccount && nft.box.tokenMint === printingMint) {
let balance = 0;
try {
balance =
(await connection.getTokenAccountBalance(nft.box.tokenAccount)).value
.uiAmount || 0;
(
await connection.getTokenAccountBalance(
toPublicKey(nft.box.tokenAccount),
)
).value.uiAmount || 0;
} catch (e) {
console.error(e);
}
@ -84,7 +83,7 @@ export async function deprecatedPopulatePrintingTokens(
await deprecatedMintPrintingTokens(
nft.box.tokenAccount,
nft.box.tokenMint,
wallet.publicKey,
wallet.publicKey.toBase58(),
nft.draft.metadata.pubkey,
nft.draft.masterEdition.pubkey,
new BN(nft.box.amount.toNumber() - balance),

20
js/packages/web/src/actions/makeAuction.ts
View File

@ -1,10 +1,12 @@
import { Keypair, PublicKey, TransactionInstruction } from '@solana/web3.js';
import { Keypair, TransactionInstruction } from '@solana/web3.js';
import {
utils,
actions,
findProgramAddress,
IPartialCreateAuctionArgs,
CreateAuctionArgs,
StringPublicKey,
toPublicKey,
} from '@oyster/common';
const { AUCTION_PREFIX, createAuction } = actions;
@ -12,10 +14,10 @@ const { AUCTION_PREFIX, createAuction } = actions;
// This command makes an auction
export async function makeAuction(
wallet: any,
vault: PublicKey,
vault: StringPublicKey,
auctionSettings: IPartialCreateAuctionArgs,
): Promise<{
auction: PublicKey;
auction: StringPublicKey;
instructions: TransactionInstruction[];
signers: Keypair[];
}> {
@ -23,24 +25,24 @@ export async function makeAuction(
let signers: Keypair[] = [];
let instructions: TransactionInstruction[] = [];
const auctionKey: PublicKey = (
const auctionKey = (
await findProgramAddress(
[
Buffer.from(AUCTION_PREFIX),
PROGRAM_IDS.auction.toBuffer(),
vault.toBuffer(),
toPublicKey(PROGRAM_IDS.auction).toBuffer(),
toPublicKey(vault).toBuffer(),
],
PROGRAM_IDS.auction,
toPublicKey(PROGRAM_IDS.auction),
)
)[0];
const fullSettings = new CreateAuctionArgs({
...auctionSettings,
authority: wallet.publicKey,
authority: wallet.publicKey.toBase58(),
resource: vault,
});
createAuction(fullSettings, wallet.publicKey, instructions);
createAuction(fullSettings, wallet.publicKey.toBase58(), instructions);
return { instructions, signers, auction: auctionKey };
}

6
js/packages/web/src/actions/markItemsThatArentMineAsSold.ts
View File

@ -19,7 +19,9 @@ export async function markItemsThatArentMineAsSold(
const item = safetyDepositDrafts[i].metadata;
if (
!item.info.data.creators?.find(c => c.address.equals(wallet.publicKey)) &&
!item.info.data.creators?.find(
c => c.address === wallet.publicKey.toBase58(),
) &&
!item.info.primarySaleHappened
) {
console.log(
@ -29,7 +31,7 @@ export async function markItemsThatArentMineAsSold(
);
await updatePrimarySaleHappenedViaToken(
item.pubkey,
wallet.publicKey,
wallet.publicKey.toBase58(),
safetyDepositDrafts[i].holding,
markInstructions,
);

33
js/packages/web/src/actions/nft.tsx
View File

@ -11,6 +11,8 @@ import {
Data,
Creator,
findProgramAddress,
StringPublicKey,
toPublicKey,
} from '@oyster/common';
import React from 'react';
import { MintLayout, Token } from '@solana/spl-token';
@ -18,7 +20,6 @@ import { WalletAdapter } from '@solana/wallet-base';
import {
Keypair,
Connection,
PublicKey,
SystemProgram,
TransactionInstruction,
} from '@solana/web3.js';
@ -56,7 +57,7 @@ export const mintNFT = async (
},
maxSupply?: number,
): Promise<{
metadataAccount: PublicKey;
metadataAccount: StringPublicKey;
} | void> => {
if (!wallet?.publicKey) {
return;
@ -74,7 +75,7 @@ export const mintNFT = async (
...metadata.properties,
creators: metadata.creators?.map(creator => {
return {
address: creator.address.toBase58(),
address: creator.address,
share: creator.share,
};
}),
@ -103,7 +104,7 @@ export const mintNFT = async (
// twice post Arweave. We store in an account (payer) and use it post-Arweave to update MD with new link
// then give control back to the user.
// const payer = new Account();
const payerPublicKey = wallet.publicKey;
const payerPublicKey = wallet.publicKey.toBase58();
const instructions: TransactionInstruction[] = [...pushInstructions];
const signers: Keypair[] = [...pushSigners];
@ -114,17 +115,17 @@ export const mintNFT = async (
mintRent,
0,
// Some weird bug with phantom where it's public key doesnt mesh with data encode wellff
payerPublicKey,
payerPublicKey,
toPublicKey(payerPublicKey),
toPublicKey(payerPublicKey),
signers,
);
).toBase58();
const recipientKey: PublicKey = (
const recipientKey = (
await findProgramAddress(
[
wallet.publicKey.toBuffer(),
programIds().token.toBuffer(),
mintKey.toBuffer(),
toPublicKey(mintKey).toBuffer(),
],
programIds().associatedToken,
)
@ -132,10 +133,10 @@ export const mintNFT = async (
createAssociatedTokenAccountInstruction(
instructions,
recipientKey,
toPublicKey(recipientKey),
wallet.publicKey,
wallet.publicKey,
mintKey,
toPublicKey(mintKey),
);
const metadataAccount = await createMetadata(
@ -150,7 +151,7 @@ export const mintNFT = async (
mintKey,
payerPublicKey,
instructions,
wallet.publicKey,
wallet.publicKey.toBase58(),
);
// TODO: enable when using payer account to avoid 2nd popup
@ -185,7 +186,7 @@ export const mintNFT = async (
const tags = realFiles.reduce(
(acc: Record<string, Array<{ name: string; value: string }>>, f) => {
acc[f.name] = [{ name: 'mint', value: mintKey.toBase58() }];
acc[f.name] = [{ name: 'mint', value: mintKey }];
return acc;
},
{},
@ -237,9 +238,9 @@ export const mintNFT = async (
updateInstructions.push(
Token.createMintToInstruction(
TOKEN_PROGRAM_ID,
mintKey,
recipientKey,
payerPublicKey,
toPublicKey(mintKey),
toPublicKey(recipientKey),
toPublicKey(payerPublicKey),
[],
1,
),

8
js/packages/web/src/actions/saveAdmin.ts
View File

@ -25,8 +25,8 @@ export async function saveAdmin(
await setStore(
isPublic,
wallet.publicKey,
wallet.publicKey,
wallet.publicKey.toBase58(),
wallet.publicKey.toBase58(),
storeInstructions,
);
signers.push(storeSigners);
@ -40,8 +40,8 @@ export async function saveAdmin(
await setWhitelistedCreator(
wc.address,
wc.activated,
wallet.publicKey,
wallet.publicKey,
wallet.publicKey.toBase58(),
wallet.publicKey.toBase58(),
wcInstructions,
);
signers.push(wcSigners);

28
js/packages/web/src/actions/sendPlaceBid.ts
View File

@ -1,9 +1,4 @@
import {
Keypair,
Connection,
PublicKey,
TransactionInstruction,
} from '@solana/web3.js';
import { Keypair, Connection, TransactionInstruction } from '@solana/web3.js';
import {
actions,
sendTransactionWithRetry,
@ -14,6 +9,7 @@ import {
ensureWrappedAccount,
toLamports,
ParsedAccount,
toPublicKey,
} from '@oyster/common';
import { AccountLayout, MintInfo } from '@solana/spl-token';
@ -27,7 +23,7 @@ const { approve } = models;
export async function sendPlaceBid(
connection: Connection,
wallet: any,
bidderTokenAccount: PublicKey | undefined,
bidderTokenAccount: string | undefined,
auctionView: AuctionView,
accountsByMint: Map<string, TokenAccount>,
// value entered by the user adjust to decimals of the mint
@ -62,7 +58,7 @@ export async function sendPlaceBid(
export async function setupPlaceBid(
connection: Connection,
wallet: any,
bidderTokenAccount: PublicKey | undefined,
bidderTokenAccount: string | undefined,
auctionView: AuctionView,
accountsByMint: Map<string, TokenAccount>,
// value entered by the user adjust to decimals of the mint
@ -86,16 +82,16 @@ export async function setupPlaceBid(
) as ParsedAccount<MintInfo>;
let lamports = toLamports(amount, mint.info) + accountRentExempt;
let bidderPotTokenAccount: PublicKey;
let bidderPotTokenAccount: string;
if (!auctionView.myBidderPot) {
bidderPotTokenAccount = createTokenAccount(
instructions,
wallet.publicKey,
accountRentExempt,
auctionView.auction.info.tokenMint,
auctionView.auction.pubkey,
toPublicKey(auctionView.auction.info.tokenMint),
toPublicKey(auctionView.auction.pubkey),
signers,
);
).toBase58();
} else {
bidderPotTokenAccount = auctionView.myBidderPot?.info.bidderPot;
if (!auctionView.auction.info.ended()) {
@ -126,7 +122,7 @@ export async function setupPlaceBid(
const transferAuthority = approve(
instructions,
cleanupInstructions,
payingSolAccount,
toPublicKey(payingSolAccount),
wallet.publicKey,
lamports - accountRentExempt,
);
@ -135,12 +131,12 @@ export async function setupPlaceBid(
const bid = new BN(lamports - accountRentExempt);
await placeBid(
wallet.publicKey,
wallet.publicKey.toBase58(),
payingSolAccount,
bidderPotTokenAccount,
auctionView.auction.info.tokenMint,
transferAuthority.publicKey,
wallet.publicKey,
transferAuthority.publicKey.toBase58(),
wallet.publicKey.toBase58(),
auctionView.auctionManager.vault,
bid,
instructions,

156
js/packages/web/src/actions/sendRedeemBid.ts
View File

@ -1,9 +1,4 @@
import {
Keypair,
Connection,
PublicKey,
TransactionInstruction,
} from '@solana/web3.js';
import { Keypair, Connection, TransactionInstruction } from '@solana/web3.js';
import {
actions,
ParsedAccount,
@ -30,6 +25,8 @@ import {
getEditionMarkPda,
decodeEditionMarker,
BidStateType,
StringPublicKey,
toPublicKey,
} from '@oyster/common';
import { AccountLayout, MintLayout, Token } from '@solana/spl-token';
@ -90,7 +87,7 @@ export function eligibleForParticipationPrizeGivenWinningIndex(
export async function sendRedeemBid(
connection: Connection,
wallet: any,
payingAccount: PublicKey,
payingAccount: StringPublicKey,
auctionView: AuctionView,
accountsByMint: Map<string, TokenAccount>,
prizeTrackingTickets: Record<string, ParsedAccount<PrizeTrackingTicket>>,
@ -163,7 +160,7 @@ export async function sendRedeemBid(
auctionView,
mintRentExempt,
wallet,
wallet.publicKey,
wallet.publicKey.toBase58(),
safetyDeposit,
item,
signers,
@ -262,7 +259,7 @@ export async function sendRedeemBid(
accountRentExempt,
mintRentExempt,
wallet,
wallet.publicKey,
wallet.publicKey.toBase58(),
safetyDeposit,
auctionView.myBidRedemption,
auctionView.myBidderMetadata,
@ -273,7 +270,7 @@ export async function sendRedeemBid(
}
}
if (wallet.publicKey.equals(auctionView.auctionManager.authority)) {
if (wallet.publicKey.toBase58() === auctionView.auctionManager.authority) {
await claimUnusedPrizes(
connection,
wallet,
@ -316,17 +313,17 @@ async function setupRedeemInstructions(
);
if (!claimed && auctionView.myBidderMetadata) {
let newTokenAccount = accountsByMint.get(
safetyDeposit.info.tokenMint.toBase58(),
safetyDeposit.info.tokenMint,
)?.pubkey;
if (!newTokenAccount)
newTokenAccount = createTokenAccount(
winningPrizeInstructions,
wallet.publicKey,
accountRentExempt,
safetyDeposit.info.tokenMint,
toPublicKey(safetyDeposit.info.tokenMint),
wallet.publicKey,
winningPrizeSigner,
);
).toBase58();
await redeemBid(
auctionView.auctionManager.vault,
@ -335,7 +332,7 @@ async function setupRedeemInstructions(
safetyDeposit.pubkey,
auctionView.vault.info.fractionMint,
auctionView.myBidderMetadata.info.bidderPubkey,
wallet.publicKey,
wallet.publicKey.toBase58(),
undefined,
undefined,
false,
@ -345,7 +342,7 @@ async function setupRedeemInstructions(
const metadata = await getMetadata(safetyDeposit.info.tokenMint);
await updatePrimarySaleHappenedViaToken(
metadata,
wallet.publicKey,
wallet.publicKey.toBase58(),
newTokenAccount,
winningPrizeInstructions,
);
@ -375,17 +372,17 @@ async function setupRedeemFullRightsTransferInstructions(
);
if (!claimed && auctionView.myBidderMetadata) {
let newTokenAccount = accountsByMint.get(
safetyDeposit.info.tokenMint.toBase58(),
safetyDeposit.info.tokenMint,
)?.pubkey;
if (!newTokenAccount)
newTokenAccount = createTokenAccount(
winningPrizeInstructions,
wallet.publicKey,
accountRentExempt,
safetyDeposit.info.tokenMint,
toPublicKey(safetyDeposit.info.tokenMint),
wallet.publicKey,
winningPrizeSigner,
);
).toBase58();
await redeemFullRightsTransferBid(
auctionView.auctionManager.vault,
@ -394,10 +391,10 @@ async function setupRedeemFullRightsTransferInstructions(
safetyDeposit.pubkey,
auctionView.vault.info.fractionMint,
auctionView.myBidderMetadata.info.bidderPubkey,
wallet.publicKey,
wallet.publicKey.toBase58(),
winningPrizeInstructions,
item.metadata.pubkey,
wallet.publicKey,
wallet.publicKey.toBase58(),
);
const metadata = await getMetadata(safetyDeposit.info.tokenMint);
@ -412,11 +409,11 @@ async function setupRedeemFullRightsTransferInstructions(
async function createMintAndAccountWithOne(
wallet: any,
receiverWallet: PublicKey,
receiverWallet: StringPublicKey,
mintRent: any,
instructions: TransactionInstruction[],
signers: Keypair[],
): Promise<{ mint: PublicKey; account: PublicKey }> {
): Promise<{ mint: StringPublicKey; account: StringPublicKey }> {
const mint = createMint(
instructions,
wallet.publicKey,
@ -429,10 +426,10 @@ async function createMintAndAccountWithOne(
const PROGRAM_IDS = programIds();
const account: PublicKey = (
const account: StringPublicKey = (
await findProgramAddress(
[
receiverWallet.toBuffer(),
toPublicKey(receiverWallet).toBuffer(),
PROGRAM_IDS.token.toBuffer(),
mint.toBuffer(),
],
@ -442,9 +439,9 @@ async function createMintAndAccountWithOne(
createAssociatedTokenAccountInstruction(
instructions,
account,
toPublicKey(account),
wallet.publicKey,
receiverWallet,
toPublicKey(receiverWallet),
mint,
);
@ -452,14 +449,14 @@ async function createMintAndAccountWithOne(
Token.createMintToInstruction(
PROGRAM_IDS.token,
mint,
account,
toPublicKey(account),
wallet.publicKey,
[],
1,
),
);
return { mint, account };
return { mint: mint.toBase58(), account };
}
export async function setupRedeemPrintingV2Instructions(
@ -467,7 +464,7 @@ export async function setupRedeemPrintingV2Instructions(
auctionView: AuctionView,
mintRentExempt: number,
wallet: any,
receiverWallet: PublicKey,
receiverWallet: StringPublicKey,
safetyDeposit: ParsedAccount<SafetyDepositBox>,
item: AuctionViewItem,
signers: Array<Keypair[]>,
@ -486,8 +483,7 @@ export async function setupRedeemPrintingV2Instructions(
item.metadata.info.mint,
);
const myPrizeTrackingTicket =
prizeTrackingTickets[myPrizeTrackingTicketKey.toBase58()];
const myPrizeTrackingTicket = prizeTrackingTickets[myPrizeTrackingTicketKey];
// We are not entirely guaranteed this is right. Someone could be clicking at the same time. Contract will throw error if this
// is the case and they'll need to refresh to get tracking ticket which may not have existed when they first clicked.
const editionBase = myPrizeTrackingTicket
@ -530,7 +526,9 @@ export async function setupRedeemPrintingV2Instructions(
);
try {
const editionData = await connection.getAccountInfo(editionMarkPda);
const editionData = await connection.getAccountInfo(
toPublicKey(editionMarkPda),
);
if (editionData) {
const marker = decodeEditionMarker(editionData.data);
@ -550,7 +548,7 @@ export async function setupRedeemPrintingV2Instructions(
account,
safetyDeposit.pubkey,
receiverWallet,
wallet.publicKey,
wallet.publicKey.toBase58(),
item.metadata.pubkey,
me.pubkey,
item.metadata.info.mint,
@ -563,10 +561,10 @@ export async function setupRedeemPrintingV2Instructions(
const metadata = await getMetadata(mint);
if (wallet.publicKey.equals(receiverWallet)) {
if (wallet.publicKey.toBase58() === receiverWallet) {
await updatePrimarySaleHappenedViaToken(
metadata,
wallet.publicKey,
wallet.publicKey.toBase58(),
account,
myInstructions,
);
@ -600,8 +598,8 @@ async function deprecatedSetupRedeemPrintingV1Instructions(
const me = item.masterEdition as ParsedAccount<MasterEditionV1>;
const newTokenAccount = accountsByMint.get(me.info.printingMint.toBase58());
let newTokenAccountKey: PublicKey | undefined = newTokenAccount?.pubkey;
const newTokenAccount = accountsByMint.get(me.info.printingMint);
let newTokenAccountKey: StringPublicKey | undefined = newTokenAccount?.pubkey;
let newTokenAccountBalance: number = newTokenAccount
? newTokenAccount.info.amount.toNumber()
@ -626,10 +624,10 @@ async function deprecatedSetupRedeemPrintingV1Instructions(
winningPrizeInstructions,
wallet.publicKey,
accountRentExempt,
me.info.printingMint,
toPublicKey(me.info.printingMint),
wallet.publicKey,
winningPrizeSigner,
);
).toBase58();
await redeemBid(
auctionView.auctionManager.vault,
@ -638,7 +636,7 @@ async function deprecatedSetupRedeemPrintingV1Instructions(
safetyDeposit.pubkey,
auctionView.vault.info.fractionMint,
auctionView.myBidderMetadata.info.bidderPubkey,
wallet.publicKey,
wallet.publicKey.toBase58(),
item.masterEdition.pubkey,
reservationList,
true,
@ -669,14 +667,14 @@ async function deprecatedSetupRedeemPrintingV1Instructions(
async function deprecatedRedeemPrintingV1Token(
wallet: any,
updateAuth: PublicKey,
updateAuth: StringPublicKey,
item: AuctionViewItem,
newTokenAccount: PublicKey,
newTokenAccount: StringPublicKey,
mintRentExempt: number,
accountRentExempt: number,
signers: Keypair[][],
instructions: TransactionInstruction[][],
reservationList?: PublicKey,
reservationList?: StringPublicKey,
) {
if (!item.masterEdition) return;
let cashInLimitedPrizeAuthorizationTokenSigner: Keypair[] = [];
@ -693,12 +691,12 @@ async function deprecatedRedeemPrintingV1Token(
wallet.publicKey,
wallet.publicKey,
cashInLimitedPrizeAuthorizationTokenSigner,
);
).toBase58();
const newLimitedEdition = createTokenAccount(
cashInLimitedPrizeAuthorizationTokenInstruction,
wallet.publicKey,
accountRentExempt,
newLimitedEditionMint,
toPublicKey(newLimitedEditionMint),
wallet.publicKey,
cashInLimitedPrizeAuthorizationTokenSigner,
);
@ -706,7 +704,7 @@ async function deprecatedRedeemPrintingV1Token(
cashInLimitedPrizeAuthorizationTokenInstruction.push(
Token.createMintToInstruction(
programIds().token,
newLimitedEditionMint,
toPublicKey(newLimitedEditionMint),
newLimitedEdition,
wallet.publicKey,
[],
@ -717,7 +715,7 @@ async function deprecatedRedeemPrintingV1Token(
const burnAuthority = approve(
cashInLimitedPrizeAuthorizationTokenInstruction,
[],
newTokenAccount,
toPublicKey(newTokenAccount),
wallet.publicKey,
1,
);
@ -729,21 +727,21 @@ async function deprecatedRedeemPrintingV1Token(
await deprecatedMintNewEditionFromMasterEditionViaPrintingToken(
newLimitedEditionMint,
item.metadata.info.mint,
wallet.publicKey,
wallet.publicKey.toBase58(),
me.info.printingMint,
newTokenAccount,
burnAuthority.publicKey,
burnAuthority.publicKey.toBase58(),
updateAuth,
reservationList,
cashInLimitedPrizeAuthorizationTokenInstruction,
wallet.publicKey,
wallet.publicKey.toBase58(),
);
const metadata = await getMetadata(newLimitedEditionMint);
await updatePrimarySaleHappenedViaToken(
metadata,
wallet.publicKey,
newLimitedEdition,
wallet.publicKey.toBase58(),
newLimitedEdition.toBase58(),
cashInLimitedPrizeAuthorizationTokenInstruction,
);
}
@ -755,7 +753,7 @@ export async function setupRedeemParticipationInstructions(
accountRentExempt: number,
mintRentExempt: number,
wallet: any,
receiverWallet: PublicKey,
receiverWallet: StringPublicKey,
safetyDeposit: ParsedAccount<SafetyDepositBox>,
bidRedemption: ParsedAccount<BidRedemptionTicket> | undefined,
bid: ParsedAccount<BidderMetadata> | undefined,
@ -793,9 +791,7 @@ export async function setupRedeemParticipationInstructions(
? fixedPrice.toNumber()
: bid?.info.lastBid.toNumber() || 0;
let tokenAccount = accountsByMint.get(
auctionView.auction.info.tokenMint.toBase58(),
);
let tokenAccount = accountsByMint.get(auctionView.auction.info.tokenMint);
console.log('Have token account', tokenAccount);
if (!tokenAccount) {
@ -807,7 +803,7 @@ export async function setupRedeemParticipationInstructions(
if (allAccounts.value.length > 0) {
tokenAccount = TokenAccountParser(
allAccounts.value[0].pubkey,
allAccounts.value[0].pubkey.toBase58(),
allAccounts.value[0].account,
);
}
@ -833,14 +829,14 @@ export async function setupRedeemParticipationInstructions(
const transferAuthority = approve(
myInstructions,
cleanupInstructions,
payingSolAccount,
toPublicKey(payingSolAccount),
wallet.publicKey,
price,
);
mySigners.push(transferAuthority);
const winnerIndex = auctionView.auction.info.bidState.getWinnerIndex(
wallet.publicKey,
wallet.publicKey.toBase58(),
);
await redeemParticipationBidV3(
auctionView.vault.pubkey,
@ -848,11 +844,11 @@ export async function setupRedeemParticipationInstructions(
account,
safetyDeposit.pubkey,
receiverWallet,
wallet.publicKey,
wallet.publicKey.toBase58(),
item.metadata.pubkey,
me.pubkey,
item.metadata.info.mint,
transferAuthority.publicKey,
transferAuthority.publicKey.toBase58(),
auctionView.auctionManager.acceptPayment,
payingSolAccount,
mint,
@ -866,13 +862,13 @@ export async function setupRedeemParticipationInstructions(
signers.push(mySigners);
const metadata = await getMetadata(mint);
if (receiverWallet.equals(wallet.publicKey)) {
if (receiverWallet === wallet.publicKey.toBase58()) {
let updatePrimarySaleHappenedInstructions: TransactionInstruction[] = [];
let updatePrimarySaleHappenedSigners: Keypair[] = [];
await updatePrimarySaleHappenedViaToken(
metadata,
wallet.publicKey,
wallet.publicKey.toBase58(),
account,
updatePrimarySaleHappenedInstructions,
);
@ -880,7 +876,7 @@ export async function setupRedeemParticipationInstructions(
signers.push(updatePrimarySaleHappenedSigners);
}
} else {
console.log('Item is already claimed!', item.metadata.info.mint.toBase58());
console.log('Item is already claimed!', item.metadata.info.mint);
}
}
@ -909,16 +905,14 @@ async function deprecatedSetupRedeemParticipationInstructions(
return;
const updateAuth = item.metadata.info.updateAuthority;
let tokenAccount = accountsByMint.get(
auctionView.auction.info.tokenMint.toBase58(),
);
let tokenAccount = accountsByMint.get(auctionView.auction.info.tokenMint);
const mint = cache.get(auctionView.auction.info.tokenMint);
const participationBalance = await connection.getTokenAccountBalance(
participationState.printingAuthorizationTokenAccount,
toPublicKey(participationState.printingAuthorizationTokenAccount),
);
const tokenBalance = await connection.getTokenAccountBalance(
safetyDeposit.info.store,
toPublicKey(safetyDeposit.info.store),
);
if (
@ -932,10 +926,10 @@ async function deprecatedSetupRedeemParticipationInstructions(
fillParticipationStashInstructions,
wallet.publicKey,
accountRentExempt,
me?.info.oneTimePrintingAuthorizationMint,
auctionView.auctionManager.pubkey,
toPublicKey(me?.info.oneTimePrintingAuthorizationMint),
toPublicKey(auctionView.auctionManager.pubkey),
fillParticipationStashSigners,
);
).toBase58();
await deprecatedPopulateParticipationPrintingAccount(
auctionView.vault.pubkey,
@ -950,7 +944,7 @@ async function deprecatedSetupRedeemParticipationInstructions(
me.info.oneTimePrintingAuthorizationMint,
me.pubkey,
item.metadata.pubkey,
wallet.publicKey,
wallet.publicKey.toBase58(),
fillParticipationStashInstructions,
);
@ -958,12 +952,12 @@ async function deprecatedSetupRedeemParticipationInstructions(
instructions.push(fillParticipationStashInstructions);
}
let newTokenAccount: PublicKey | undefined = accountsByMint.get(
me.info.printingMint.toBase58(),
let newTokenAccount: StringPublicKey | undefined = accountsByMint.get(
me.info.printingMint,
)?.pubkey;
let newTokenBalance =
accountsByMint.get(me.info.printingMint.toBase58())?.info.amount || 0;
accountsByMint.get(me.info.printingMint)?.info.amount || 0;
if (
me &&
@ -991,10 +985,10 @@ async function deprecatedSetupRedeemParticipationInstructions(
newTokenAccountInstructions,
wallet.publicKey,
accountRentExempt,
me.info.printingMint,
toPublicKey(me.info.printingMint),
wallet.publicKey,
newTokenAccountSigner,
);
).toBase58();
}
signers.push(winningPrizeSigner);
@ -1017,7 +1011,7 @@ async function deprecatedSetupRedeemParticipationInstructions(
const transferAuthority = approve(
winningPrizeInstructions,
cleanupInstructions,
payingSolAccount,
toPublicKey(payingSolAccount),
wallet.publicKey,
price,
);
@ -1030,10 +1024,10 @@ async function deprecatedSetupRedeemParticipationInstructions(
newTokenAccount,
safetyDeposit.pubkey,
auctionView.myBidderMetadata.info.bidderPubkey,
wallet.publicKey,
wallet.publicKey.toBase58(),
winningPrizeInstructions,
participationState.printingAuthorizationTokenAccount,
transferAuthority.publicKey,
transferAuthority.publicKey.toBase58(),
auctionView.auctionManager.acceptPayment,
payingSolAccount,
);

15
js/packages/web/src/actions/sendSignMetadata.ts
View File

@ -1,20 +1,19 @@
import { Keypair, Connection, TransactionInstruction } from '@solana/web3.js';
import {
Keypair,
Connection,
TransactionInstruction,
PublicKey,
} from '@solana/web3.js';
import { sendTransactionWithRetry, signMetadata } from '@oyster/common';
sendTransactionWithRetry,
signMetadata,
StringPublicKey,
} from '@oyster/common';
export async function sendSignMetadata(
connection: Connection,
wallet: any,
metadata: PublicKey,
metadata: StringPublicKey,
) {
let signers: Keypair[] = [];
let instructions: TransactionInstruction[] = [];
await signMetadata(metadata, wallet.publicKey, instructions);
await signMetadata(metadata, wallet.publicKey.toBase58(), instructions);
await sendTransactionWithRetry(
connection,

18
js/packages/web/src/actions/setVaultAndAuctionAuthorities.ts
View File

@ -1,12 +1,16 @@
import { Keypair, PublicKey, TransactionInstruction } from '@solana/web3.js';
import { setAuctionAuthority, setVaultAuthority } from '@oyster/common';
import { Keypair, TransactionInstruction } from '@solana/web3.js';
import {
setAuctionAuthority,
setVaultAuthority,
StringPublicKey,
} from '@oyster/common';
// This command sets the authorities on the vault and auction to be the newly created auction manager.
export async function setVaultAndAuctionAuthorities(
wallet: any,
vault: PublicKey,
auction: PublicKey,
auctionManager: PublicKey,
vault: StringPublicKey,
auction: StringPublicKey,
auctionManager: StringPublicKey,
): Promise<{
instructions: TransactionInstruction[];
signers: Keypair[];
@ -16,13 +20,13 @@ export async function setVaultAndAuctionAuthorities(
await setAuctionAuthority(
auction,
wallet.publicKey,
wallet.publicKey.toBase58(),
auctionManager,
instructions,
);
await setVaultAuthority(
vault,
wallet.publicKey,
wallet.publicKey.toBase58(),
auctionManager,
instructions,
);

27
js/packages/web/src/actions/settle.ts
View File

@ -15,6 +15,7 @@ import {
findProgramAddress,
AuctionState,
TokenAccount,
toPublicKey,
} from '@oyster/common';
import { AuctionView } from '../hooks';
@ -32,7 +33,7 @@ export async function settle(
wallet: any,
auctionView: AuctionView,
bidsToClaim: ParsedAccount<BidderPot>[],
payingAccount: PublicKey | undefined,
payingAccount: string | undefined,
accountsByMint: Map<string, TokenAccount>,
) {
if (
@ -96,9 +97,7 @@ async function emptyPaymentAccountForAllTokens(
const creators = item.metadata.info.data.creators;
const edgeCaseWhereCreatorIsAuctioneer = !!creators
?.map(c => c.address)
.find(
c => c.toBase58() === auctionView.auctionManager.authority.toBase58(),
);
.find(c => c === auctionView.auctionManager.authority);
const addresses = [
...(creators ? creators.map(c => c.address) : []),
@ -109,7 +108,7 @@ async function emptyPaymentAccountForAllTokens(
const ata = (
await findProgramAddress(
[
addresses[k].toBuffer(),
toPublicKey(addresses[k]).toBuffer(),
PROGRAM_IDS.token.toBuffer(),
QUOTE_MINT.toBuffer(),
],
@ -117,23 +116,21 @@ async function emptyPaymentAccountForAllTokens(
)
)[0];
const existingAta = await connection.getAccountInfo(ata);
const existingAta = await connection.getAccountInfo(toPublicKey(ata));
console.log('Existing ata?', existingAta);
if (!existingAta && !ataLookup[ata.toBase58()])
if (!existingAta && !ataLookup[ata])
createAssociatedTokenAccountInstruction(
settleInstructions,
ata,
toPublicKey(ata),
wallet.publicKey,
addresses[k],
toPublicKey(addresses[k]),
QUOTE_MINT,
);
ataLookup[ata.toBase58()] = true;
ataLookup[ata] = true;
const creatorIndex = creators
? creators
.map(c => c.address.toBase58())
.indexOf(addresses[k].toBase58())
? creators.map(c => c.address).indexOf(addresses[k])
: null;
await emptyPaymentAccount(
@ -145,7 +142,7 @@ async function emptyPaymentAccountForAllTokens(
item.safetyDeposit.pubkey,
item.safetyDeposit.info.vault,
auctionView.auction.pubkey,
wallet.publicKey,
wallet.publicKey.toBase58(),
addresses[k],
item === auctionView.participationItem ? null : i,
item === auctionView.participationItem ? null : j,
@ -233,7 +230,7 @@ async function claimAllBids(
// That's what this loop is building.
for (let i = 0; i < bids.length; i++) {
const bid = bids[i];
console.log('Claiming', bid.info.bidderAct.toBase58());
console.log('Claiming', bid.info.bidderAct);
await claimBid(
auctionView.auctionManager.acceptPayment,
bid.info.bidderAct,

17
js/packages/web/src/actions/unwindVault.ts
View File

@ -10,6 +10,7 @@ import {
sendTransactionsWithManualRetry,
decodeExternalPriceAccount,
findProgramAddress,
toPublicKey,
} from '@oyster/common';
import BN from 'bn.js';
@ -38,7 +39,7 @@ export async function unwindVault(
if (vault.info.state === VaultState.Inactive) {
console.log('Vault is inactive, combining');
const epa = await connection.getAccountInfo(
vault.info.pricingLookupAddress,
toPublicKey(vault.info.pricingLookupAddress),
);
if (epa) {
const decoded = decodeExternalPriceAccount(epa.data);
@ -60,7 +61,7 @@ export async function unwindVault(
}
}
const vaultKey = vault.pubkey.toBase58();
const vaultKey = vault.pubkey;
let boxes: ParsedAccount<SafetyDepositBox>[] = [];
let box = safetyDepositBoxesByVaultAndIndex[vaultKey + '-0'];
@ -81,24 +82,26 @@ export async function unwindVault(
[
wallet.publicKey.toBuffer(),
PROGRAM_IDS.token.toBuffer(),
nft.info.tokenMint.toBuffer(),
toPublicKey(nft.info.tokenMint).toBuffer(),
],
PROGRAM_IDS.associatedToken,
)
)[0];
const existingAta = await connection.getAccountInfo(ata);
const existingAta = await connection.getAccountInfo(toPublicKey(ata));
console.log('Existing ata?', existingAta);
if (!existingAta)
createAssociatedTokenAccountInstruction(
currInstructions,
ata,
toPublicKey(ata),
wallet.publicKey,
wallet.publicKey,
nft.info.tokenMint,
toPublicKey(nft.info.tokenMint),
);
const value = await connection.getTokenAccountBalance(nft.info.store);
const value = await connection.getTokenAccountBalance(
toPublicKey(nft.info.store),
);
await withdrawTokenFromSafetyDepositBox(
new BN(value.value.uiAmount || 1),
ata,

4
js/packages/web/src/components/ArtCard/index.tsx
View File

@ -1,6 +1,6 @@
import React from 'react';
import { Card, CardProps, Button, Badge } from 'antd';
import { MetadataCategory } from '@oyster/common';
import { MetadataCategory, StringPublicKey } from '@oyster/common';
import { ArtContent } from './../ArtContent';
import { useArt } from '../../hooks';
import { PublicKey } from '@solana/web3.js';
@ -10,7 +10,7 @@ import { MetaAvatar } from '../MetaAvatar';
const { Meta } = Card;
export interface ArtCardProps extends CardProps {
pubkey?: PublicKey;
pubkey?: StringPublicKey;
image?: string;
animationURL?: string;

12
js/packages/web/src/components/AuctionCard/index.tsx
View File

@ -81,7 +81,7 @@ async function calculateTotalCostOfRedeemingOtherPeoplesBids(
if (!winner) {
break;
} else {
const bid = bids.find(b => b.info.bidderPubkey.equals(winner));
const bid = bids.find(b => b.info.bidderPubkey === winner);
if (bid) {
for (
let j = 0;
@ -162,7 +162,7 @@ function useAuctionExtended(
auctionProgramId: PROGRAM_IDS.auction,
resource: auctionView.vault.pubkey,
});
const extendedValue = auctionDataExtended[extendedKey.toBase58()];
const extendedValue = auctionDataExtended[extendedKey];
if (extendedValue) setAuctionExtended(extendedValue);
}
};
@ -239,7 +239,7 @@ export const AuctionCard = ({
const gapBidInvalid = useGapTickCheck(value, gapTick, gapTime, auctionView);
const isAuctionManagerAuthorityNotWalletOwner =
auctionView.auctionManager.authority.toBase58() !=
auctionView.auctionManager.authority !==
wallet?.publicKey?.toBase58();
const isAuctionNotStarted =
@ -272,7 +272,7 @@ export const AuctionCard = ({
setLoading(true);
setShowRedemptionIssue(false);
if (
wallet?.publicKey?.equals(auctionView.auctionManager.authority)
wallet?.publicKey?.toBase58() === auctionView.auctionManager.authority
) {
const totalCost =
await calculateTotalCostOfRedeemingOtherPeoplesBids(
@ -325,7 +325,7 @@ export const AuctionCard = ({
) : (
`${
wallet?.publicKey &&
auctionView.auctionManager.authority.equals(wallet.publicKey)
auctionView.auctionManager.authority === wallet.publicKey.toBase58()
? 'Reclaim Items'
: 'Refund bid'
}`
@ -515,7 +515,7 @@ export const AuctionCard = ({
width: '100%',
background: '#242424',
borderRadius: 14,
color: 'rgba(0, 0, 0, 0.5);',
color: 'rgba(0, 0, 0, 0.5)',
}}
>
<InputNumber

59
js/packages/web/src/components/Notifications/index.tsx
View File

@ -5,7 +5,10 @@ import {
SyncOutlined,
} from '@ant-design/icons';
import {
findProgramAddress,
programIds,
StringPublicKey,
toPublicKey,
useConnection,
useUserAccounts,
useWallet,
@ -97,11 +100,11 @@ function RunAction({
export async function getPersonalEscrowAta(
wallet: WalletAdapter | undefined,
): Promise<PublicKey | undefined> {
): Promise<StringPublicKey | undefined> {
const PROGRAM_IDS = programIds();
if (!wallet?.publicKey) return undefined;
return (
await PublicKey.findProgramAddress(
await findProgramAddress(
[
wallet.publicKey.toBuffer(),
PROGRAM_IDS.token.toBuffer(),
@ -126,7 +129,7 @@ export function useCollapseWrappedSol({
const ata = await getPersonalEscrowAta(wallet);
if (ata) {
try {
const balance = await connection.getTokenAccountBalance(ata);
const balance = await connection.getTokenAccountBalance(toPublicKey(ata));
if ((balance && balance.value.uiAmount) || 0 > 0) {
setShowNotification(true);
@ -149,7 +152,7 @@ export function useCollapseWrappedSol({
try {
const ata = await getPersonalEscrowAta(wallet);
if (ata) {
const data = await connection.getAccountInfo(ata);
const data = await connection.getAccountInfo(toPublicKey(ata));
if (data?.data.length || 0 > 0)
await closePersonalEscrow(connection, wallet, ata);
}
@ -174,7 +177,7 @@ export function useSettlementAuctions({
notifications: NotificationCard[];
}) {
const { accountByMint } = useUserAccounts();
const walletPubkey = wallet?.publicKey;
const walletPubkey = wallet?.publicKey?.toBase58();
const { bidderPotsByAuctionAndBidder } = useMeta();
const auctionsNeedingSettling = useAuctions(AuctionViewState.Ended);
@ -186,7 +189,7 @@ export function useSettlementAuctions({
.filter(
a =>
walletPubkey &&
a.auctionManager.authority.equals(walletPubkey) &&
a.auctionManager.authority === walletPubkey &&
a.auction.info.ended(),
)
.sort(
@ -196,11 +199,11 @@ export function useSettlementAuctions({
);
for (let i = 0; i < nextBatch.length; i++) {
const av = nextBatch[i];
if (!CALLING_MUTEX[av.auctionManager.pubkey.toBase58()]) {
CALLING_MUTEX[av.auctionManager.pubkey.toBase58()] = true;
if (!CALLING_MUTEX[av.auctionManager.pubkey]) {
CALLING_MUTEX[av.auctionManager.pubkey] = true;
try {
const balance = await connection.getTokenAccountBalance(
av.auctionManager.acceptPayment,
toPublicKey(av.auctionManager.acceptPayment),
);
if (
((balance.value.uiAmount || 0) === 0 &&
@ -211,7 +214,7 @@ export function useSettlementAuctions({
) {
setValidDiscoveredEndedAuctions(old => ({
...old,
[av.auctionManager.pubkey.toBase58()]:
[av.auctionManager.pubkey]:
balance.value.uiAmount || 0,
}));
}
@ -226,26 +229,26 @@ export function useSettlementAuctions({
Object.keys(validDiscoveredEndedAuctions).forEach(auctionViewKey => {
const auctionView = auctionsNeedingSettling.find(
a => a.auctionManager.pubkey.toBase58() === auctionViewKey,
a => a.auctionManager.pubkey === auctionViewKey,
);
if (!auctionView) return;
const winners = [...auctionView.auction.info.bidState.bids]
.reverse()
.slice(0, auctionView.auctionManager.numWinners.toNumber())
.reduce((acc: Record<string, boolean>, r) => {
acc[r.key.toBase58()] = true;
acc[r.key] = true;
return acc;
}, {});
const myPayingAccount = accountByMint.get(
auctionView.auction.info.tokenMint.toBase58(),
auctionView.auction.info.tokenMint,
);
const auctionKey = auctionView.auction.pubkey.toBase58();
const auctionKey = auctionView.auction.pubkey;
const bidsToClaim = Object.values(bidderPotsByAuctionAndBidder).filter(
b =>
winners[b.info.bidderAct.toBase58()] &&
winners[b.info.bidderAct] &&
!b.info.emptied &&
b.info.auctionAct.toBase58() === auctionKey,
b.info.auctionAct === auctionKey,
);
if (bidsToClaim.length || validDiscoveredEndedAuctions[auctionViewKey] > 0)
notifications.push({
@ -312,7 +315,7 @@ export function Notifications() {
() =>
Object.values(vaults).filter(
v =>
v.info.authority.toBase58() === walletPubkey &&
v.info.authority === walletPubkey &&
v.info.state !== VaultState.Deactivated &&
v.info.tokenTypeCount > 0,
),
@ -321,7 +324,7 @@ export function Notifications() {
vaultsNeedUnwinding.forEach(v => {
notifications.push({
id: v.pubkey.toBase58(),
id: v.pubkey,
title: 'You have items locked in a defective auction!',
description: (
<span>
@ -347,10 +350,10 @@ export function Notifications() {
});
possiblyBrokenAuctionManagerSetups
.filter(v => v.auctionManager.authority.toBase58() === walletPubkey)
.filter(v => v.auctionManager.authority === walletPubkey)
.forEach(v => {
notifications.push({
id: v.auctionManager.pubkey.toBase58(),
id: v.auctionManager.pubkey,
title: 'You have items locked in a defective auction!',
description: (
<span>
@ -380,11 +383,11 @@ export function Notifications() {
metadata.filter(m => {
return (
m.info.data.creators &&
(whitelistedCreatorsByCreator[m.info.updateAuthority.toBase58()]?.info
(whitelistedCreatorsByCreator[m.info.updateAuthority]?.info
?.activated ||
store?.info.public) &&
m.info.data.creators.find(
c => c.address.toBase58() === walletPubkey && !c.verified,
c => c.address === walletPubkey && !c.verified,
)
);
}),
@ -393,14 +396,14 @@ export function Notifications() {
metaNeedsApproving.forEach(m => {
notifications.push({
id: m.pubkey.toBase58(),
id: m.pubkey,
title: 'You have a new artwork to approve!',
description: (
<span>
{whitelistedCreatorsByCreator[m.info.updateAuthority.toBase58()]?.info
?.name || m.pubkey.toBase58()}{' '}
{whitelistedCreatorsByCreator[m.info.updateAuthority]?.info
?.name || m.pubkey}{' '}
wants you to approve that you helped create their art{' '}
<Link to={`/art/${m.pubkey.toBase58()}`}>here.</Link>
<Link to={`/art/${m.pubkey}`}>here.</Link>
</span>
),
action: async () => {
@ -416,10 +419,10 @@ export function Notifications() {
});
upcomingAuctions
.filter(v => v.auctionManager.authority.toBase58() === walletPubkey)
.filter(v => v.auctionManager.authority === walletPubkey)
.forEach(v => {
notifications.push({
id: v.auctionManager.pubkey.toBase58(),
id: v.auctionManager.pubkey,
title: 'You have an auction which is not started yet!',
description: <span>You can activate it now if you wish.</span>,
action: async () => {

2
js/packages/web/src/components/PreSaleBanner/index.tsx
View File

@ -43,7 +43,7 @@ export const PreSaleBanner = ({ auction }: IPreSaleBanner) => {
hideDefaultAction={true}
action={
<>
<Link to={`/auction/${auction.auction.pubkey.toBase58()}`}>
<Link to={`/auction/${auction.auction.pubkey}`}>
<Button
type="primary"
size="large"

4
js/packages/web/src/components/UserSearch/index.tsx
View File

@ -77,8 +77,8 @@ export const UserSearch = (props: { setCreators: Function }) => {
const items = Object.values(whitelistedCreatorsByCreator)
.filter(c => c.info.activated)
.map(a => ({
label: a.info.name || shortenAddress(a.info.address.toBase58()),
value: a.info.address.toBase58(),
label: a.info.name || shortenAddress(a.info.address),
value: a.info.address,
}));
return items;

2
js/packages/web/src/contexts/meta/isMetadataPartOfStore.ts
View File

@ -21,6 +21,6 @@ export const isMetadataPartOfStore = (
c =>
c.verified &&
(store.info.public ||
whitelistedCreatorsByCreator[c.address.toBase58()]?.info?.activated),
whitelistedCreatorsByCreator[c.address]?.info?.activated),
);
};

213
js/packages/web/src/contexts/meta/loadAccounts.ts
View File

@ -2,9 +2,11 @@ import {
AUCTION_ID,
METADATA_PROGRAM_ID,
METAPLEX_ID,
StringPublicKey,
toPublicKey,
VAULT_ID,
} from '@oyster/common/dist/lib/utils/ids';
import { Connection, PublicKey } from '@solana/web3.js';
import { AccountInfo, Connection, PublicKey } from '@solana/web3.js';
import { AccountAndPubkey, MetaState, ProcessAccountsFunc } from './types';
import { isMetadataPartOfStore } from './isMetadataPartOfStore';
import { processAuctions } from './processAuctions';
@ -29,6 +31,60 @@ import {
MetaplexKey,
} from '../../models/metaplex';
async function getProgramAccounts(
connection: Connection,
programId: StringPublicKey,
configOrCommitment?: any,
): Promise<Array<AccountAndPubkey>> {
const extra: any = {};
let commitment;
let encoding;
if (configOrCommitment) {
if (typeof configOrCommitment === 'string') {
commitment = configOrCommitment;
} else {
commitment = configOrCommitment.commitment;
encoding = configOrCommitment.encoding;
if (configOrCommitment.dataSlice) {
extra.dataSlice = configOrCommitment.dataSlice;
}
if (configOrCommitment.filters) {
extra.filters = configOrCommitment.filters;
}
}
}
const args = connection._buildArgs([programId], commitment, 'base64', extra);
const unsafeRes = await (connection as any)._rpcRequest(
'getProgramAccounts',
args,
);
const data = (
unsafeRes.result as Array<{
account: AccountInfo<[string, string]>;
pubkey: string;
}>
).map(item => {
return {
account: {
// TODO: possible delay parsing could be added here
data: Buffer.from(item.account.data[0], 'base64'),
executable: item.account.executable,
lamports: item.account.lamports,
// TODO: maybe we can do it in lazy way? or just use string
owner: item.account.owner,
} as AccountInfo<Buffer>,
pubkey: item.pubkey,
};
});
return data;
}
export const loadAccounts = async (connection: Connection, all: boolean) => {
const tempCache: MetaState = {
metadata: [],
@ -65,71 +121,80 @@ export const loadAccounts = async (connection: Connection, all: boolean) => {
const additionalPromises: Promise<void>[] = [];
const IS_BIG_STORE =
process.env.NEXT_PUBLIC_BIG_STORE?.toLowerCase() === 'true';
console.log(`Is big store: ${IS_BIG_STORE}`);
const promises = [
connection.getProgramAccounts(VAULT_ID).then(forEach(processVaultData)),
connection.getProgramAccounts(AUCTION_ID).then(forEach(processAuctions)),
getProgramAccounts(connection, VAULT_ID).then(forEach(processVaultData)),
getProgramAccounts(connection, AUCTION_ID).then(forEach(processAuctions)),
,
connection
.getProgramAccounts(METAPLEX_ID)
.then(forEach(processMetaplexAccounts)),
connection
.getProgramAccounts(METAPLEX_ID, {
filters: [
{
dataSize: MAX_WHITELISTED_CREATOR_SIZE,
},
],
})
.then(async creators => {
await forEach(processMetaplexAccounts)(creators);
getProgramAccounts(connection, METAPLEX_ID).then(
forEach(processMetaplexAccounts),
),
IS_BIG_STORE
? getProgramAccounts(connection, METADATA_PROGRAM_ID).then(
forEach(processMetaData),
)
: undefined,
getProgramAccounts(connection, METAPLEX_ID, {
filters: [
{
dataSize: MAX_WHITELISTED_CREATOR_SIZE,
},
],
}).then(async creators => {
const result = await forEach(processMetaplexAccounts)(creators);
const whitelistedCreators = Object.values(
tempCache.whitelistedCreatorsByCreator,
if (IS_BIG_STORE) {
return result;
}
const whitelistedCreators = Object.values(
tempCache.whitelistedCreatorsByCreator,
);
if (whitelistedCreators.length > 3) {
console.log(' too many creators, pulling all nfts in one go');
additionalPromises.push(
getProgramAccounts(connection, METADATA_PROGRAM_ID).then(
forEach(processMetaData),
),
);
} else {
console.log('pulling optimized nfts');
if (whitelistedCreators.length > 3) {
console.log(' too many creators, pulling all nfts in one go');
additionalPromises.push(
connection
.getProgramAccounts(METADATA_PROGRAM_ID)
.then(forEach(processMetaData)),
);
} else {
console.log('pulling optimized nfts');
for (let i = 0; i < MAX_CREATOR_LIMIT; i++) {
for (let j = 0; j < whitelistedCreators.length; j++) {
additionalPromises.push(
connection
.getProgramAccounts(METADATA_PROGRAM_ID, {
filters: [
{
memcmp: {
offset:
1 + // key
32 + // update auth
32 + // mint
4 + // name string length
MAX_NAME_LENGTH + // name
4 + // uri string length
MAX_URI_LENGTH + // uri
4 + // symbol string length
MAX_SYMBOL_LENGTH + // symbol
2 + // seller fee basis points
1 + // whether or not there is a creators vec
4 + // creators vec length
i * MAX_CREATOR_LEN,
bytes: whitelistedCreators[j].info.address.toBase58(),
},
},
],
})
.then(forEach(processMetaData)),
);
}
for (let i = 0; i < MAX_CREATOR_LIMIT; i++) {
for (let j = 0; j < whitelistedCreators.length; j++) {
additionalPromises.push(
getProgramAccounts(connection, METADATA_PROGRAM_ID, {
filters: [
{
memcmp: {
offset:
1 + // key
32 + // update auth
32 + // mint
4 + // name string length
MAX_NAME_LENGTH + // name
4 + // uri string length
MAX_URI_LENGTH + // uri
4 + // symbol string length
MAX_SYMBOL_LENGTH + // symbol
2 + // seller fee basis points
1 + // whether or not there is a creators vec
4 + // creators vec length
i * MAX_CREATOR_LEN,
bytes: whitelistedCreators[j].info.address,
},
},
],
}).then(forEach(processMetaData)),
);
}
}
}),
}
}),
];
await Promise.all(promises);
await Promise.all(additionalPromises);
@ -143,22 +208,24 @@ export const loadAccounts = async (connection: Connection, all: boolean) => {
const editionPromises = [];
for (let i = 0; i < tempCache.metadata.length; i++) {
let edition: PublicKey;
let edition: StringPublicKey;
if (tempCache.metadata[i].info.editionNonce != null) {
edition = await PublicKey.createProgramAddress(
[
Buffer.from(METADATA_PREFIX),
METADATA_PROGRAM_ID.toBuffer(),
tempCache.metadata[i].info.mint.toBuffer(),
new Uint8Array([tempCache.metadata[i].info.editionNonce || 0]),
],
METADATA_PROGRAM_ID,
);
edition = (
await PublicKey.createProgramAddress(
[
Buffer.from(METADATA_PREFIX),
toPublicKey(METADATA_PROGRAM_ID).toBuffer(),
toPublicKey(tempCache.metadata[i].info.mint).toBuffer(),
new Uint8Array([tempCache.metadata[i].info.editionNonce || 0]),
],
toPublicKey(METADATA_PROGRAM_ID),
)
).toBase58();
} else {
edition = await getEdition(tempCache.metadata[i].info.mint);
}
setOf100MetadataEditionKeys.push(edition.toBase58());
setOf100MetadataEditionKeys.push(edition);
if (setOf100MetadataEditionKeys.length >= 100) {
editionPromises.push(
@ -178,7 +245,7 @@ export const loadAccounts = async (connection: Connection, all: boolean) => {
for (let j = 0; j < returnedAccounts.array.length; j++) {
processMetaData(
{
pubkey: new PublicKey(returnedAccounts.keys[j]),
pubkey: returnedAccounts.keys[j],
account: returnedAccounts.array[j],
},
updateTemp,
@ -220,7 +287,7 @@ export const metadataByMintUpdater = async (
state: MetaState,
all: boolean,
) => {
const key = metadata.info.mint.toBase58();
const key = metadata.info.mint;
if (
isMetadataPartOfStore(
metadata,
@ -230,7 +297,7 @@ export const metadataByMintUpdater = async (
)
) {
await metadata.info.init();
const masterEditionKey = metadata.info?.masterEdition?.toBase58();
const masterEditionKey = metadata.info?.masterEdition;
if (masterEditionKey) {
state.metadataByMasterEdition[masterEditionKey] = metadata;
}

9
js/packages/web/src/contexts/meta/meta.tsx
View File

@ -6,6 +6,7 @@ import {
METAPLEX_ID,
VAULT_ID,
METADATA_PROGRAM_ID,
toPublicKey,
} from '@oyster/common';
import React, {
useCallback,
@ -135,22 +136,22 @@ export function MetaProvider({ children = null as any }) {
}
const vaultSubId = connection.onProgramAccountChange(
VAULT_ID,
toPublicKey(VAULT_ID),
onChangeAccount(processVaultData, updateStateValue, all),
);
const auctionSubId = connection.onProgramAccountChange(
AUCTION_ID,
toPublicKey(AUCTION_ID),
onChangeAccount(processAuctions, updateStateValue, all),
);
const metaplexSubId = connection.onProgramAccountChange(
METAPLEX_ID,
toPublicKey(METAPLEX_ID),
onChangeAccount(processMetaplexAccounts, updateStateValue, all),
);
const metaSubId = connection.onProgramAccountChange(
METADATA_PROGRAM_ID,
toPublicKey(METADATA_PROGRAM_ID),
onChangeAccount(processMetaData, async (prop, key, value) => {
if (prop === 'metadataByMint') {
const nextState = await metadataByMintUpdater(value, state, all);

5
js/packages/web/src/contexts/meta/onChangeAccount.ts
View File

@ -1,7 +1,6 @@
import {
KeyedAccountInfo,
ProgramAccountChangeCallback,
PublicKey,
} from '@solana/web3.js';
import { ProcessAccountsFunc, UpdateStateValueFunc } from './types';
@ -25,6 +24,6 @@ export const onChangeAccount =
const pubkeyByAccountInfo = (info: KeyedAccountInfo) => {
return typeof info.accountId === 'string'
? new PublicKey(info.accountId as unknown as string)
: info.accountId;
? info.accountId
: info.accountId.toBase58();
};

16
js/packages/web/src/contexts/meta/processAuctions.ts
View File

@ -12,8 +12,8 @@ import {
AuctionDataExtended,
MAX_AUCTION_DATA_EXTENDED_SIZE,
AuctionDataExtendedParser,
AUCTION_ID,
} from '@oyster/common';
import { AUCTION_ID } from '@oyster/common/dist/lib/utils/ids';
import { CheckAccountFunc, ProcessAccountsFunc } from './types';
export const processAuctions: ProcessAccountsFunc = (
@ -29,7 +29,7 @@ export const processAuctions: ProcessAccountsFunc = (
AuctionParser,
false,
) as ParsedAccount<AuctionData>;
setter('auctions', pubkey.toBase58(), parsedAccount);
setter('auctions', pubkey, parsedAccount);
} catch (e) {
// ignore errors
// add type as first byte for easier deserialization
@ -43,7 +43,7 @@ export const processAuctions: ProcessAccountsFunc = (
AuctionDataExtendedParser,
false,
) as ParsedAccount<AuctionDataExtended>;
setter('auctionDataExtended', pubkey.toBase58(), parsedAccount);
setter('auctionDataExtended', pubkey, parsedAccount);
}
} catch {
// ignore errors
@ -60,9 +60,9 @@ export const processAuctions: ProcessAccountsFunc = (
) as ParsedAccount<BidderMetadata>;
setter(
'bidderMetadataByAuctionAndBidder',
parsedAccount.info.auctionPubkey.toBase58() +
parsedAccount.info.auctionPubkey +
'-' +
parsedAccount.info.bidderPubkey.toBase58(),
parsedAccount.info.bidderPubkey,
parsedAccount,
);
}
@ -81,9 +81,7 @@ export const processAuctions: ProcessAccountsFunc = (
) as ParsedAccount<BidderPot>;
setter(
'bidderPotsByAuctionAndBidder',
parsedAccount.info.auctionAct.toBase58() +
'-' +
parsedAccount.info.bidderAct.toBase58(),
parsedAccount.info.auctionAct + '-' + parsedAccount.info.bidderAct,
parsedAccount,
);
}
@ -94,7 +92,7 @@ export const processAuctions: ProcessAccountsFunc = (
};
const isAuctionAccount: CheckAccountFunc = account =>
account.owner.equals(AUCTION_ID);
(account.owner as unknown as any) === AUCTION_ID;
const isExtendedAuctionAccount: CheckAccountFunc = account =>
account.data.length === MAX_AUCTION_DATA_EXTENDED_SIZE;

21
js/packages/web/src/contexts/meta/processMetaData.ts
View File

@ -7,9 +7,9 @@ import {
Edition,
MasterEditionV1,
MasterEditionV2,
MetadataKey,
METADATA_PROGRAM_ID,
} from '@oyster/common';
import { MetadataKey } from '@oyster/common/dist/lib/actions/metadata';
import { METADATA_PROGRAM_ID } from '@oyster/common/dist/lib/utils/ids';
import { AccountInfo } from '@solana/web3.js';
import { ProcessAccountsFunc } from './types';
import { isValidHttpUrl } from '../../utils/isValidHttpUrl';
@ -33,7 +33,7 @@ export const processMetaData: ProcessAccountsFunc = (
account,
info: metadata,
};
setter('metadataByMint', metadata.mint.toBase58(), parsedAccount);
setter('metadataByMint', metadata.mint, parsedAccount);
}
}
@ -44,7 +44,7 @@ export const processMetaData: ProcessAccountsFunc = (
account,
info: edition,
};
setter('editions', pubkey.toBase58(), parsedAccount);
setter('editions', pubkey, parsedAccount);
}
if (isMasterEditionAccount(account)) {
@ -56,17 +56,17 @@ export const processMetaData: ProcessAccountsFunc = (
account,
info: masterEdition,
};
setter('masterEditions', pubkey.toBase58(), parsedAccount);
setter('masterEditions', pubkey, parsedAccount);
setter(
'masterEditionsByPrintingMint',
masterEdition.printingMint.toBase58(),
masterEdition.printingMint,
parsedAccount,
);
setter(
'masterEditionsByOneTimeAuthMint',
masterEdition.oneTimePrintingAuthorizationMint.toBase58(),
masterEdition.oneTimePrintingAuthorizationMint,
parsedAccount,
);
} else {
@ -75,7 +75,7 @@ export const processMetaData: ProcessAccountsFunc = (
account,
info: masterEdition,
};
setter('masterEditions', pubkey.toBase58(), parsedAccount);
setter('masterEditions', pubkey, parsedAccount);
}
}
} catch {
@ -85,10 +85,7 @@ export const processMetaData: ProcessAccountsFunc = (
};
const isMetadataAccount = (account: AccountInfo<Buffer>) => {
return account.owner.equals
? account.owner.equals(METADATA_PROGRAM_ID)
: //@ts-ignore
account.owner === METADATA_PROGRAM_ID.toBase58();
return (account.owner as unknown as any) === METADATA_PROGRAM_ID;
};
const isMetadataV1Account = (account: AccountInfo<Buffer>) =>

26
js/packages/web/src/contexts/meta/processMetaplexAccounts.ts
View File

@ -52,7 +52,7 @@ export const processMetaplexAccounts: ProcessAccountsFunc = async (
};
setter(
'auctionManagersByAuction',
auctionManager.auction.toBase58(),
auctionManager.auction,
parsedAccount,
);
}
@ -68,14 +68,14 @@ export const processMetaplexAccounts: ProcessAccountsFunc = async (
account,
info: ticket,
};
setter('bidRedemptions', pubkey.toBase58(), parsedAccount);
setter('bidRedemptions', pubkey, parsedAccount);
if (ticket.key == MetaplexKey.BidRedemptionTicketV2) {
const asV2 = ticket as BidRedemptionTicketV2;
if (asV2.winnerIndex) {
setter(
'bidRedemptionV2sByAuctionManagerAndWinningIndex',
asV2.auctionManager.toBase58() + '-' + asV2.winnerIndex.toNumber(),
asV2.auctionManager + '-' + asV2.winnerIndex.toNumber(),
parsedAccount,
);
}
@ -89,7 +89,7 @@ export const processMetaplexAccounts: ProcessAccountsFunc = async (
account,
info: ticket,
};
setter('payoutTickets', pubkey.toBase58(), parsedAccount);
setter('payoutTickets', pubkey, parsedAccount);
}
if (isPrizeTrackingTicketV1Account(account)) {
@ -99,7 +99,7 @@ export const processMetaplexAccounts: ProcessAccountsFunc = async (
account,
info: ticket,
};
setter('prizeTrackingTickets', pubkey.toBase58(), parsedAccount);
setter('prizeTrackingTickets', pubkey, parsedAccount);
}
if (isStoreV1Account(account)) {
@ -109,10 +109,10 @@ export const processMetaplexAccounts: ProcessAccountsFunc = async (
account,
info: store,
};
if (STORE_ID && pubkey.equals(STORE_ID)) {
setter('store', pubkey.toBase58(), parsedAccount);
if (STORE_ID && pubkey === STORE_ID.toBase58()) {
setter('store', pubkey, parsedAccount);
}
setter('stores', pubkey.toBase58(), parsedAccount);
setter('stores', pubkey, parsedAccount);
}
if (isSafetyDepositConfigV1Account(account)) {
@ -124,7 +124,7 @@ export const processMetaplexAccounts: ProcessAccountsFunc = async (
};
setter(
'safetyDepositConfigsByAuctionManagerAndIndex',
config.auctionManager.toBase58() + '-' + config.order.toNumber(),
config.auctionManager + '-' + config.order.toNumber(),
parsedAccount,
);
}
@ -137,7 +137,7 @@ export const processMetaplexAccounts: ProcessAccountsFunc = async (
whitelistedCreator.address,
);
if (creatorKeyIfCreatorWasPartOfThisStore.equals(pubkey)) {
if (creatorKeyIfCreatorWasPartOfThisStore === pubkey) {
const parsedAccount = cache.add(
pubkey,
account,
@ -145,7 +145,7 @@ export const processMetaplexAccounts: ProcessAccountsFunc = async (
false,
) as ParsedAccount<WhitelistedCreator>;
const nameInfo = (names as any)[parsedAccount.info.address.toBase58()];
const nameInfo = (names as any)[parsedAccount.info.address];
if (nameInfo) {
parsedAccount.info = { ...parsedAccount.info, ...nameInfo };
@ -153,7 +153,7 @@ export const processMetaplexAccounts: ProcessAccountsFunc = async (
setter(
'whitelistedCreatorsByCreator',
whitelistedCreator.address.toBase58(),
whitelistedCreator.address,
parsedAccount,
);
}
@ -165,7 +165,7 @@ export const processMetaplexAccounts: ProcessAccountsFunc = async (
};
const isMetaplexAccount = (account: AccountInfo<Buffer>) =>
account.owner.equals(METAPLEX_ID);
(account.owner as unknown as any) === METAPLEX_ID;
const isAuctionManagerV1Account = (account: AccountInfo<Buffer>) =>
account.data[0] === MetaplexKey.AuctionManagerV1;

6
js/packages/web/src/contexts/meta/processVaultData.ts
View File

@ -26,7 +26,7 @@ export const processVaultData: ProcessAccountsFunc = (
};
setter(
'safetyDepositBoxesByVaultAndIndex',
safetyDeposit.vault.toBase58() + '-' + safetyDeposit.order,
safetyDeposit.vault + '-' + safetyDeposit.order,
parsedAccount,
);
}
@ -38,7 +38,7 @@ export const processVaultData: ProcessAccountsFunc = (
info: vault,
};
setter('vaults', pubkey.toBase58(), parsedAccount);
setter('vaults', pubkey, parsedAccount);
}
} catch {
// ignore errors
@ -47,7 +47,7 @@ export const processVaultData: ProcessAccountsFunc = (
};
const isVaultAccount = (account: AccountInfo<Buffer>) =>
account.owner.equals(VAULT_ID);
(account.owner as unknown as any) === VAULT_ID;
const isSafetyDepositBoxV1Account = (account: AccountInfo<Buffer>) =>
account.data[0] === VaultKey.SafetyDepositBoxV1;

5
js/packages/web/src/contexts/meta/types.ts
View File

@ -10,6 +10,7 @@ import {
AuctionDataExtended,
MasterEditionV1,
MasterEditionV2,
PublicKeyStringAndAccount,
} from '@oyster/common';
import { AccountInfo, PublicKey, PublicKeyAndAccount } from '@solana/web3.js';
import {
@ -78,7 +79,7 @@ export interface MetaContextState extends MetaState {
}
export type AccountAndPubkey = {
pubkey: PublicKey;
pubkey: string;
account: AccountInfo<Buffer>;
};
@ -89,7 +90,7 @@ export type UpdateStateValueFunc = (
) => void;
export type ProcessAccountsFunc = (
account: PublicKeyAndAccount<Buffer>,
account: PublicKeyStringAndAccount<Buffer>,
setter: UpdateStateValueFunc,
useAll: boolean,
) => void;

26
js/packages/web/src/hooks/useArt.ts
View File

@ -1,5 +1,4 @@
import React, { useEffect, useMemo, useState } from 'react';
import { PublicKey } from '@solana/web3.js';
import { useMeta } from '../contexts';
import { Art, Artist, ArtType } from '../types';
import {
@ -9,6 +8,7 @@ import {
MasterEditionV2,
Metadata,
ParsedAccount,
StringPublicKey,
} from '@oyster/common';
import { WhitelistedCreator } from '../models/metaplex';
import { Cache } from 'three';
@ -33,11 +33,10 @@ const metadataToArt = (
let supply: number | undefined = undefined;
if (info) {
const masterEdition = masterEditions[info.masterEdition?.toBase58() || ''];
const edition = editions[info.edition?.toBase58() || ''];
const masterEdition = masterEditions[info.masterEdition || ''];
const edition = editions[info.edition || ''];
if (edition) {
const myMasterEdition =
masterEditions[edition.info.parent.toBase58() || ''];
const myMasterEdition = masterEditions[edition.info.parent || ''];
if (myMasterEdition) {
type = ArtType.Print;
editionNumber = edition.info.edition.toNumber();
@ -52,15 +51,14 @@ const metadataToArt = (
return {
uri: info?.data.uri || '',
mint: info?.mint.toBase58(),
mint: info?.mint,
title: info?.data.name,
creators: (info?.data.creators || [])
.map(creator => {
const knownCreator =
whitelistedCreatorsByCreator[creator.address.toBase58()];
const knownCreator = whitelistedCreatorsByCreator[creator.address];
return {
address: creator.address.toBase58(),
address: creator.address,
verified: creator.verified,
share: creator.share,
image: knownCreator?.info.image || '',
@ -133,14 +131,12 @@ export const useCachedImage = (uri: string, cacheMesh?: boolean) => {
return { cachedBlob, isLoading };
};
export const useArt = (id?: PublicKey | string) => {
export const useArt = (key?: StringPublicKey) => {
const { metadata, editions, masterEditions, whitelistedCreatorsByCreator } =
useMeta();
const key = pubkeyToString(id);
const account = useMemo(
() => metadata.find(a => a.pubkey.toBase58() === key),
() => metadata.find(a => a.pubkey === key),
[key, metadata],
);
@ -158,7 +154,7 @@ export const useArt = (id?: PublicKey | string) => {
return art;
};
export const useExtendedArt = (id?: PublicKey | string) => {
export const useExtendedArt = (id?: StringPublicKey) => {
const { metadata } = useMeta();
const [data, setData] = useState<IMetadataExtension>();
@ -167,7 +163,7 @@ export const useExtendedArt = (id?: PublicKey | string) => {
const key = pubkeyToString(id);
const account = useMemo(
() => metadata.find(a => a.pubkey.toBase58() === key),
() => metadata.find(a => a.pubkey === key),
[key, metadata],
);

9
js/packages/web/src/hooks/useAuction.ts
View File

@ -1,5 +1,4 @@
import { useWallet } from '@oyster/common';
import { PublicKey } from '@solana/web3.js';
import { StringPublicKey, useWallet } from '@oyster/common';
import { useEffect, useState } from 'react';
import {
AuctionView,
@ -8,15 +7,13 @@ import {
} from '.';
import { useMeta } from '../contexts';
export const useAuction = (pubkey: PublicKey | string) => {
const id = typeof pubkey === 'string' ? pubkey : pubkey.toBase58();
export const useAuction = (id: StringPublicKey) => {
const { wallet } = useWallet();
const cachedRedemptionKeys = useCachedRedemptionKeysByWallet();
const [existingAuctionView, setAuctionView] =
useState<AuctionView | undefined>(undefined);
const walletPubkey = wallet?.publicKey;
const walletPubkey = wallet?.publicKey?.toBase58();
const {
auctions,
auctionManagersByAuction,

73
js/packages/web/src/hooks/useAuctions.ts
View File

@ -10,8 +10,8 @@ import {
MasterEditionV1,
MasterEditionV2,
useWallet,
StringPublicKey,
} from '@oyster/common';
import { PublicKey } from '@solana/web3.js';
import BN from 'bn.js';
import { useEffect, useState } from 'react';
import { useMeta } from '../contexts';
@ -67,7 +67,8 @@ export function useCachedRedemptionKeysByWallet() {
const [cachedRedemptionKeys, setCachedRedemptionKeys] = useState<
Record<
string,
ParsedAccount<BidRedemptionTicket> | { pubkey: PublicKey; info: null }
| ParsedAccount<BidRedemptionTicket>
| { pubkey: StringPublicKey; info: null }
>
>({});
@ -76,7 +77,8 @@ export function useCachedRedemptionKeysByWallet() {
if (wallet && wallet.publicKey) {
const temp: Record<
string,
ParsedAccount<BidRedemptionTicket> | { pubkey: PublicKey; info: null }
| ParsedAccount<BidRedemptionTicket>
| { pubkey: StringPublicKey; info: null }
> = {};
const keys = Object.keys(auctions);
const tasks = [];
@ -85,15 +87,18 @@ export function useCachedRedemptionKeysByWallet() {
if (!cachedRedemptionKeys[a])
//@ts-ignore
tasks.push(
getBidderKeys(auctions[a].pubkey, wallet.publicKey).then(key => {
temp[a] = bidRedemptions[key.bidRedemption.toBase58()]
? bidRedemptions[key.bidRedemption.toBase58()]
getBidderKeys(
auctions[a].pubkey,
wallet.publicKey.toBase58(),
).then(key => {
temp[a] = bidRedemptions[key.bidRedemption]
? bidRedemptions[key.bidRedemption]
: { pubkey: key.bidRedemption, info: null };
}),
);
else if (!cachedRedemptionKeys[a].info) {
temp[a] =
bidRedemptions[cachedRedemptionKeys[a].pubkey.toBase58()] ||
bidRedemptions[cachedRedemptionKeys[a].pubkey] ||
cachedRedemptionKeys[a];
}
}
@ -112,7 +117,7 @@ export const useAuctions = (state?: AuctionViewState) => {
const [auctionViews, setAuctionViews] = useState<AuctionView[]>([]);
const { wallet } = useWallet();
const pubkey = wallet?.publicKey;
const pubkey = wallet?.publicKey?.toBase58();
const cachedRedemptionKeys = useCachedRedemptionKeysByWallet();
const {
@ -204,7 +209,7 @@ function buildListWhileNonZero<T>(hash: Record<string, T>, key: string) {
}
export function processAccountsIntoAuctionView(
walletPubkey: PublicKey | null | undefined,
walletPubkey: StringPublicKey | null | undefined,
auction: ParsedAccount<AuctionData>,
auctionManagersByAuction: Record<
string,
@ -241,7 +246,7 @@ export function processAccountsIntoAuctionView(
metadataByMasterEdition: Record<string, ParsedAccount<Metadata>>,
cachedRedemptionKeysByWallet: Record<
string,
ParsedAccount<BidRedemptionTicket> | { pubkey: PublicKey; info: null }
ParsedAccount<BidRedemptionTicket> | { pubkey: StringPublicKey; info: null }
>,
desiredState: AuctionViewState | undefined,
existingAuctionView?: AuctionView,
@ -257,8 +262,7 @@ export function processAccountsIntoAuctionView(
state = AuctionViewState.BuyNow;
}
const auctionManagerInstance =
auctionManagersByAuction[auction.pubkey.toBase58() || ''];
const auctionManagerInstance = auctionManagersByAuction[auction.pubkey || ''];
// The defective auction view state really applies to auction managers, not auctions, so we ignore it here
if (
@ -284,8 +288,8 @@ export function processAccountsIntoAuctionView(
)
return undefined;
const vault = vaults[auctionManagerInstance.info.vault.toBase58()];
const auctionManagerKey = auctionManagerInstance.pubkey.toBase58();
const vault = vaults[auctionManagerInstance.info.vault];
const auctionManagerKey = auctionManagerInstance.pubkey;
let safetyDepositConfigs: ParsedAccount<SafetyDepositConfig>[] =
buildListWhileNonZero(
@ -309,20 +313,16 @@ export function processAccountsIntoAuctionView(
const boxesExpected = auctionManager.safetyDepositBoxesExpected.toNumber();
let bidRedemption: ParsedAccount<BidRedemptionTicket> | undefined =
cachedRedemptionKeysByWallet[auction.pubkey.toBase58()]?.info
cachedRedemptionKeysByWallet[auction.pubkey]?.info
? (cachedRedemptionKeysByWallet[
auction.pubkey.toBase58()
auction.pubkey
] as ParsedAccount<BidRedemptionTicket>)
: undefined;
const bidderMetadata =
bidderMetadataByAuctionAndBidder[
auction.pubkey.toBase58() + '-' + walletPubkey?.toBase58()
];
bidderMetadataByAuctionAndBidder[auction.pubkey + '-' + walletPubkey];
const bidderPot =
bidderPotsByAuctionAndBidder[
auction.pubkey.toBase58() + '-' + walletPubkey?.toBase58()
];
bidderPotsByAuctionAndBidder[auction.pubkey + '-' + walletPubkey];
if (existingAuctionView && existingAuctionView.totallyComplete) {
// If totally complete, we know we arent updating anythign else, let's speed things up
@ -336,16 +336,13 @@ export function processAccountsIntoAuctionView(
const curr = winningSet[j];
if (!curr.metadata) {
let foundMetadata =
metadataByMint[curr.safetyDeposit.info.tokenMint.toBase58()];
metadataByMint[curr.safetyDeposit.info.tokenMint];
if (!foundMetadata) {
// Means is a limited edition, so the tokenMint is the printingMint
let masterEdition =
masterEditionsByPrintingMint[
curr.safetyDeposit.info.tokenMint.toBase58()
];
masterEditionsByPrintingMint[curr.safetyDeposit.info.tokenMint];
if (masterEdition) {
foundMetadata =
metadataByMasterEdition[masterEdition.pubkey.toBase58()];
foundMetadata = metadataByMasterEdition[masterEdition.pubkey];
}
}
curr.metadata = foundMetadata;
@ -356,8 +353,7 @@ export function processAccountsIntoAuctionView(
!curr.masterEdition &&
curr.metadata.info.masterEdition
) {
let foundMaster =
masterEditions[curr.metadata.info.masterEdition.toBase58()];
let foundMaster = masterEditions[curr.metadata.info.masterEdition];
curr.masterEdition = foundMaster;
}
@ -367,7 +363,7 @@ export function processAccountsIntoAuctionView(
return existingAuctionView;
}
const vaultKey = auctionManager.vault.toBase58();
const vaultKey = auctionManager.vault;
let boxes: ParsedAccount<SafetyDepositBox>[] = buildListWhileNonZero(
safetyDepositBoxesByVaultAndIndex,
vaultKey,
@ -390,19 +386,14 @@ export function processAccountsIntoAuctionView(
// and case of v2 master edition where the edition itself is stored
participationMetadata =
metadataByMasterEdition[
masterEditionsByOneTimeAuthMint[
participationBox.info.tokenMint.toBase58()
]?.pubkey.toBase58()
] || metadataByMint[participationBox.info.tokenMint.toBase58()];
masterEditionsByOneTimeAuthMint[participationBox.info.tokenMint]
?.pubkey
] || metadataByMint[participationBox.info.tokenMint];
if (participationMetadata) {
participationMaster =
masterEditionsByOneTimeAuthMint[
participationBox.info.tokenMint.toBase58()
] ||
masterEditionsByOneTimeAuthMint[participationBox.info.tokenMint] ||
(participationMetadata.info.masterEdition &&
masterEditions[
participationMetadata.info.masterEdition?.toBase58()
]);
masterEditions[participationMetadata.info.masterEdition]);
}
}

14
js/packages/web/src/hooks/useBidsForAuction.ts
View File

@ -1,13 +1,15 @@
import React, { useEffect, useMemo, useState } from 'react';
import { PublicKey } from '@solana/web3.js';
import {
BidderMetadata,
BidderMetadataParser,
cache,
ParsedAccount,
StringPublicKey,
} from '@oyster/common';
export const useHighestBidForAuction = (auctionPubkey: PublicKey | string) => {
export const useHighestBidForAuction = (
auctionPubkey: StringPublicKey | string,
) => {
const bids = useBidsForAuction(auctionPubkey);
const winner = useMemo(() => {
@ -17,12 +19,12 @@ export const useHighestBidForAuction = (auctionPubkey: PublicKey | string) => {
return winner;
};
export const useBidsForAuction = (auctionPubkey: PublicKey | string) => {
export const useBidsForAuction = (auctionPubkey: StringPublicKey | string) => {
const id = useMemo(
() =>
typeof auctionPubkey === 'string'
? auctionPubkey !== ''
? new PublicKey(auctionPubkey)
? auctionPubkey
: undefined
: auctionPubkey,
[auctionPubkey],
@ -47,7 +49,7 @@ export const useBidsForAuction = (auctionPubkey: PublicKey | string) => {
return bids;
};
const getBids = (id?: PublicKey) => {
const getBids = (id?: StringPublicKey) => {
return cache
.byParser(BidderMetadataParser)
.filter(key => {
@ -56,7 +58,7 @@ const getBids = (id?: PublicKey) => {
return false;
}
return id?.equals(bidder.info.auctionPubkey);
return id === bidder.info.auctionPubkey;
})
.map(key => {
const bidder = cache.get(key) as ParsedAccount<BidderMetadata>;

6
js/packages/web/src/hooks/useCreator.ts
View File

@ -1,12 +1,12 @@
import { PublicKey } from '@solana/web3.js';
import { StringPublicKey } from '@oyster/common';
import { useMeta } from '../contexts';
import { pubkeyToString } from '../utils/pubkeyToString';
export const useCreator = (id?: PublicKey | string) => {
export const useCreator = (id?: StringPublicKey) => {
const { whitelistedCreatorsByCreator } = useMeta();
const key = pubkeyToString(id);
const creator = Object.values(whitelistedCreatorsByCreator).find(
creator => creator.info.address.toBase58() === key,
creator => creator.info.address === key,
);
return creator;
};

6
js/packages/web/src/hooks/useCreatorArts.ts
View File

@ -1,10 +1,10 @@
import { useMeta } from '../contexts';
import { PublicKey } from '@solana/web3.js';
import { StringPublicKey } from '@oyster/common';
export const useCreatorArts = (id?: PublicKey | string) => {
export const useCreatorArts = (id?: StringPublicKey) => {
const { metadata } = useMeta();
const filtered = metadata.filter(m =>
m.info.data.creators?.some(c => c.address.toBase58() === id),
m.info.data.creators?.some(c => c.address === id),
);
return filtered;

2
js/packages/web/src/hooks/useCreators.ts
View File

@ -20,7 +20,7 @@ export const useCreators = (auction?: AuctionView) => {
)
.filter(creator => creator.verified)
.reduce((agg, item) => {
agg.add(item.address.toBase58());
agg.add(item.address);
return agg;
}, new Set<string>())
.values(),

18
js/packages/web/src/hooks/useUserArts.ts
View File

@ -26,32 +26,28 @@ export const useUserArts = (): SafetyDepositDraft[] => {
const ownedMetadata = metadata.filter(
m =>
accountByMint.has(m.info.mint.toBase58()) &&
(accountByMint?.get(m.info.mint.toBase58())?.info?.amount?.toNumber() ||
0) > 0,
accountByMint.has(m.info.mint) &&
(accountByMint?.get(m.info.mint)?.info?.amount?.toNumber() || 0) > 0,
);
const possibleEditions = ownedMetadata.map(m =>
m.info.edition ? editions[m.info.edition?.toBase58()] : undefined,
m.info.edition ? editions[m.info.edition] : undefined,
);
const possibleMasterEditions = ownedMetadata.map(m =>
m.info.masterEdition
? masterEditions[m.info.masterEdition?.toBase58()]
: undefined,
m.info.masterEdition ? masterEditions[m.info.masterEdition] : undefined,
);
let safetyDeposits: SafetyDepositDraft[] = [];
let i = 0;
ownedMetadata.forEach(m => {
let a = accountByMint.get(m.info.mint.toBase58());
let a = accountByMint.get(m.info.mint);
let masterA;
const masterEdition = possibleMasterEditions[i];
if (masterEdition?.info.key == MetadataKey.MasterEditionV1) {
masterA = accountByMint.get(
(
masterEdition as ParsedAccount<MasterEditionV1>
)?.info.printingMint?.toBase58() || '',
(masterEdition as ParsedAccount<MasterEditionV1>)?.info.printingMint ||
'',
);
}

17
js/packages/web/src/hooks/useUserBalance.ts
View File

@ -1,15 +1,18 @@
import { fromLamports, useMint, useUserAccounts } from '@oyster/common';
import { PublicKey } from '@solana/web3.js';
import {
fromLamports,
StringPublicKey,
useMint,
useUserAccounts,
} from '@oyster/common';
import { useEffect, useMemo, useState } from 'react';
import { useSolPrice } from '../contexts';
export function useUserBalance(
mintAddress?: PublicKey | string,
account?: PublicKey,
mintAddress?: StringPublicKey,
account?: StringPublicKey,
) {
const mint = useMemo(
() =>
typeof mintAddress === 'string' ? mintAddress : mintAddress?.toBase58(),
() => (typeof mintAddress === 'string' ? mintAddress : mintAddress),
[mintAddress],
);
const { userAccounts } = useUserAccounts();
@ -23,7 +26,7 @@ export function useUserBalance(
.filter(
acc =>
mint === acc.info.mint.toBase58() &&
(!account || account.equals(acc.pubkey)),
(!account || account === acc.pubkey),
)
.sort((a, b) => b.info.amount.sub(a.info.amount).toNumber());
}, [userAccounts, mint, account]);

1
js/packages/web/src/models/dex/index.ts
View File

@ -1 +0,0 @@
export * from './market';

47
js/packages/web/src/models/dex/market.ts
View File

@ -1,47 +0,0 @@
import { contexts, ParsedAccountBase } from '@oyster/common';
import { Market, MARKETS, Orderbook } from '@project-serum/serum';
import { AccountInfo, PublicKey } from '@solana/web3.js';
const { MintParser, cache } = contexts.Accounts;
export const OrderBookParser = (id: PublicKey, acc: AccountInfo<Buffer>) => {
const decoded = Orderbook.LAYOUT.decode(acc.data);
const details = {
pubkey: id,
account: {
...acc,
},
info: decoded,
} as ParsedAccountBase;
return details;
};
const DEFAULT_DEX_ID = new PublicKey(
'EUqojwWA2rd19FZrzeBncJsm38Jm1hEhE3zsmX3bRc2o',
);
export const DexMarketParser = (
pubkey: PublicKey,
acc: AccountInfo<Buffer>,
) => {
const market = MARKETS.find(m => m.address.equals(pubkey));
const decoded = Market.getLayout(market?.programId || DEFAULT_DEX_ID).decode(
acc.data,
);
const details = {
pubkey,
account: {
...acc,
},
info: decoded,
} as ParsedAccountBase;
cache.registerParser(details.info.baseMint, MintParser);
cache.registerParser(details.info.quoteMint, MintParser);
cache.registerParser(details.info.bids, OrderBookParser);
cache.registerParser(details.info.asks, OrderBookParser);
return details;
};

1
js/packages/web/src/models/index.ts
View File

@ -1 +0,0 @@
export * from './dex';

2
js/packages/web/src/models/marketOverrides.ts
View File

@ -1,2 +1,2 @@
// use to override serum market to use specifc mint
// use to override serum market to use specific mint
export const MINT_TO_MARKET: { [key: string]: string } = {};

43
js/packages/web/src/models/metaplex/claimBid.ts
View File

@ -1,19 +1,20 @@
import { getBidderPotKey, programIds } from '@oyster/common';
import {
PublicKey,
SYSVAR_CLOCK_PUBKEY,
TransactionInstruction,
} from '@solana/web3.js';
getBidderPotKey,
programIds,
StringPublicKey,
toPublicKey,
} from '@oyster/common';
import { SYSVAR_CLOCK_PUBKEY, TransactionInstruction } from '@solana/web3.js';
import { serialize } from 'borsh';
import { getAuctionKeys, ClaimBidArgs, SCHEMA } from '.';
export async function claimBid(
acceptPayment: PublicKey,
bidder: PublicKey,
bidderPotToken: PublicKey,
vault: PublicKey,
tokenMint: PublicKey,
acceptPayment: StringPublicKey,
bidder: StringPublicKey,
bidderPotToken: StringPublicKey,
vault: StringPublicKey,
tokenMint: StringPublicKey,
instructions: TransactionInstruction[],
) {
const PROGRAM_IDS = programIds();
@ -35,53 +36,53 @@ export async function claimBid(
const keys = [
{
pubkey: acceptPayment,
pubkey: toPublicKey(acceptPayment),
isSigner: false,
isWritable: true,
},
{
pubkey: bidderPotToken,
pubkey: toPublicKey(bidderPotToken),
isSigner: false,
isWritable: true,
},
{
pubkey: bidderPotKey,
pubkey: toPublicKey(bidderPotKey),
isSigner: false,
isWritable: true,
},
{
pubkey: auctionManagerKey,
pubkey: toPublicKey(auctionManagerKey),
isSigner: false,
isWritable: true,
},
{
pubkey: auctionKey,
pubkey: toPublicKey(auctionKey),
isSigner: false,
isWritable: false,
},
{
pubkey: bidder,
pubkey: toPublicKey(bidder),
isSigner: false,
isWritable: false,
},
{
pubkey: tokenMint,
pubkey: toPublicKey(tokenMint),
isSigner: false,
isWritable: false,
},
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: false,
},
{
pubkey: store,
pubkey: toPublicKey(store),
isSigner: false,
isWritable: false,
},
{
pubkey: PROGRAM_IDS.auction,
pubkey: toPublicKey(PROGRAM_IDS.auction),
isSigner: false,
isWritable: false,
},
@ -100,7 +101,7 @@ export async function claimBid(
instructions.push(
new TransactionInstruction({
keys,
programId: PROGRAM_IDS.metaplex,
programId: toPublicKey(PROGRAM_IDS.metaplex),
data,
}),
);

30
js/packages/web/src/models/metaplex/decommissionAuctionManager.ts
View File

@ -1,18 +1,14 @@
import { programIds } from '@oyster/common';
import {
PublicKey,
SYSVAR_CLOCK_PUBKEY,
TransactionInstruction,
} from '@solana/web3.js';
import { programIds, StringPublicKey, toPublicKey } from '@oyster/common';
import { SYSVAR_CLOCK_PUBKEY, TransactionInstruction } from '@solana/web3.js';
import { serialize } from 'borsh';
import { DecommissionAuctionManagerArgs, SCHEMA } from '.';
export async function decommissionAuctionManager(
auctionManager: PublicKey,
auction: PublicKey,
authority: PublicKey,
vault: PublicKey,
auctionManager: StringPublicKey,
auction: StringPublicKey,
authority: StringPublicKey,
vault: StringPublicKey,
instructions: TransactionInstruction[],
) {
const PROGRAM_IDS = programIds();
@ -26,34 +22,34 @@ export async function decommissionAuctionManager(
const keys = [
{
pubkey: auctionManager,
pubkey: toPublicKey(auctionManager),
isSigner: false,
isWritable: true,
},
{
pubkey: auction,
pubkey: toPublicKey(auction),
isSigner: false,
isWritable: true,
},
{
pubkey: authority,
pubkey: toPublicKey(authority),
isSigner: true,
isWritable: false,
},
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: false,
},
{
pubkey: store,
pubkey: toPublicKey(store),
isSigner: false,
isWritable: false,
},
{
pubkey: PROGRAM_IDS.auction,
pubkey: toPublicKey(PROGRAM_IDS.auction),
isSigner: false,
isWritable: false,
},
@ -67,7 +63,7 @@ export async function decommissionAuctionManager(
instructions.push(
new TransactionInstruction({
keys,
programId: PROGRAM_IDS.metaplex,
programId: toPublicKey(PROGRAM_IDS.metaplex),
data,
}),
);

29
js/packages/web/src/models/metaplex/deprecatedInitAuctionManagerV1.ts
View File

@ -1,6 +1,5 @@
import { programIds } from '@oyster/common';
import { programIds, StringPublicKey, toPublicKey } from '@oyster/common';
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction,
@ -14,11 +13,11 @@ import {
} from './deprecatedStates';
export async function deprecatedInitAuctionManagerV1(
vault: PublicKey,
auctionManagerAuthority: PublicKey,
payer: PublicKey,
acceptPaymentAccount: PublicKey,
store: PublicKey,
vault: StringPublicKey,
auctionManagerAuthority: StringPublicKey,
payer: StringPublicKey,
acceptPaymentAccount: StringPublicKey,
store: StringPublicKey,
settings: AuctionManagerSettingsV1,
instructions: TransactionInstruction[],
) {
@ -33,38 +32,38 @@ export async function deprecatedInitAuctionManagerV1(
const keys = [
{
pubkey: auctionManagerKey,
pubkey: toPublicKey(auctionManagerKey),
isSigner: false,
isWritable: true,
},
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: false,
},
{
pubkey: auctionKey,
pubkey: toPublicKey(auctionKey),
isSigner: false,
isWritable: false,
},
{
pubkey: auctionManagerAuthority,
pubkey: toPublicKey(auctionManagerAuthority),
isSigner: false,
isWritable: false,
},
{
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: false,
},
{
pubkey: acceptPaymentAccount,
pubkey: toPublicKey(acceptPaymentAccount),
isSigner: false,
isWritable: false,
},
{
pubkey: store,
pubkey: toPublicKey(store),
isSigner: false,
isWritable: false,
},
@ -82,7 +81,7 @@ export async function deprecatedInitAuctionManagerV1(
instructions.push(
new TransactionInstruction({
keys,
programId: PROGRAM_IDS.metaplex,
programId: toPublicKey(PROGRAM_IDS.metaplex),
data,
}),
);

86
js/packages/web/src/models/metaplex/deprecatedPopulateParticipationPrintingAccount.ts
View File

@ -3,31 +3,29 @@ import {
VAULT_PREFIX,
getAuctionExtended,
findProgramAddress,
StringPublicKey,
toPublicKey,
} from '@oyster/common';
import {
PublicKey,
SYSVAR_RENT_PUBKEY,
TransactionInstruction,
} from '@solana/web3.js';
import { SYSVAR_RENT_PUBKEY, TransactionInstruction } from '@solana/web3.js';
import { serialize } from 'borsh';
import { SCHEMA } from '.';
import { DeprecatedPopulateParticipationPrintingAccountArgs } from './deprecatedStates';
export async function deprecatedPopulateParticipationPrintingAccount(
vault: PublicKey,
auctionManager: PublicKey,
auction: PublicKey,
safetyDepositTokenStore: PublicKey,
transientOneTimeAccount: PublicKey,
printingTokenAccount: PublicKey,
safetyDeposit: PublicKey,
fractionMint: PublicKey,
printingMint: PublicKey,
oneTimePrintingAuthorizationMint: PublicKey,
masterEdition: PublicKey,
metadata: PublicKey,
payer: PublicKey,
vault: StringPublicKey,
auctionManager: StringPublicKey,
auction: StringPublicKey,
safetyDepositTokenStore: StringPublicKey,
transientOneTimeAccount: StringPublicKey,
printingTokenAccount: StringPublicKey,
safetyDeposit: StringPublicKey,
fractionMint: StringPublicKey,
printingMint: StringPublicKey,
oneTimePrintingAuthorizationMint: StringPublicKey,
masterEdition: StringPublicKey,
metadata: StringPublicKey,
payer: StringPublicKey,
instructions: TransactionInstruction[],
) {
const PROGRAM_IDS = programIds();
@ -36,14 +34,14 @@ export async function deprecatedPopulateParticipationPrintingAccount(
throw new Error('Store not initialized');
}
const transferAuthority: PublicKey = (
const transferAuthority = (
await findProgramAddress(
[
Buffer.from(VAULT_PREFIX),
PROGRAM_IDS.vault.toBuffer(),
vault.toBuffer(),
toPublicKey(PROGRAM_IDS.vault).toBuffer(),
toPublicKey(vault).toBuffer(),
],
PROGRAM_IDS.vault,
toPublicKey(PROGRAM_IDS.vault),
)
)[0];
@ -52,60 +50,62 @@ export async function deprecatedPopulateParticipationPrintingAccount(
const keys = [
{
pubkey: safetyDepositTokenStore,
pubkey: toPublicKey(safetyDepositTokenStore),
isSigner: false,
isWritable: true,
},
{
pubkey: transientOneTimeAccount,
pubkey: toPublicKey(transientOneTimeAccount),
isSigner: false,
isWritable: true,
},
{
pubkey: printingTokenAccount,
pubkey: toPublicKey(printingTokenAccount),
isSigner: false,
isWritable: true,
},
{
pubkey: oneTimePrintingAuthorizationMint,
pubkey: toPublicKey(oneTimePrintingAuthorizationMint),
isSigner: false,
isWritable: true,
},
{
pubkey: printingMint,
pubkey: toPublicKey(printingMint),
isSigner: false,
isWritable: true,
},
{
pubkey: safetyDeposit,
pubkey: toPublicKey(safetyDeposit),
isSigner: false,
isWritable: true,
},
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: true,
},
{
pubkey: fractionMint,
pubkey: toPublicKey(fractionMint),
isSigner: false,
isWritable: false,
},
{
pubkey: auction,
pubkey: toPublicKey(auction),
isSigner: false,
isWritable: false,
},
{
pubkey: await getAuctionExtended({
auctionProgramId: PROGRAM_IDS.auction,
resource: vault,
}),
pubkey: toPublicKey(
await getAuctionExtended({
auctionProgramId: PROGRAM_IDS.auction,
resource: vault,
}),
),
isSigner: false,
isWritable: false,
},
{
pubkey: auctionManager,
pubkey: toPublicKey(auctionManager),
isSigner: false,
isWritable: false,
},
@ -115,12 +115,12 @@ export async function deprecatedPopulateParticipationPrintingAccount(
isWritable: false,
},
{
pubkey: PROGRAM_IDS.vault,
pubkey: toPublicKey(PROGRAM_IDS.vault),
isSigner: false,
isWritable: false,
},
{
pubkey: PROGRAM_IDS.metadata,
pubkey: toPublicKey(PROGRAM_IDS.metadata),
isSigner: false,
isWritable: false,
},
@ -130,22 +130,22 @@ export async function deprecatedPopulateParticipationPrintingAccount(
isWritable: false,
},
{
pubkey: masterEdition,
pubkey: toPublicKey(masterEdition),
isSigner: false,
isWritable: false,
},
{
pubkey: metadata,
pubkey: toPublicKey(metadata),
isSigner: false,
isWritable: false,
},
{
pubkey: transferAuthority,
pubkey: toPublicKey(transferAuthority),
isSigner: false,
isWritable: false,
},
{
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: false,
isWritable: false,
},
@ -159,7 +159,7 @@ export async function deprecatedPopulateParticipationPrintingAccount(
instructions.push(
new TransactionInstruction({
keys,
programId: PROGRAM_IDS.metaplex,
programId: toPublicKey(PROGRAM_IDS.metaplex),
data,
}),
);

59
js/packages/web/src/models/metaplex/deprecatedRedeemParticipationBid.ts
View File

@ -1,6 +1,5 @@
import { getEdition, programIds, getMetadata } from '@oyster/common';
import { programIds, StringPublicKey, toPublicKey } from '@oyster/common';
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction,
@ -16,17 +15,17 @@ import {
import { DeprecatedRedeemParticipationBidArgs } from './deprecatedStates';
export async function deprecatedRedeemParticipationBid(
vault: PublicKey,
safetyDepositTokenStore: PublicKey,
destination: PublicKey,
safetyDeposit: PublicKey,
bidder: PublicKey,
payer: PublicKey,
vault: StringPublicKey,
safetyDepositTokenStore: StringPublicKey,
destination: StringPublicKey,
safetyDeposit: StringPublicKey,
bidder: StringPublicKey,
payer: StringPublicKey,
instructions: TransactionInstruction[],
participationPrintingAccount: PublicKey,
transferAuthority: PublicKey,
acceptPaymentAccount: PublicKey,
tokenPaymentAccount: PublicKey,
participationPrintingAccount: StringPublicKey,
transferAuthority: StringPublicKey,
acceptPaymentAccount: StringPublicKey,
tokenPaymentAccount: StringPublicKey,
) {
const PROGRAM_IDS = programIds();
const store = PROGRAM_IDS.store;
@ -50,57 +49,57 @@ export async function deprecatedRedeemParticipationBid(
const data = Buffer.from(serialize(SCHEMA, value));
const keys = [
{
pubkey: auctionManagerKey,
pubkey: toPublicKey(auctionManagerKey),
isSigner: false,
isWritable: true,
},
{
pubkey: safetyDepositTokenStore,
pubkey: toPublicKey(safetyDepositTokenStore),
isSigner: false,
isWritable: true,
},
{
pubkey: destination,
pubkey: toPublicKey(destination),
isSigner: false,
isWritable: true,
},
{
pubkey: bidRedemption,
pubkey: toPublicKey(bidRedemption),
isSigner: false,
isWritable: true,
},
{
pubkey: safetyDeposit,
pubkey: toPublicKey(safetyDeposit),
isSigner: false,
isWritable: false,
},
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: false,
},
{
pubkey: safetyDepositConfig,
pubkey: toPublicKey(safetyDepositConfig),
isSigner: false,
isWritable: false,
},
{
pubkey: auctionKey,
pubkey: toPublicKey(auctionKey),
isSigner: false,
isWritable: false,
},
{
pubkey: bidMetadata,
pubkey: toPublicKey(bidMetadata),
isSigner: false,
isWritable: false,
},
{
pubkey: bidder,
pubkey: toPublicKey(bidder),
isSigner: false,
isWritable: true,
},
{
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: false,
},
@ -110,12 +109,12 @@ export async function deprecatedRedeemParticipationBid(
isWritable: false,
},
{
pubkey: PROGRAM_IDS.vault,
pubkey: toPublicKey(PROGRAM_IDS.vault),
isSigner: false,
isWritable: false,
},
{
pubkey: PROGRAM_IDS.metadata,
pubkey: toPublicKey(PROGRAM_IDS.metadata),
isSigner: false,
isWritable: false,
},
@ -135,22 +134,22 @@ export async function deprecatedRedeemParticipationBid(
isWritable: false,
},
{
pubkey: transferAuthority,
pubkey: toPublicKey(transferAuthority),
isSigner: true,
isWritable: false,
},
{
pubkey: acceptPaymentAccount,
pubkey: toPublicKey(acceptPaymentAccount),
isSigner: false,
isWritable: true,
},
{
pubkey: tokenPaymentAccount,
pubkey: toPublicKey(tokenPaymentAccount),
isSigner: false,
isWritable: true,
},
{
pubkey: participationPrintingAccount,
pubkey: toPublicKey(participationPrintingAccount),
isSigner: false,
isWritable: true,
},
@ -159,7 +158,7 @@ export async function deprecatedRedeemParticipationBid(
instructions.push(
new TransactionInstruction({
keys,
programId: PROGRAM_IDS.metaplex,
programId: toPublicKey(PROGRAM_IDS.metaplex),
data,
}),
);

49
js/packages/web/src/models/metaplex/deprecatedStates.ts
View File

@ -1,5 +1,4 @@
import { programIds, findProgramAddress } from '@oyster/common';
import { PublicKey } from '@solana/web3.js';
import { programIds, findProgramAddress, toPublicKey } from '@oyster/common';
import BN from 'bn.js';
import {
AuctionManagerStatus,
@ -15,20 +14,20 @@ export const MAX_BID_REDEMPTION_TICKET_V1_SIZE = 3;
export class AuctionManagerV1 {
key: MetaplexKey;
store: PublicKey;
authority: PublicKey;
auction: PublicKey;
vault: PublicKey;
acceptPayment: PublicKey;
store: string;
authority: string;
auction: string;
vault: string;
acceptPayment: string;
state: AuctionManagerStateV1;
settings: AuctionManagerSettingsV1;
constructor(args: {
store: PublicKey;
authority: PublicKey;
auction: PublicKey;
vault: PublicKey;
acceptPayment: PublicKey;
store: string;
authority: string;
auction: string;
vault: string;
acceptPayment: string;
state: AuctionManagerStateV1;
settings: AuctionManagerSettingsV1;
}) {
@ -81,7 +80,7 @@ export class ParticipationStateV1 {
collectedToAcceptPayment: BN = new BN(0);
primarySaleHappened: boolean = false;
validated: boolean = false;
printingAuthorizationTokenAccount: PublicKey | null = null;
printingAuthorizationTokenAccount: string | null = null;
constructor(args?: ParticipationStateV1) {
Object.assign(this, args);
@ -163,19 +162,19 @@ export class BidRedemptionTicketV1 implements BidRedemptionTicket {
}
export async function getSafetyDepositBoxValidationTicket(
auctionManager: PublicKey,
safetyDepositBox: PublicKey,
auctionManager: string,
safetyDepositBox: string,
) {
const PROGRAM_IDS = programIds();
return (
await findProgramAddress(
[
Buffer.from(METAPLEX_PREFIX),
PROGRAM_IDS.metaplex.toBuffer(),
auctionManager.toBuffer(),
safetyDepositBox.toBuffer(),
toPublicKey(PROGRAM_IDS.metaplex).toBuffer(),
toPublicKey(auctionManager).toBuffer(),
toPublicKey(safetyDepositBox).toBuffer(),
],
PROGRAM_IDS.metaplex,
toPublicKey(PROGRAM_IDS.metaplex),
)
)[0];
}
@ -187,11 +186,11 @@ export const DEPRECATED_SCHEMA = new Map<any, any>([
kind: 'struct',
fields: [
['key', 'u8'],
['store', 'pubkey'],
['authority', 'pubkey'],
['auction', 'pubkey'],
['vault', 'pubkey'],
['acceptPayment', 'pubkey'],
['store', 'pubkeyAsString'],
['authority', 'pubkeyAsString'],
['auction', 'pubkeyAsString'],
['vault', 'pubkeyAsString'],
['acceptPayment', 'pubkeyAsString'],
['state', AuctionManagerStateV1],
['settings', AuctionManagerSettingsV1],
],
@ -282,7 +281,7 @@ export const DEPRECATED_SCHEMA = new Map<any, any>([
['validated', 'u8'], //bool
[
'printingAuthorizationTokenAccount',
{ kind: 'option', type: 'pubkey' },
{ kind: 'option', type: 'pubkeyAsString' },
],
],
},

45
js/packages/web/src/models/metaplex/deprecatedValidateParticipation.ts
View File

@ -1,6 +1,5 @@
import { programIds } from '@oyster/common';
import { programIds, StringPublicKey, toPublicKey } from '@oyster/common';
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction,
@ -11,16 +10,16 @@ import { SCHEMA } from '.';
import { DeprecatedValidateParticipationArgs } from './deprecatedStates';
export async function deprecatedValidateParticipation(
auctionManager: PublicKey,
openEditionMetadata: PublicKey,
openEditionMasterAccount: PublicKey,
printingAuthorizationHoldingAccount: PublicKey,
auctionManagerAuthority: PublicKey,
whitelistedCreatorEntry: PublicKey | undefined,
store: PublicKey,
safetyDepositBox: PublicKey,
safetyDepositBoxTokenStore: PublicKey,
vault: PublicKey,
auctionManager: StringPublicKey,
openEditionMetadata: StringPublicKey,
openEditionMasterAccount: StringPublicKey,
printingAuthorizationHoldingAccount: StringPublicKey,
auctionManagerAuthority: StringPublicKey,
whitelistedCreatorEntry: StringPublicKey | undefined,
store: StringPublicKey,
safetyDepositBox: StringPublicKey,
safetyDepositBoxTokenStore: StringPublicKey,
vault: StringPublicKey,
instructions: TransactionInstruction[],
) {
const PROGRAM_IDS = programIds();
@ -31,59 +30,59 @@ export async function deprecatedValidateParticipation(
const keys = [
{
pubkey: auctionManager,
pubkey: toPublicKey(auctionManager),
isSigner: false,
isWritable: true,
},
{
pubkey: openEditionMetadata,
pubkey: toPublicKey(openEditionMetadata),
isSigner: false,
isWritable: false,
},
{
pubkey: openEditionMasterAccount,
pubkey: toPublicKey(openEditionMasterAccount),
isSigner: false,
isWritable: false,
},
{
pubkey: printingAuthorizationHoldingAccount,
pubkey: toPublicKey(printingAuthorizationHoldingAccount),
isSigner: false,
isWritable: false,
},
{
pubkey: auctionManagerAuthority,
pubkey: toPublicKey(auctionManagerAuthority),
isSigner: true,
isWritable: false,
},
{
pubkey: whitelistedCreatorEntry || SystemProgram.programId,
pubkey: toPublicKey(whitelistedCreatorEntry || SystemProgram.programId),
isSigner: false,
isWritable: false,
},
{
pubkey: store,
pubkey: toPublicKey(store),
isSigner: false,
isWritable: false,
},
{
pubkey: safetyDepositBox,
pubkey: toPublicKey(safetyDepositBox),
isSigner: false,
isWritable: false,
},
{
pubkey: safetyDepositBoxTokenStore,
pubkey: toPublicKey(safetyDepositBoxTokenStore),
isSigner: false,
isWritable: false,
},
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: false,
},
@ -97,7 +96,7 @@ export async function deprecatedValidateParticipation(
instructions.push(
new TransactionInstruction({
keys,
programId: PROGRAM_IDS.metaplex,
programId: toPublicKey(PROGRAM_IDS.metaplex),
data,
}),
);

73
js/packages/web/src/models/metaplex/deprecatedValidateSafetyDepositBoxV1.ts
View File

@ -1,6 +1,5 @@
import { programIds, getEdition } from '@oyster/common';
import { programIds, StringPublicKey, toPublicKey } from '@oyster/common';
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction,
@ -15,26 +14,26 @@ import {
} from './deprecatedStates';
export async function deprecatedValidateSafetyDepositBoxV1(
vault: PublicKey,
metadata: PublicKey,
safetyDepositBox: PublicKey,
safetyDepositTokenStore: PublicKey,
tokenMint: PublicKey,
auctionManagerAuthority: PublicKey,
metadataAuthority: PublicKey,
payer: PublicKey,
vault: StringPublicKey,
metadata: StringPublicKey,
safetyDepositBox: StringPublicKey,
safetyDepositTokenStore: StringPublicKey,
tokenMint: StringPublicKey,
auctionManagerAuthority: StringPublicKey,
metadataAuthority: StringPublicKey,
payer: StringPublicKey,
instructions: TransactionInstruction[],
edition: PublicKey,
whitelistedCreator: PublicKey | undefined,
store: PublicKey,
printingMint?: PublicKey,
printingMintAuthority?: PublicKey,
edition: StringPublicKey,
whitelistedCreator: StringPublicKey | undefined,
store: StringPublicKey,
printingMint?: StringPublicKey,
printingMintAuthority?: StringPublicKey,
) {
const PROGRAM_IDS = programIds();
const { auctionKey, auctionManagerKey } = await getAuctionKeys(vault);
const originalAuthorityLookup: PublicKey = await getOriginalAuthority(
const originalAuthorityLookup = await getOriginalAuthority(
auctionKey,
metadata,
);
@ -44,81 +43,83 @@ export async function deprecatedValidateSafetyDepositBoxV1(
const data = Buffer.from(serialize(SCHEMA, value));
const keys = [
{
pubkey: await getSafetyDepositBoxValidationTicket(
auctionManagerKey,
safetyDepositBox,
pubkey: toPublicKey(
await getSafetyDepositBoxValidationTicket(
auctionManagerKey,
safetyDepositBox,
),
),
isSigner: false,
isWritable: true,
},
{
pubkey: auctionManagerKey,
pubkey: toPublicKey(auctionManagerKey),
isSigner: false,
isWritable: true,
},
{
pubkey: metadata,
pubkey: toPublicKey(metadata),
isSigner: false,
isWritable: true,
},
{
pubkey: originalAuthorityLookup,
pubkey: toPublicKey(originalAuthorityLookup),
isSigner: false,
isWritable: true,
},
{
pubkey: whitelistedCreator || SystemProgram.programId,
pubkey: toPublicKey(whitelistedCreator || SystemProgram.programId),
isSigner: false,
isWritable: false,
},
{
pubkey: store,
pubkey: toPublicKey(store),
isSigner: false,
isWritable: false,
},
{
pubkey: safetyDepositBox,
pubkey: toPublicKey(safetyDepositBox),
isSigner: false,
isWritable: false,
},
{
pubkey: safetyDepositTokenStore,
pubkey: toPublicKey(safetyDepositTokenStore),
isSigner: false,
isWritable: false,
},
{
pubkey: tokenMint,
pubkey: toPublicKey(tokenMint),
isSigner: false,
isWritable: false,
},
{
pubkey: edition,
pubkey: toPublicKey(edition),
isSigner: false,
isWritable: false,
},
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: false,
},
{
pubkey: auctionManagerAuthority,
pubkey: toPublicKey(auctionManagerAuthority),
isSigner: true,
isWritable: false,
},
{
pubkey: metadataAuthority,
pubkey: toPublicKey(metadataAuthority),
isSigner: true,
isWritable: false,
},
{
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: false,
},
{
pubkey: PROGRAM_IDS.metadata,
pubkey: toPublicKey(PROGRAM_IDS.metadata),
isSigner: false,
isWritable: false,
},
@ -136,13 +137,13 @@ export async function deprecatedValidateSafetyDepositBoxV1(
if (printingMint && printingMintAuthority) {
keys.push({
pubkey: printingMint,
pubkey: toPublicKey(printingMint),
isSigner: false,
isWritable: true,
});
keys.push({
pubkey: printingMintAuthority,
pubkey: toPublicKey(printingMintAuthority),
isSigner: true,
isWritable: false,
});
@ -150,7 +151,7 @@ export async function deprecatedValidateSafetyDepositBoxV1(
instructions.push(
new TransactionInstruction({
keys,
programId: PROGRAM_IDS.metaplex,
programId: toPublicKey(PROGRAM_IDS.metaplex),
data,
}),
);

65
js/packages/web/src/models/metaplex/emptyPaymentAccount.ts
View File

@ -1,6 +1,5 @@
import { programIds } from '@oyster/common';
import { programIds, StringPublicKey, toPublicKey } from '@oyster/common';
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction,
@ -16,16 +15,16 @@ import {
} from '.';
export async function emptyPaymentAccount(
acceptPayment: PublicKey,
destination: PublicKey,
auctionManager: PublicKey,
metadata: PublicKey,
masterEdition: PublicKey | undefined,
safetyDepositBox: PublicKey,
vault: PublicKey,
auction: PublicKey,
payer: PublicKey,
recipient: PublicKey,
acceptPayment: StringPublicKey,
destination: StringPublicKey,
auctionManager: StringPublicKey,
metadata: StringPublicKey,
masterEdition: StringPublicKey | undefined,
safetyDepositBox: StringPublicKey,
vault: StringPublicKey,
auction: StringPublicKey,
payer: StringPublicKey,
recipient: StringPublicKey,
winningConfigIndex: number | null,
winningConfigItemIndex: number | null,
creatorIndex: number | null,
@ -54,64 +53,66 @@ export async function emptyPaymentAccount(
const keys = [
{
pubkey: acceptPayment,
pubkey: toPublicKey(acceptPayment),
isSigner: false,
isWritable: true,
},
{
pubkey: destination,
pubkey: toPublicKey(destination),
isSigner: false,
isWritable: true,
},
{
pubkey: auctionManager,
pubkey: toPublicKey(auctionManager),
isSigner: false,
isWritable: true,
},
{
pubkey: await getPayoutTicket(
auctionManager,
winningConfigIndex,
winningConfigItemIndex,
creatorIndex,
safetyDepositBox,
recipient,
pubkey: toPublicKey(
await getPayoutTicket(
auctionManager,
winningConfigIndex,
winningConfigItemIndex,
creatorIndex,
safetyDepositBox,
recipient,
),
),
isSigner: false,
isWritable: true,
},
{
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: false,
},
{
pubkey: metadata,
pubkey: toPublicKey(metadata),
isSigner: false,
isWritable: false,
},
{
pubkey: masterEdition || SystemProgram.programId,
pubkey: toPublicKey(masterEdition || SystemProgram.programId),
isSigner: false,
isWritable: false,
},
{
pubkey: safetyDepositBox,
pubkey: toPublicKey(safetyDepositBox),
isSigner: false,
isWritable: false,
},
{
pubkey: store,
pubkey: toPublicKey(store),
isSigner: false,
isWritable: false,
},
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: false,
},
{
pubkey: auction,
pubkey: toPublicKey(auction),
isSigner: false,
isWritable: false,
},
@ -132,13 +133,13 @@ export async function emptyPaymentAccount(
},
{
pubkey: tokenTracker,
pubkey: toPublicKey(tokenTracker),
isSigner: false,
isWritable: false,
},
{
pubkey: safetyDepositConfig,
pubkey: toPublicKey(safetyDepositConfig),
isSigner: false,
isWritable: false,
},
@ -147,7 +148,7 @@ export async function emptyPaymentAccount(
instructions.push(
new TransactionInstruction({
keys,
programId: PROGRAM_IDS.metaplex,
programId: toPublicKey(PROGRAM_IDS.metaplex),
data,
}),
);

244
js/packages/web/src/models/metaplex/index.ts
View File

@ -12,10 +12,13 @@ import {
MetadataKey,
SafetyDepositBox,
MasterEditionV2,
toPublicKey,
StringPublicKey,
} from '@oyster/common';
import { AccountInfo, PublicKey, SystemProgram } from '@solana/web3.js';
import { AccountInfo, SystemProgram } from '@solana/web3.js';
import BN from 'bn.js';
import { deserializeUnchecked } from 'borsh';
import bs58 from 'bs58';
import { AuctionViewItem } from '../../hooks';
import {
AuctionManagerV1,
@ -56,13 +59,13 @@ export enum MetaplexKey {
}
export class PrizeTrackingTicket {
key: MetaplexKey = MetaplexKey.PrizeTrackingTicketV1;
metadata: PublicKey;
metadata: string;
supplySnapshot: BN;
expectedRedemptions: BN;
redemptions: BN;
constructor(args: {
metadata: PublicKey;
metadata: string;
supplySnapshot: BN;
expectedRedemptions: BN;
redemptions: BN;
@ -76,22 +79,22 @@ export class PrizeTrackingTicket {
}
export class PayoutTicket {
key: MetaplexKey = MetaplexKey.PayoutTicketV1;
recipient: PublicKey;
recipient: StringPublicKey;
amountPaid: BN;
constructor(args: { recipient: PublicKey; amountPaid: BN }) {
constructor(args: { recipient: StringPublicKey; amountPaid: BN }) {
this.key = MetaplexKey.PayoutTicketV1;
this.recipient = args.recipient;
this.amountPaid = args.amountPaid;
}
}
export class AuctionManager {
pubkey: PublicKey;
store: PublicKey;
authority: PublicKey;
auction: PublicKey;
vault: PublicKey;
acceptPayment: PublicKey;
pubkey: StringPublicKey;
store: StringPublicKey;
authority: StringPublicKey;
auction: StringPublicKey;
vault: StringPublicKey;
acceptPayment: StringPublicKey;
numWinners: BN;
safetyDepositConfigs: ParsedAccount<SafetyDepositConfig>[];
bidRedemptions: ParsedAccount<BidRedemptionTicketV2>[];
@ -199,18 +202,15 @@ export class AuctionManager {
).settings.winningConfigs.map(w => {
return w.items.map(it => {
let metadata =
metadataByMint[
boxes[it.safetyDepositBoxIndex]?.info.tokenMint.toBase58()
];
metadataByMint[boxes[it.safetyDepositBoxIndex]?.info.tokenMint];
if (!metadata) {
// Means is a limited edition v1, so the tokenMint is the printingMint
let masterEdition =
masterEditionsByPrintingMint[
boxes[it.safetyDepositBoxIndex]?.info.tokenMint.toBase58()
boxes[it.safetyDepositBoxIndex]?.info.tokenMint
];
if (masterEdition) {
metadata =
metadataByMasterEdition[masterEdition.pubkey.toBase58()];
metadata = metadataByMasterEdition[masterEdition.pubkey];
}
}
return {
@ -219,7 +219,7 @@ export class AuctionManager {
safetyDeposit: boxes[it.safetyDepositBoxIndex],
amount: new BN(it.amount),
masterEdition: metadata?.info?.masterEdition
? masterEditions[metadata.info.masterEdition.toBase58()]
? masterEditions[metadata.info.masterEdition]
: undefined,
};
});
@ -233,15 +233,14 @@ export class AuctionManager {
const amount = s.info.getAmountForWinner(new BN(i));
if (amount.gt(new BN(0))) {
const safetyDeposit = boxes[s.info.order.toNumber()];
const metadata =
metadataByMint[safetyDeposit.info.tokenMint.toBase58()];
const metadata = metadataByMint[safetyDeposit.info.tokenMint];
newWinnerArr.push({
metadata,
winningConfigType: s.info.winningConfigType,
safetyDeposit,
amount,
masterEdition: metadata?.info?.masterEdition
? masterEditions[metadata.info.masterEdition.toBase58()]
? masterEditions[metadata.info.masterEdition]
: undefined,
});
}
@ -254,19 +253,19 @@ export class AuctionManager {
export class AuctionManagerV2 {
key: MetaplexKey;
store: PublicKey;
authority: PublicKey;
auction: PublicKey;
vault: PublicKey;
acceptPayment: PublicKey;
store: StringPublicKey;
authority: StringPublicKey;
auction: StringPublicKey;
vault: StringPublicKey;
acceptPayment: StringPublicKey;
state: AuctionManagerStateV2;
constructor(args: {
store: PublicKey;
authority: PublicKey;
auction: PublicKey;
vault: PublicKey;
acceptPayment: PublicKey;
store: StringPublicKey;
authority: StringPublicKey;
auction: StringPublicKey;
vault: StringPublicKey;
acceptPayment: StringPublicKey;
state: AuctionManagerStateV2;
}) {
this.key = MetaplexKey.AuctionManagerV2;
@ -461,7 +460,7 @@ export const decodeWhitelistedCreator = (buffer: Buffer) => {
};
export const WhitelistedCreatorParser: AccountParser = (
pubkey: PublicKey,
pubkey: StringPublicKey,
account: AccountInfo<Buffer>,
) => ({
pubkey,
@ -504,7 +503,7 @@ export const decodePayoutTicket = (buffer: Buffer) => {
export class WhitelistedCreator {
key: MetaplexKey = MetaplexKey.WhitelistedCreatorV1;
address: PublicKey;
address: StringPublicKey;
activated: boolean = true;
// Populated from name service
@ -513,7 +512,7 @@ export class WhitelistedCreator {
image?: string;
description?: string;
constructor(args: { address: PublicKey; activated: boolean }) {
constructor(args: { address: string; activated: boolean }) {
this.address = args.address;
this.activated = args.activated;
}
@ -522,17 +521,17 @@ export class WhitelistedCreator {
export class Store {
key: MetaplexKey = MetaplexKey.StoreV1;
public: boolean = true;
auctionProgram: PublicKey;
tokenVaultProgram: PublicKey;
tokenMetadataProgram: PublicKey;
tokenProgram: PublicKey;
auctionProgram: StringPublicKey;
tokenVaultProgram: StringPublicKey;
tokenMetadataProgram: StringPublicKey;
tokenProgram: StringPublicKey;
constructor(args: {
public: boolean;
auctionProgram: PublicKey;
tokenVaultProgram: PublicKey;
tokenMetadataProgram: PublicKey;
tokenProgram: PublicKey;
auctionProgram: StringPublicKey;
tokenVaultProgram: StringPublicKey;
tokenMetadataProgram: StringPublicKey;
tokenProgram: StringPublicKey;
}) {
this.key = MetaplexKey.StoreV1;
this.public = args.public;
@ -551,7 +550,7 @@ export interface BidRedemptionTicket {
export class BidRedemptionTicketV2 implements BidRedemptionTicket {
key: MetaplexKey = MetaplexKey.BidRedemptionTicketV2;
winnerIndex: BN | null;
auctionManager: PublicKey;
auctionManager: StringPublicKey;
data: number[] = [];
constructor(args: { key: MetaplexKey; data: number[] }) {
@ -564,7 +563,7 @@ export class BidRedemptionTicketV2 implements BidRedemptionTicket {
offset += 8;
}
this.auctionManager = new PublicKey(this.data.slice(offset, offset + 32));
this.auctionManager = bs58.encode(this.data.slice(offset, offset + 32));
}
getBidRedeemed(order: number): boolean {
@ -625,7 +624,7 @@ export class InitAuctionManagerV2Args {
export class SafetyDepositConfig {
key: MetaplexKey = MetaplexKey.SafetyDepositConfigV1;
auctionManager: PublicKey = SystemProgram.programId;
auctionManager: StringPublicKey = SystemProgram.programId.toBase58();
order: BN = new BN(0);
winningConfigType: WinningConfigType = WinningConfigType.PrintingV2;
amountType: TupleNumericType = TupleNumericType.U8;
@ -637,7 +636,7 @@ export class SafetyDepositConfig {
constructor(args: {
data?: Uint8Array;
directArgs?: {
auctionManager: PublicKey;
auctionManager: StringPublicKey;
order: BN;
winningConfigType: WinningConfigType;
amountType: TupleNumericType;
@ -650,7 +649,7 @@ export class SafetyDepositConfig {
if (args.directArgs) {
Object.assign(this, args.directArgs);
} else if (args.data) {
this.auctionManager = new PublicKey(args.data.slice(1, 33));
this.auctionManager = bs58.encode(args.data.slice(1, 33));
this.order = new BN(args.data.slice(33, 41), 'le');
this.winningConfigType = args.data[41];
this.amountType = args.data[42];
@ -752,7 +751,7 @@ export const SCHEMA = new Map<any, any>([
kind: 'struct',
fields: [
['key', 'u8'],
['metadata', 'pubkey'],
['metadata', 'pubkeyAsString'],
['supplySnapshot', 'u64'],
['expectedRedemptions', 'u64'],
['redemptions', 'u64'],
@ -765,11 +764,11 @@ export const SCHEMA = new Map<any, any>([
kind: 'struct',
fields: [
['key', 'u8'],
['store', 'pubkey'],
['authority', 'pubkey'],
['auction', 'pubkey'],
['vault', 'pubkey'],
['acceptPayment', 'pubkey'],
['store', 'pubkeyAsString'],
['authority', 'pubkeyAsString'],
['auction', 'pubkeyAsString'],
['vault', 'pubkeyAsString'],
['acceptPayment', 'pubkeyAsString'],
['state', AuctionManagerStateV2],
],
},
@ -792,7 +791,7 @@ export const SCHEMA = new Map<any, any>([
kind: 'struct',
fields: [
['key', 'u8'],
['address', 'pubkey'],
['address', 'pubkeyAsString'],
['activated', 'u8'],
],
},
@ -804,10 +803,10 @@ export const SCHEMA = new Map<any, any>([
fields: [
['key', 'u8'],
['public', 'u8'],
['auctionProgram', 'pubkey'],
['tokenVaultProgram', 'pubkey'],
['tokenMetadataProgram', 'pubkey'],
['tokenProgram', 'pubkey'],
['auctionProgram', 'pubkeyAsString'],
['tokenVaultProgram', 'pubkeyAsString'],
['tokenMetadataProgram', 'pubkeyAsString'],
['tokenProgram', 'pubkeyAsString'],
],
},
],
@ -836,7 +835,7 @@ export const SCHEMA = new Map<any, any>([
kind: 'struct',
fields: [
['key', 'u8'],
['recipient', 'pubkey'],
['recipient', 'pubkeyAsString'],
['amountPaid', 'u64'],
],
},
@ -857,7 +856,7 @@ export const SCHEMA = new Map<any, any>([
kind: 'struct',
fields: [
['key', 'u8'],
['auctionManager', 'pubkey'],
['auctionManager', 'pubkeyAsString'],
['order', 'u64'],
['winningConfigType', 'u8'],
['amountType', 'u8'],
@ -1014,32 +1013,32 @@ export const SCHEMA = new Map<any, any>([
]);
export async function getAuctionManagerKey(
vault: PublicKey,
auctionKey: PublicKey,
): Promise<PublicKey> {
vault: string,
auctionKey: string,
): Promise<string> {
const PROGRAM_IDS = programIds();
return (
await findProgramAddress(
[Buffer.from(METAPLEX_PREFIX), auctionKey.toBuffer()],
PROGRAM_IDS.metaplex,
[Buffer.from(METAPLEX_PREFIX), toPublicKey(auctionKey).toBuffer()],
toPublicKey(PROGRAM_IDS.metaplex),
)
)[0];
}
export async function getAuctionKeys(
vault: PublicKey,
): Promise<{ auctionKey: PublicKey; auctionManagerKey: PublicKey }> {
vault: string,
): Promise<{ auctionKey: string; auctionManagerKey: string }> {
const PROGRAM_IDS = programIds();
const auctionKey: PublicKey = (
const auctionKey = (
await findProgramAddress(
[
Buffer.from(AUCTION_PREFIX),
PROGRAM_IDS.auction.toBuffer(),
vault.toBuffer(),
toPublicKey(PROGRAM_IDS.auction).toBuffer(),
toPublicKey(vault).toBuffer(),
],
PROGRAM_IDS.auction,
toPublicKey(PROGRAM_IDS.auction),
)
)[0];
@ -1049,69 +1048,66 @@ export async function getAuctionKeys(
}
export async function getBidRedemption(
auctionKey: PublicKey,
bidMetadata: PublicKey,
): Promise<PublicKey> {
auctionKey: string,
bidMetadata: string,
): Promise<string> {
const PROGRAM_IDS = programIds();
return (
await findProgramAddress(
[
Buffer.from(METAPLEX_PREFIX),
auctionKey.toBuffer(),
bidMetadata.toBuffer(),
toPublicKey(auctionKey).toBuffer(),
toPublicKey(bidMetadata).toBuffer(),
],
PROGRAM_IDS.metaplex,
toPublicKey(PROGRAM_IDS.metaplex),
)
)[0];
}
export async function getBidderKeys(
auctionKey: PublicKey,
bidder: PublicKey,
): Promise<{ bidMetadata: PublicKey; bidRedemption: PublicKey }> {
auctionKey: string,
bidder: string,
): Promise<{ bidMetadata: string; bidRedemption: string }> {
const PROGRAM_IDS = programIds();
const bidMetadata: PublicKey = (
const bidMetadata = (
await findProgramAddress(
[
Buffer.from(AUCTION_PREFIX),
PROGRAM_IDS.auction.toBuffer(),
auctionKey.toBuffer(),
bidder.toBuffer(),
toPublicKey(PROGRAM_IDS.auction).toBuffer(),
toPublicKey(auctionKey).toBuffer(),
toPublicKey(bidder).toBuffer(),
Buffer.from(METADATA),
],
PROGRAM_IDS.auction,
toPublicKey(PROGRAM_IDS.auction),
)
)[0];
const bidRedemption: PublicKey = await getBidRedemption(
auctionKey,
bidMetadata,
);
const bidRedemption = await getBidRedemption(auctionKey, bidMetadata);
return { bidMetadata, bidRedemption };
}
export async function getOriginalAuthority(
auctionKey: PublicKey,
metadata: PublicKey,
): Promise<PublicKey> {
auctionKey: string,
metadata: string,
): Promise<string> {
const PROGRAM_IDS = programIds();
return (
await findProgramAddress(
[
Buffer.from(METAPLEX_PREFIX),
auctionKey.toBuffer(),
metadata.toBuffer(),
toPublicKey(auctionKey).toBuffer(),
toPublicKey(metadata).toBuffer(),
],
PROGRAM_IDS.metaplex,
toPublicKey(PROGRAM_IDS.metaplex),
)
)[0];
}
export async function getWhitelistedCreator(creator: PublicKey) {
export async function getWhitelistedCreator(creator: string) {
const PROGRAM_IDS = programIds();
const store = PROGRAM_IDS.store;
if (!store) {
@ -1122,18 +1118,18 @@ export async function getWhitelistedCreator(creator: PublicKey) {
await findProgramAddress(
[
Buffer.from(METAPLEX_PREFIX),
PROGRAM_IDS.metaplex.toBuffer(),
store.toBuffer(),
creator.toBuffer(),
toPublicKey(PROGRAM_IDS.metaplex).toBuffer(),
toPublicKey(store).toBuffer(),
toPublicKey(creator).toBuffer(),
],
PROGRAM_IDS.metaplex,
toPublicKey(PROGRAM_IDS.metaplex),
)
)[0];
}
export async function getPrizeTrackingTicket(
auctionManager: PublicKey,
mint: PublicKey,
auctionManager: string,
mint: string,
) {
const PROGRAM_IDS = programIds();
const store = PROGRAM_IDS.store;
@ -1145,18 +1141,16 @@ export async function getPrizeTrackingTicket(
await findProgramAddress(
[
Buffer.from(METAPLEX_PREFIX),
PROGRAM_IDS.metaplex.toBuffer(),
auctionManager.toBuffer(),
mint.toBuffer(),
toPublicKey(PROGRAM_IDS.metaplex).toBuffer(),
toPublicKey(auctionManager).toBuffer(),
toPublicKey(mint).toBuffer(),
],
PROGRAM_IDS.metaplex,
toPublicKey(PROGRAM_IDS.metaplex),
)
)[0];
}
export async function getAuctionWinnerTokenTypeTracker(
auctionManager: PublicKey,
) {
export async function getAuctionWinnerTokenTypeTracker(auctionManager: string) {
const PROGRAM_IDS = programIds();
const store = PROGRAM_IDS.store;
if (!store) {
@ -1167,18 +1161,18 @@ export async function getAuctionWinnerTokenTypeTracker(
await findProgramAddress(
[
Buffer.from(METAPLEX_PREFIX),
PROGRAM_IDS.metaplex.toBuffer(),
auctionManager.toBuffer(),
toPublicKey(PROGRAM_IDS.metaplex).toBuffer(),
toPublicKey(auctionManager).toBuffer(),
Buffer.from(TOTALS),
],
PROGRAM_IDS.metaplex,
toPublicKey(PROGRAM_IDS.metaplex),
)
)[0];
}
export async function getSafetyDepositConfig(
auctionManager: PublicKey,
safetyDeposit: PublicKey,
auctionManager: string,
safetyDeposit: string,
) {
const PROGRAM_IDS = programIds();
const store = PROGRAM_IDS.store;
@ -1190,22 +1184,22 @@ export async function getSafetyDepositConfig(
await findProgramAddress(
[
Buffer.from(METAPLEX_PREFIX),
PROGRAM_IDS.metaplex.toBuffer(),
auctionManager.toBuffer(),
safetyDeposit.toBuffer(),
toPublicKey(PROGRAM_IDS.metaplex).toBuffer(),
toPublicKey(auctionManager).toBuffer(),
toPublicKey(safetyDeposit).toBuffer(),
],
PROGRAM_IDS.metaplex,
toPublicKey(PROGRAM_IDS.metaplex),
)
)[0];
}
export async function getPayoutTicket(
auctionManager: PublicKey,
auctionManager: string,
winnerConfigIndex: number | null | undefined,
winnerConfigItemIndex: number | null | undefined,
creatorIndex: number | null | undefined,
safetyDepositBox: PublicKey,
recipient: PublicKey,
safetyDepositBox: string,
recipient: string,
) {
const PROGRAM_IDS = programIds();
@ -1213,7 +1207,7 @@ export async function getPayoutTicket(
await findProgramAddress(
[
Buffer.from(METAPLEX_PREFIX),
auctionManager.toBuffer(),
toPublicKey(auctionManager).toBuffer(),
Buffer.from(
winnerConfigIndex !== null && winnerConfigIndex !== undefined
? winnerConfigIndex.toString()
@ -1229,10 +1223,10 @@ export async function getPayoutTicket(
? creatorIndex.toString()
: 'auctioneer',
),
safetyDepositBox.toBuffer(),
recipient.toBuffer(),
toPublicKey(safetyDepositBox).toBuffer(),
toPublicKey(recipient).toBuffer(),
],
PROGRAM_IDS.metaplex,
toPublicKey(PROGRAM_IDS.metaplex),
)
)[0];
}

31
js/packages/web/src/models/metaplex/initAuctionManagerV2.ts
View File

@ -1,6 +1,5 @@
import { programIds } from '@oyster/common';
import { programIds, StringPublicKey, toPublicKey } from '@oyster/common';
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction,
@ -17,11 +16,11 @@ import {
} from '.';
export async function initAuctionManagerV2(
vault: PublicKey,
auctionManagerAuthority: PublicKey,
payer: PublicKey,
acceptPaymentAccount: PublicKey,
store: PublicKey,
vault: StringPublicKey,
auctionManagerAuthority: StringPublicKey,
payer: StringPublicKey,
acceptPaymentAccount: StringPublicKey,
store: StringPublicKey,
amountType: TupleNumericType,
lengthType: TupleNumericType,
maxRanges: BN,
@ -44,43 +43,43 @@ export async function initAuctionManagerV2(
const keys = [
{
pubkey: auctionManagerKey,
pubkey: toPublicKey(auctionManagerKey),
isSigner: false,
isWritable: true,
},
{
pubkey: tokenTracker,
pubkey: toPublicKey(tokenTracker),
isSigner: false,
isWritable: true,
},
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: false,
},
{
pubkey: auctionKey,
pubkey: toPublicKey(auctionKey),
isSigner: false,
isWritable: false,
},
{
pubkey: auctionManagerAuthority,
pubkey: toPublicKey(auctionManagerAuthority),
isSigner: false,
isWritable: false,
},
{
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: false,
},
{
pubkey: acceptPaymentAccount,
pubkey: toPublicKey(acceptPaymentAccount),
isSigner: false,
isWritable: false,
},
{
pubkey: store,
pubkey: toPublicKey(store),
isSigner: false,
isWritable: false,
},
@ -98,7 +97,7 @@ export async function initAuctionManagerV2(
instructions.push(
new TransactionInstruction({
keys,
programId: PROGRAM_IDS.metaplex,
programId: toPublicKey(PROGRAM_IDS.metaplex),
data,
}),
);

70
js/packages/web/src/models/metaplex/redeemBid.ts
View File

@ -5,7 +5,13 @@ import {
VAULT_PREFIX,
} from '@oyster/common';
import {
PublicKey,
findProgramAddress,
programIds,
StringPublicKey,
toPublicKey,
VAULT_PREFIX,
} from '@oyster/common';
import {
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction,
@ -23,15 +29,15 @@ import {
} from '.';
export async function redeemBid(
vault: PublicKey,
safetyDepositTokenStore: PublicKey,
destination: PublicKey,
safetyDeposit: PublicKey,
fractionMint: PublicKey,
bidder: PublicKey,
payer: PublicKey,
masterEdition: PublicKey | undefined,
reservationList: PublicKey | undefined,
vault: StringPublicKey,
safetyDepositTokenStore: StringPublicKey,
destination: StringPublicKey,
safetyDeposit: StringPublicKey,
fractionMint: StringPublicKey,
bidder: StringPublicKey,
payer: StringPublicKey,
masterEdition: StringPublicKey | undefined,
reservationList: StringPublicKey | undefined,
isPrintingType: boolean,
instructions: TransactionInstruction[],
// If this is an auctioneer trying to reclaim a specific winning index, pass it here,
@ -52,14 +58,14 @@ export async function redeemBid(
bidder,
);
const transferAuthority: PublicKey = (
const transferAuthority: StringPublicKey = (
await findProgramAddress(
[
Buffer.from(VAULT_PREFIX),
PROGRAM_IDS.vault.toBuffer(),
vault.toBuffer(),
toPublicKey(PROGRAM_IDS.vault).toBuffer(),
toPublicKey(vault).toBuffer(),
],
PROGRAM_IDS.vault,
toPublicKey(PROGRAM_IDS.vault),
)
)[0];
@ -83,57 +89,57 @@ export async function redeemBid(
const data = Buffer.from(serialize(SCHEMA, value));
const keys = [
{
pubkey: auctionManagerKey,
pubkey: toPublicKey(auctionManagerKey),
isSigner: false,
isWritable: true,
},
{
pubkey: safetyDepositTokenStore,
pubkey: toPublicKey(safetyDepositTokenStore),
isSigner: false,
isWritable: true,
},
{
pubkey: destination,
pubkey: toPublicKey(destination),
isSigner: false,
isWritable: true,
},
{
pubkey: bidRedemption,
pubkey: toPublicKey(bidRedemption),
isSigner: false,
isWritable: true,
},
{
pubkey: safetyDeposit,
pubkey: toPublicKey(safetyDeposit),
isSigner: false,
isWritable: true,
},
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: true,
},
{
pubkey: fractionMint,
pubkey: toPublicKey(fractionMint),
isSigner: false,
isWritable: true,
},
{
pubkey: auctionKey,
pubkey: toPublicKey(auctionKey),
isSigner: false,
isWritable: false,
},
{
pubkey: bidMetadata,
pubkey: toPublicKey(bidMetadata),
isSigner: false,
isWritable: false,
},
{
pubkey: bidder,
pubkey: toPublicKey(bidder),
isSigner: false,
isWritable: false,
},
{
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: false,
},
@ -143,12 +149,12 @@ export async function redeemBid(
isWritable: false,
},
{
pubkey: PROGRAM_IDS.vault,
pubkey: toPublicKey(PROGRAM_IDS.vault),
isSigner: false,
isWritable: false,
},
{
pubkey: PROGRAM_IDS.metadata,
pubkey: toPublicKey(PROGRAM_IDS.metadata),
isSigner: false,
isWritable: false,
},
@ -168,12 +174,12 @@ export async function redeemBid(
isWritable: false,
},
{
pubkey: transferAuthority,
pubkey: toPublicKey(transferAuthority),
isSigner: false,
isWritable: false,
},
{
pubkey: safetyDepositConfig,
pubkey: toPublicKey(safetyDepositConfig),
isSigner: false,
isWritable: false,
},
@ -186,12 +192,12 @@ export async function redeemBid(
if (isPrintingType && masterEdition && reservationList) {
keys.push({
pubkey: masterEdition,
pubkey: toPublicKey(masterEdition),
isSigner: false,
isWritable: true,
});
keys.push({
pubkey: reservationList,
pubkey: toPublicKey(reservationList),
isSigner: false,
isWritable: true,
});
@ -200,7 +206,7 @@ export async function redeemBid(
instructions.push(
new TransactionInstruction({
keys,
programId: PROGRAM_IDS.metaplex,
programId: toPublicKey(PROGRAM_IDS.metaplex),
data,
}),
);

66
js/packages/web/src/models/metaplex/redeemFullRightsTransferBid.ts
View File

@ -2,10 +2,10 @@ import {
programIds,
VAULT_PREFIX,
findProgramAddress,
getAuctionExtended,
StringPublicKey,
toPublicKey,
} from '@oyster/common';
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction,
@ -23,16 +23,16 @@ import {
} from '.';
export async function redeemFullRightsTransferBid(
vault: PublicKey,
safetyDepositTokenStore: PublicKey,
destination: PublicKey,
safetyDeposit: PublicKey,
fractionMint: PublicKey,
bidder: PublicKey,
payer: PublicKey,
vault: StringPublicKey,
safetyDepositTokenStore: StringPublicKey,
destination: StringPublicKey,
safetyDeposit: StringPublicKey,
fractionMint: StringPublicKey,
bidder: StringPublicKey,
payer: StringPublicKey,
instructions: TransactionInstruction[],
masterMetadata: PublicKey,
newAuthority: PublicKey,
masterMetadata: StringPublicKey,
newAuthority: StringPublicKey,
// If this is an auctioneer trying to reclaim a specific winning index, pass it here,
// and this will instead call the proxy route instead of the real one, wrapping the original
// redemption call in an override call that forces the winning index if the auctioneer is authorized.
@ -51,14 +51,14 @@ export async function redeemFullRightsTransferBid(
bidder,
);
const transferAuthority: PublicKey = (
const transferAuthority = (
await findProgramAddress(
[
Buffer.from(VAULT_PREFIX),
PROGRAM_IDS.vault.toBuffer(),
vault.toBuffer(),
toPublicKey(PROGRAM_IDS.vault).toBuffer(),
toPublicKey(vault).toBuffer(),
],
PROGRAM_IDS.vault,
toPublicKey(PROGRAM_IDS.vault),
)
)[0];
@ -82,57 +82,57 @@ export async function redeemFullRightsTransferBid(
const data = Buffer.from(serialize(SCHEMA, value));
const keys = [
{
pubkey: auctionManagerKey,
pubkey: toPublicKey(auctionManagerKey),
isSigner: false,
isWritable: true,
},
{
pubkey: safetyDepositTokenStore,
pubkey: toPublicKey(safetyDepositTokenStore),
isSigner: false,
isWritable: true,
},
{
pubkey: destination,
pubkey: toPublicKey(destination),
isSigner: false,
isWritable: true,
},
{
pubkey: bidRedemption,
pubkey: toPublicKey(bidRedemption),
isSigner: false,
isWritable: true,
},
{
pubkey: safetyDeposit,
pubkey: toPublicKey(safetyDeposit),
isSigner: false,
isWritable: true,
},
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: true,
},
{
pubkey: fractionMint,
pubkey: toPublicKey(fractionMint),
isSigner: false,
isWritable: true,
},
{
pubkey: auctionKey,
pubkey: toPublicKey(auctionKey),
isSigner: false,
isWritable: false,
},
{
pubkey: bidMetadata,
pubkey: toPublicKey(bidMetadata),
isSigner: false,
isWritable: false,
},
{
pubkey: bidder,
pubkey: toPublicKey(bidder),
isSigner: false,
isWritable: false,
},
{
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: false,
},
@ -142,12 +142,12 @@ export async function redeemFullRightsTransferBid(
isWritable: false,
},
{
pubkey: PROGRAM_IDS.vault,
pubkey: toPublicKey(PROGRAM_IDS.vault),
isSigner: false,
isWritable: false,
},
{
pubkey: PROGRAM_IDS.metadata,
pubkey: toPublicKey(PROGRAM_IDS.metadata),
isSigner: false,
isWritable: false,
},
@ -167,22 +167,22 @@ export async function redeemFullRightsTransferBid(
isWritable: false,
},
{
pubkey: masterMetadata,
pubkey: toPublicKey(masterMetadata),
isSigner: false,
isWritable: true,
},
{
pubkey: newAuthority,
pubkey: toPublicKey(newAuthority),
isSigner: false,
isWritable: false,
},
{
pubkey: transferAuthority,
pubkey: toPublicKey(transferAuthority),
isSigner: false,
isWritable: false,
},
{
pubkey: safetyDepositConfig,
pubkey: toPublicKey(safetyDepositConfig),
isSigner: false,
isWritable: false,
},
@ -197,7 +197,7 @@ export async function redeemFullRightsTransferBid(
instructions.push(
new TransactionInstruction({
keys,
programId: PROGRAM_IDS.metaplex,
programId: toPublicKey(PROGRAM_IDS.metaplex),
data,
}),
);

87
js/packages/web/src/models/metaplex/redeemParticipationBidV3.ts
View File

@ -2,13 +2,12 @@ import {
getEdition,
programIds,
getMetadata,
findProgramAddress,
VAULT_PREFIX,
getEditionMarkPda,
getAuctionExtended,
StringPublicKey,
toPublicKey,
} from '@oyster/common';
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction,
@ -26,19 +25,19 @@ import {
} from '.';
export async function redeemParticipationBidV3(
vault: PublicKey,
safetyDepositTokenStore: PublicKey,
destination: PublicKey,
safetyDeposit: PublicKey,
bidder: PublicKey,
payer: PublicKey,
metadata: PublicKey,
masterEdition: PublicKey,
originalMint: PublicKey,
transferAuthority: PublicKey,
acceptPaymentAccount: PublicKey,
tokenPaymentAccount: PublicKey,
newMint: PublicKey,
vault: StringPublicKey,
safetyDepositTokenStore: StringPublicKey,
destination: StringPublicKey,
safetyDeposit: StringPublicKey,
bidder: StringPublicKey,
payer: StringPublicKey,
metadata: StringPublicKey,
masterEdition: StringPublicKey,
originalMint: StringPublicKey,
transferAuthority: StringPublicKey,
acceptPaymentAccount: StringPublicKey,
tokenPaymentAccount: StringPublicKey,
newMint: StringPublicKey,
edition: BN,
winIndex: BN | null,
instructions: TransactionInstruction[],
@ -79,57 +78,57 @@ export async function redeemParticipationBidV3(
const data = Buffer.from(serialize(SCHEMA, value));
const keys = [
{
pubkey: auctionManagerKey,
pubkey: toPublicKey(auctionManagerKey),
isSigner: false,
isWritable: true,
},
{
pubkey: safetyDepositTokenStore,
pubkey: toPublicKey(safetyDepositTokenStore),
isSigner: false,
isWritable: true,
},
{
pubkey: destination,
pubkey: toPublicKey(destination),
isSigner: false,
isWritable: true,
},
{
pubkey: bidRedemption,
pubkey: toPublicKey(bidRedemption),
isSigner: false,
isWritable: true,
},
{
pubkey: safetyDeposit,
pubkey: toPublicKey(safetyDeposit),
isSigner: false,
isWritable: false,
},
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: false,
},
{
pubkey: safetyDepositConfig,
pubkey: toPublicKey(safetyDepositConfig),
isSigner: false,
isWritable: true,
},
{
pubkey: auctionKey,
pubkey: toPublicKey(auctionKey),
isSigner: false,
isWritable: false,
},
{
pubkey: bidMetadata,
pubkey: toPublicKey(bidMetadata),
isSigner: false,
isWritable: false,
},
{
pubkey: bidder,
pubkey: toPublicKey(bidder),
isSigner: false,
isWritable: true,
},
{
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: true,
},
@ -139,12 +138,12 @@ export async function redeemParticipationBidV3(
isWritable: false,
},
{
pubkey: PROGRAM_IDS.vault,
pubkey: toPublicKey(PROGRAM_IDS.vault),
isSigner: false,
isWritable: false,
},
{
pubkey: PROGRAM_IDS.metadata,
pubkey: toPublicKey(PROGRAM_IDS.metadata),
isSigner: false,
isWritable: false,
},
@ -164,47 +163,47 @@ export async function redeemParticipationBidV3(
isWritable: false,
},
{
pubkey: transferAuthority,
pubkey: toPublicKey(transferAuthority),
isSigner: true,
isWritable: false,
},
{
pubkey: acceptPaymentAccount,
pubkey: toPublicKey(acceptPaymentAccount),
isSigner: false,
isWritable: true,
},
{
pubkey: tokenPaymentAccount,
pubkey: toPublicKey(tokenPaymentAccount),
isSigner: false,
isWritable: true,
},
{
pubkey: prizeTrackingTicket,
pubkey: toPublicKey(prizeTrackingTicket),
isSigner: false,
isWritable: true,
},
{
pubkey: newMetadata,
pubkey: toPublicKey(newMetadata),
isSigner: false,
isWritable: true,
},
{
pubkey: newEdition,
pubkey: toPublicKey(newEdition),
isSigner: false,
isWritable: true,
},
{
pubkey: masterEdition,
pubkey: toPublicKey(masterEdition),
isSigner: false,
isWritable: true,
},
{
pubkey: newMint,
pubkey: toPublicKey(newMint),
isSigner: false,
isWritable: true,
},
{
pubkey: editionMarkPda,
pubkey: toPublicKey(editionMarkPda),
isSigner: false,
isWritable: true,
},
@ -213,23 +212,27 @@ export async function redeemParticipationBidV3(
// may not be signer hre - we may be redeeming for someone else (permissionless)
// and during the txn, mint authority is removed from us and given to master edition.
// The ATA account is already owned by bidder by default. No signing needed
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: false,
},
{
pubkey: metadata,
pubkey: toPublicKey(metadata),
isSigner: false,
isWritable: false,
},
{ pubkey: auctionDataExtended, isSigner: false, isWritable: false },
{
pubkey: toPublicKey(auctionDataExtended),
isSigner: false,
isWritable: false,
},
];
instructions.push(
new TransactionInstruction({
keys,
programId: PROGRAM_IDS.metaplex,
programId: toPublicKey(PROGRAM_IDS.metaplex),
data,
}),
);

69
js/packages/web/src/models/metaplex/redeemPrintingV2Bid.ts
View File

@ -1,13 +1,12 @@
import {
findProgramAddress,
getEdition,
getEditionMarkPda,
getMetadata,
programIds,
VAULT_PREFIX,
StringPublicKey,
toPublicKey,
} from '@oyster/common';
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction,
@ -25,16 +24,16 @@ import {
} from '.';
export async function redeemPrintingV2Bid(
vault: PublicKey,
safetyDepositTokenStore: PublicKey,
tokenAccount: PublicKey,
safetyDeposit: PublicKey,
bidder: PublicKey,
payer: PublicKey,
metadata: PublicKey,
masterEdition: PublicKey,
originalMint: PublicKey,
newMint: PublicKey,
vault: StringPublicKey,
safetyDepositTokenStore: StringPublicKey,
tokenAccount: StringPublicKey,
safetyDeposit: StringPublicKey,
bidder: StringPublicKey,
payer: StringPublicKey,
metadata: StringPublicKey,
masterEdition: StringPublicKey,
originalMint: StringPublicKey,
newMint: StringPublicKey,
edition: BN,
editionOffset: BN,
winIndex: BN,
@ -72,57 +71,57 @@ export async function redeemPrintingV2Bid(
const data = Buffer.from(serialize(SCHEMA, value));
const keys = [
{
pubkey: auctionManagerKey,
pubkey: toPublicKey(auctionManagerKey),
isSigner: false,
isWritable: true,
},
{
pubkey: safetyDepositTokenStore,
pubkey: toPublicKey(safetyDepositTokenStore),
isSigner: false,
isWritable: true,
},
{
pubkey: tokenAccount,
pubkey: toPublicKey(tokenAccount),
isSigner: false,
isWritable: true,
},
{
pubkey: bidRedemption,
pubkey: toPublicKey(bidRedemption),
isSigner: false,
isWritable: true,
},
{
pubkey: safetyDeposit,
pubkey: toPublicKey(safetyDeposit),
isSigner: false,
isWritable: true,
},
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: true,
},
{
pubkey: safetyDepositConfig,
pubkey: toPublicKey(safetyDepositConfig),
isSigner: false,
isWritable: false,
},
{
pubkey: auctionKey,
pubkey: toPublicKey(auctionKey),
isSigner: false,
isWritable: false,
},
{
pubkey: bidMetadata,
pubkey: toPublicKey(bidMetadata),
isSigner: false,
isWritable: false,
},
{
pubkey: bidder,
pubkey: toPublicKey(bidder),
isSigner: false,
isWritable: false,
},
{
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: true,
},
@ -132,12 +131,12 @@ export async function redeemPrintingV2Bid(
isWritable: false,
},
{
pubkey: PROGRAM_IDS.vault,
pubkey: toPublicKey(PROGRAM_IDS.vault),
isSigner: false,
isWritable: false,
},
{
pubkey: PROGRAM_IDS.metadata,
pubkey: toPublicKey(PROGRAM_IDS.metadata),
isSigner: false,
isWritable: false,
},
@ -157,32 +156,32 @@ export async function redeemPrintingV2Bid(
isWritable: false,
},
{
pubkey: prizeTrackingTicket,
pubkey: toPublicKey(prizeTrackingTicket),
isSigner: false,
isWritable: true,
},
{
pubkey: newMetadata,
pubkey: toPublicKey(newMetadata),
isSigner: false,
isWritable: true,
},
{
pubkey: newEdition,
pubkey: toPublicKey(newEdition),
isSigner: false,
isWritable: true,
},
{
pubkey: masterEdition,
pubkey: toPublicKey(masterEdition),
isSigner: false,
isWritable: true,
},
{
pubkey: newMint,
pubkey: toPublicKey(newMint),
isSigner: false,
isWritable: true,
},
{
pubkey: editionMarkPda,
pubkey: toPublicKey(editionMarkPda),
isSigner: false,
isWritable: true,
},
@ -191,12 +190,12 @@ export async function redeemPrintingV2Bid(
// may not be signer hre - we may be redeeming for someone else (permissionless)
// and during the txn, mint authority is removed from us and given to master edition.
// The ATA account is already owned by bidder by default. No signing needed
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: false,
},
{
pubkey: metadata,
pubkey: toPublicKey(metadata),
isSigner: false,
isWritable: false,
},
@ -205,7 +204,7 @@ export async function redeemPrintingV2Bid(
instructions.push(
new TransactionInstruction({
keys,
programId: PROGRAM_IDS.metaplex,
programId: toPublicKey(PROGRAM_IDS.metaplex),
data,
}),
);

38
js/packages/web/src/models/metaplex/setStore.ts
View File

@ -1,17 +1,13 @@
import { programIds } from '@oyster/common';
import {
PublicKey,
SYSVAR_RENT_PUBKEY,
TransactionInstruction,
} from '@solana/web3.js';
import { programIds, StringPublicKey, toPublicKey } from '@oyster/common';
import { SYSVAR_RENT_PUBKEY, TransactionInstruction } from '@solana/web3.js';
import { serialize } from 'borsh';
import { SCHEMA, SetStoreArgs } from '.';
export async function setStore(
isPublic: boolean,
admin: PublicKey,
payer: PublicKey,
admin: StringPublicKey,
payer: StringPublicKey,
instructions: TransactionInstruction[],
) {
const PROGRAM_IDS = programIds();
@ -25,24 +21,36 @@ export async function setStore(
const keys = [
{
pubkey: store,
pubkey: toPublicKey(store),
isSigner: false,
isWritable: true,
},
{
pubkey: admin,
pubkey: toPublicKey(admin),
isSigner: true,
isWritable: false,
},
{
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: false,
},
{ pubkey: PROGRAM_IDS.token, isSigner: false, isWritable: false },
{ pubkey: PROGRAM_IDS.vault, isSigner: false, isWritable: false },
{ pubkey: PROGRAM_IDS.metadata, isSigner: false, isWritable: false },
{ pubkey: PROGRAM_IDS.auction, isSigner: false, isWritable: false },
{
pubkey: toPublicKey(PROGRAM_IDS.vault),
isSigner: false,
isWritable: false,
},
{
pubkey: toPublicKey(PROGRAM_IDS.metadata),
isSigner: false,
isWritable: false,
},
{
pubkey: toPublicKey(PROGRAM_IDS.auction),
isSigner: false,
isWritable: false,
},
{
pubkey: PROGRAM_IDS.system,
isSigner: false,
@ -58,7 +66,7 @@ export async function setStore(
instructions.push(
new TransactionInstruction({
keys,
programId: PROGRAM_IDS.metaplex,
programId: toPublicKey(PROGRAM_IDS.metaplex),
data,
}),
);

24
js/packages/web/src/models/metaplex/setWhitelistedCreator.ts
View File

@ -1,18 +1,14 @@
import { programIds } from '@oyster/common';
import {
PublicKey,
SYSVAR_RENT_PUBKEY,
TransactionInstruction,
} from '@solana/web3.js';
import { programIds, StringPublicKey, toPublicKey } from '@oyster/common';
import { SYSVAR_RENT_PUBKEY, TransactionInstruction } from '@solana/web3.js';
import { serialize } from 'borsh';
import { getWhitelistedCreator, SCHEMA, SetWhitelistedCreatorArgs } from '.';
export async function setWhitelistedCreator(
creator: PublicKey,
creator: StringPublicKey,
activated: boolean,
admin: PublicKey,
payer: PublicKey,
admin: StringPublicKey,
payer: StringPublicKey,
instructions: TransactionInstruction[],
) {
const PROGRAM_IDS = programIds();
@ -28,22 +24,22 @@ export async function setWhitelistedCreator(
const keys = [
{
pubkey: whitelistedCreatorPDAKey,
pubkey: toPublicKey(whitelistedCreatorPDAKey),
isSigner: false,
isWritable: true,
},
{
pubkey: admin,
pubkey: toPublicKey(admin),
isSigner: true,
isWritable: false,
},
{
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: false,
},
{
pubkey: creator,
pubkey: toPublicKey(creator),
isSigner: false,
isWritable: false,
},
@ -67,7 +63,7 @@ export async function setWhitelistedCreator(
instructions.push(
new TransactionInstruction({
keys,
programId: PROGRAM_IDS.metaplex,
programId: toPublicKey(PROGRAM_IDS.metaplex),
data,
}),
);

22
js/packages/web/src/models/metaplex/startAuction.ts
View File

@ -1,16 +1,12 @@
import { programIds } from '@oyster/common';
import {
PublicKey,
SYSVAR_CLOCK_PUBKEY,
TransactionInstruction,
} from '@solana/web3.js';
import { programIds, StringPublicKey, toPublicKey } from '@oyster/common';
import { SYSVAR_CLOCK_PUBKEY, TransactionInstruction } from '@solana/web3.js';
import { serialize } from 'borsh';
import { getAuctionKeys, SCHEMA, StartAuctionArgs } from '.';
export async function startAuction(
vault: PublicKey,
auctionManagerAuthority: PublicKey,
vault: StringPublicKey,
auctionManagerAuthority: StringPublicKey,
instructions: TransactionInstruction[],
) {
const PROGRAM_IDS = programIds();
@ -26,17 +22,17 @@ export async function startAuction(
const keys = [
{
pubkey: auctionManagerKey,
pubkey: toPublicKey(auctionManagerKey),
isSigner: false,
isWritable: true,
},
{
pubkey: auctionKey,
pubkey: toPublicKey(auctionKey),
isSigner: false,
isWritable: true,
},
{
pubkey: auctionManagerAuthority,
pubkey: toPublicKey(auctionManagerAuthority),
isSigner: true,
isWritable: false,
},
@ -46,7 +42,7 @@ export async function startAuction(
isWritable: false,
},
{
pubkey: PROGRAM_IDS.auction,
pubkey: toPublicKey(PROGRAM_IDS.auction),
isSigner: false,
isWritable: false,
},
@ -61,7 +57,7 @@ export async function startAuction(
instructions.push(
new TransactionInstruction({
keys,
programId: PROGRAM_IDS.metaplex,
programId: toPublicKey(PROGRAM_IDS.metaplex),
data,
}),
);

61
js/packages/web/src/models/metaplex/validateSafetyDepositBoxV2.ts
View File

@ -1,6 +1,5 @@
import { programIds, getEdition } from '@oyster/common';
import { programIds, toPublicKey, StringPublicKey } from '@oyster/common';
import {
PublicKey,
SystemProgram,
SYSVAR_RENT_PUBKEY,
TransactionInstruction,
@ -18,25 +17,25 @@ import {
} from '.';
export async function validateSafetyDepositBoxV2(
vault: PublicKey,
metadata: PublicKey,
safetyDepositBox: PublicKey,
safetyDepositTokenStore: PublicKey,
tokenMint: PublicKey,
auctionManagerAuthority: PublicKey,
metadataAuthority: PublicKey,
payer: PublicKey,
vault: StringPublicKey,
metadata: StringPublicKey,
safetyDepositBox: StringPublicKey,
safetyDepositTokenStore: StringPublicKey,
tokenMint: StringPublicKey,
auctionManagerAuthority: StringPublicKey,
metadataAuthority: StringPublicKey,
payer: StringPublicKey,
instructions: TransactionInstruction[],
edition: PublicKey,
whitelistedCreator: PublicKey | undefined,
store: PublicKey,
edition: StringPublicKey,
whitelistedCreator: StringPublicKey | undefined,
store: StringPublicKey,
safetyDepositConfig: SafetyDepositConfig,
) {
const PROGRAM_IDS = programIds();
const { auctionKey, auctionManagerKey } = await getAuctionKeys(vault);
const originalAuthorityLookup: PublicKey = await getOriginalAuthority(
const originalAuthorityLookup = await getOriginalAuthority(
auctionKey,
metadata,
);
@ -55,83 +54,83 @@ export async function validateSafetyDepositBoxV2(
const keys = [
{
pubkey: safetyDepositConfigKey,
pubkey: toPublicKey(safetyDepositConfigKey),
isSigner: false,
isWritable: true,
},
{
pubkey: tokenTracker,
pubkey: toPublicKey(tokenTracker),
isSigner: false,
isWritable: true,
},
{
pubkey: auctionManagerKey,
pubkey: toPublicKey(auctionManagerKey),
isSigner: false,
isWritable: true,
},
{
pubkey: metadata,
pubkey: toPublicKey(metadata),
isSigner: false,
isWritable: true,
},
{
pubkey: originalAuthorityLookup,
pubkey: toPublicKey(originalAuthorityLookup),
isSigner: false,
isWritable: true,
},
{
pubkey: whitelistedCreator || SystemProgram.programId,
pubkey: toPublicKey(whitelistedCreator || SystemProgram.programId),
isSigner: false,
isWritable: false,
},
{
pubkey: store,
pubkey: toPublicKey(store),
isSigner: false,
isWritable: false,
},
{
pubkey: safetyDepositBox,
pubkey: toPublicKey(safetyDepositBox),
isSigner: false,
isWritable: false,
},
{
pubkey: safetyDepositTokenStore,
pubkey: toPublicKey(safetyDepositTokenStore),
isSigner: false,
isWritable: false,
},
{
pubkey: tokenMint,
pubkey: toPublicKey(tokenMint),
isSigner: false,
isWritable: false,
},
{
pubkey: edition,
pubkey: toPublicKey(edition),
isSigner: false,
isWritable: false,
},
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: false,
},
{
pubkey: auctionManagerAuthority,
pubkey: toPublicKey(auctionManagerAuthority),
isSigner: true,
isWritable: false,
},
{
pubkey: metadataAuthority,
pubkey: toPublicKey(metadataAuthority),
isSigner: true,
isWritable: false,
},
{
pubkey: payer,
pubkey: toPublicKey(payer),
isSigner: true,
isWritable: false,
},
{
pubkey: PROGRAM_IDS.metadata,
pubkey: toPublicKey(PROGRAM_IDS.metadata),
isSigner: false,
isWritable: false,
},
@ -150,7 +149,7 @@ export async function validateSafetyDepositBoxV2(
instructions.push(
new TransactionInstruction({
keys,
programId: PROGRAM_IDS.metaplex,
programId: toPublicKey(PROGRAM_IDS.metaplex),
data,
}),
);

64
js/packages/web/src/models/metaplex/withdrawMasterEdition.ts
View File

@ -3,13 +3,11 @@ import {
EXTENDED,
findProgramAddress,
programIds,
StringPublicKey,
toPublicKey,
VAULT_PREFIX,
} from '@oyster/common';
import {
PublicKey,
SYSVAR_RENT_PUBKEY,
TransactionInstruction,
} from '@solana/web3.js';
import { SYSVAR_RENT_PUBKEY, TransactionInstruction } from '@solana/web3.js';
import { serialize } from 'borsh';
import {
@ -21,12 +19,12 @@ import {
} from '.';
export async function withdrawMasterEdition(
vault: PublicKey,
safetyDepositTokenStore: PublicKey,
destination: PublicKey,
safetyDeposit: PublicKey,
fractionMint: PublicKey,
mint: PublicKey,
vault: StringPublicKey,
safetyDepositTokenStore: StringPublicKey,
destination: StringPublicKey,
safetyDeposit: StringPublicKey,
fractionMint: StringPublicKey,
mint: StringPublicKey,
instructions: TransactionInstruction[],
) {
const PROGRAM_IDS = programIds();
@ -41,26 +39,26 @@ export async function withdrawMasterEdition(
auctionManagerKey,
mint,
);
const vaultAuthority: PublicKey = (
const vaultAuthority = (
await findProgramAddress(
[
Buffer.from(VAULT_PREFIX),
PROGRAM_IDS.vault.toBuffer(),
vault.toBuffer(),
toPublicKey(PROGRAM_IDS.vault).toBuffer(),
toPublicKey(vault).toBuffer(),
],
PROGRAM_IDS.vault,
toPublicKey(PROGRAM_IDS.vault),
)
)[0];
const auctionExtended: PublicKey = (
const auctionExtended = (
await findProgramAddress(
[
Buffer.from(AUCTION_PREFIX),
PROGRAM_IDS.auction.toBuffer(),
vault.toBuffer(),
toPublicKey(PROGRAM_IDS.auction).toBuffer(),
toPublicKey(vault).toBuffer(),
Buffer.from(EXTENDED),
],
PROGRAM_IDS.auction,
toPublicKey(PROGRAM_IDS.auction),
)
)[0];
@ -73,52 +71,52 @@ export async function withdrawMasterEdition(
const data = Buffer.from(serialize(SCHEMA, value));
const keys = [
{
pubkey: auctionManagerKey,
pubkey: toPublicKey(auctionManagerKey),
isSigner: false,
isWritable: true,
},
{
pubkey: safetyDepositTokenStore,
pubkey: toPublicKey(safetyDepositTokenStore),
isSigner: false,
isWritable: true,
},
{
pubkey: destination,
pubkey: toPublicKey(destination),
isSigner: false,
isWritable: true,
},
{
pubkey: safetyDeposit,
pubkey: toPublicKey(safetyDeposit),
isSigner: false,
isWritable: true,
},
{
pubkey: vault,
pubkey: toPublicKey(vault),
isSigner: false,
isWritable: true,
},
{
pubkey: fractionMint,
pubkey: toPublicKey(fractionMint),
isSigner: false,
isWritable: true,
},
{
pubkey: prizeTrackingTicket,
pubkey: toPublicKey(prizeTrackingTicket),
isSigner: false,
isWritable: false,
},
{
pubkey: vaultAuthority,
pubkey: toPublicKey(vaultAuthority),
isSigner: false,
isWritable: false,
},
{
pubkey: auctionKey,
pubkey: toPublicKey(auctionKey),
isSigner: false,
isWritable: false,
},
{
pubkey: auctionExtended,
pubkey: toPublicKey(auctionExtended),
isSigner: false,
isWritable: false,
},
@ -128,12 +126,12 @@ export async function withdrawMasterEdition(
isWritable: false,
},
{
pubkey: PROGRAM_IDS.vault,
pubkey: toPublicKey(PROGRAM_IDS.vault),
isSigner: false,
isWritable: false,
},
{
pubkey: store,
pubkey: toPublicKey(store),
isSigner: false,
isWritable: false,
},
@ -143,7 +141,7 @@ export async function withdrawMasterEdition(
isWritable: false,
},
{
pubkey: safetyDepositConfig,
pubkey: toPublicKey(safetyDepositConfig),
isSigner: false,
isWritable: false,
},
@ -152,7 +150,7 @@ export async function withdrawMasterEdition(
instructions.push(
new TransactionInstruction({
keys,
programId: PROGRAM_IDS.metaplex,
programId: toPublicKey(PROGRAM_IDS.metaplex),
data,
}),
);

10
js/packages/web/src/utils/isValidHttpUrl.ts
View File

@ -1,11 +1,7 @@
export function isValidHttpUrl(text: string) {
let url;
try {
url = new URL(text);
} catch (_) {
return false;
if (text.startsWith('http:') || text.startsWith('https:')) {
return true;
}
return url.protocol === 'http:' || url.protocol === 'https:';
return false;
}

15
js/packages/web/src/views/admin/index.tsx
View File

@ -20,8 +20,9 @@ import {
useConnection,
useUserAccounts,
useWallet,
StringPublicKey,
} from '@oyster/common';
import { Connection, PublicKey } from '@solana/web3.js';
import { Connection } from '@solana/web3.js';
import { saveAdmin } from '../../actions/saveAdmin';
import { WalletAdapter } from '@solana/wallet-base';
import { useMemo } from 'react';
@ -78,9 +79,9 @@ function ArtistModal({
return;
}
let address: PublicKey;
let address: StringPublicKey;
try {
address = new PublicKey(addressToAdd);
address = addressToAdd;
setUpdatedCreators(u => ({
...u,
[modalAddress]: new WhitelistedCreator({
@ -160,7 +161,7 @@ function InnerAdminView({
const uniqueCreators = Object.values(whitelistedCreatorsByCreator).reduce(
(acc: Record<string, WhitelistedCreator>, e) => {
acc[e.info.address.toBase58()] = e.info;
acc[e.info.address] = e.info;
return acc;
},
{},
@ -177,7 +178,7 @@ function InnerAdminView({
{
title: 'Address',
dataIndex: 'address',
render: (val: PublicKey) => <span>{val.toBase58()}</span>,
render: (val: StringPublicKey) => <span>{val}</span>,
key: 'address',
},
{
@ -187,7 +188,7 @@ function InnerAdminView({
render: (
value: boolean,
record: {
address: PublicKey;
address: StringPublicKey;
activated: boolean;
name: string;
key: string;
@ -268,7 +269,7 @@ function InnerAdminView({
name:
uniqueCreatorsWithUpdates[key].name ||
shortenAddress(
uniqueCreatorsWithUpdates[key].address.toBase58(),
uniqueCreatorsWithUpdates[key].address,
),
image: uniqueCreatorsWithUpdates[key].image,
}))}

28
js/packages/web/src/views/analytics/index.tsx
View File

@ -91,18 +91,18 @@ const rerun = async ({
// are probably a minority anyway.
if (
auction.auction.info.ended() &&
auction.auction.info.tokenMint.equals(QUOTE_MINT)
auction.auction.info.tokenMint === QUOTE_MINT.toBase58()
) {
if (!LOOKUP[auction.auction.pubkey.toBase58()]) {
LOOKUP[auction.auction.pubkey.toBase58()] = (
if (!LOOKUP[auction.auction.pubkey]) {
LOOKUP[auction.auction.pubkey] = (
await getAuctionExtended({
auctionProgramId: PROGRAM_IDS.auction,
resource: auction.vault.pubkey,
})
).toBase58();
);
}
const extended =
auctionDataExtended[LOOKUP[auction.auction.pubkey.toBase58()]];
auctionDataExtended[LOOKUP[auction.auction.pubkey]];
if (extended && extended.info.totalUncancelledBids.toNumber() > 0) {
totalAuctions++;
averageBidders += extended.info.totalUncancelledBids.toNumber();
@ -119,8 +119,8 @@ const rerun = async ({
}
}
newUsersPublished[auction.auctionManager.authority.toBase58()] = true;
existingUsersEngaged[auction.auctionManager.authority.toBase58()] = true;
newUsersPublished[auction.auctionManager.authority] = true;
existingUsersEngaged[auction.auctionManager.authority] = true;
let type: AuctionType | undefined = undefined;
if (auction.items.find(set => set.length > 1)) {
@ -140,19 +140,19 @@ const rerun = async ({
const newUsersBid: Record<string, boolean> = {};
Object.values(bidderPotsByAuctionAndBidder).forEach(acct => {
if (auctionManagersByAuction[acct.info.auctionAct.toBase58()]) {
newUsersBid[acct.info.bidderAct.toBase58()] = true;
existingUsersEngaged[acct.info.bidderAct.toBase58()] = true;
if (auctionManagersByAuction[acct.info.auctionAct]) {
newUsersBid[acct.info.bidderAct] = true;
existingUsersEngaged[acct.info.bidderAct] = true;
}
});
const newBuild: Record<string, boolean> = {};
metadata.forEach(acct => {
newBuild[acct.info.updateAuthority.toBase58()] = true;
existingUsersEngaged[acct.info.updateAuthority.toBase58()] = true;
newBuild[acct.info.updateAuthority] = true;
existingUsersEngaged[acct.info.updateAuthority] = true;
acct.info.data.creators?.forEach(c => {
newBuild[c.address.toBase58()] = true;
existingUsersEngaged[c.address.toBase58()] = true;
newBuild[c.address] = true;
existingUsersEngaged[c.address] = true;
});
});

3
js/packages/web/src/views/art/index.tsx
View File

@ -7,7 +7,6 @@ import { ArtContent } from '../../components/ArtContent';
import { shortenAddress, useConnection, useWallet } from '@oyster/common';
import { MetaAvatar } from '../../components/MetaAvatar';
import { sendSignMetadata } from '../../actions/sendSignMetadata';
import { PublicKey } from '@solana/web3.js';
import { ViewOn } from './../../components/ViewOn';
import { ArtType } from '../../types';
@ -126,7 +125,7 @@ export const ArtView = () => {
await sendSignMetadata(
connection,
wallet,
new PublicKey(id),
id,
);
} catch (e) {
console.error(e);

9
js/packages/web/src/views/artCreate/index.tsx
View File

@ -30,9 +30,10 @@ import {
MetaplexModal,
MetaplexOverlay,
MetadataFile,
StringPublicKey,
} from '@oyster/common';
import { getAssetCostToStore, LAMPORT_MULTIPLIER } from '../../utils/assets';
import { Connection, PublicKey } from '@solana/web3.js';
import { Connection } from '@solana/web3.js';
import { MintLayout } from '@solana/spl-token';
import { useHistory, useParams } from 'react-router-dom';
import { cleanName, getLast } from '../../utils/utils';
@ -55,7 +56,7 @@ export const ArtCreateView = () => {
const [stepsVisible, setStepsVisible] = useState<boolean>(true);
const [progress, setProgress] = useState<number>(0);
const [nft, setNft] =
useState<{ metadataAccount: PublicKey } | undefined>(undefined);
useState<{ metadataAccount: StringPublicKey } | undefined>(undefined);
const [files, setFiles] = useState<File[]>([]);
const [attributes, setAttributes] = useState<IMetadataExtension>({
name: '',
@ -897,7 +898,7 @@ const RoyaltiesStep = (props: {
].map(
c =>
new Creator({
address: new PublicKey(c.value),
address: c.value,
verified: c.value === wallet?.publicKey?.toBase58(),
share:
royalties.find(r => r.creatorKey === c.value)?.amount ||
@ -1060,7 +1061,7 @@ const WaitingStep = (props: {
const Congrats = (props: {
nft?: {
metadataAccount: PublicKey;
metadataAccount: StringPublicKey;
};
}) => {
const history = useHistory();

4
js/packages/web/src/views/artist/index.tsx
View File

@ -25,7 +25,7 @@ export const ArtistView = () => {
>
{artwork.length > 0
? artwork.map((m, idx) => {
const id = m.pubkey.toBase58();
const id = m.pubkey;
return (
<Link to={`/art/${id}`} key={idx}>
<ArtCard key={id} pubkey={m.pubkey} preview={false} />
@ -46,7 +46,7 @@ export const ArtistView = () => {
<Col span={24}>
<h2>
{/* <MetaAvatar creators={creator ? [creator] : []} size={100} /> */}
{creator?.info.name || creator?.info.address.toBase58()}
{creator?.info.name || creator?.info.address}
</h2>
<br />
<div className="info-header">ABOUT THE CREATOR</div>

4
js/packages/web/src/views/artists/index.tsx
View File

@ -25,11 +25,11 @@ export const ArtistsView = () => {
columnClassName="my-masonry-grid_column"
>
{items.map((m, idx) => {
const id = m.info.address.toBase58();
const id = m.info.address;
return (
<Link to={`/artists/${id}`} key={idx}>
<ArtistCard key={id} artist={{
address: m.info.address.toBase58(),
address: m.info.address,
name: m.info.name || '',
image: m.info.image || '',
link: m.info.twitter || ''

6
js/packages/web/src/views/artworks/index.tsx
View File

@ -34,8 +34,8 @@ export const ArtworksView = () => {
const items =
(activeKey === ArtworkViewState.Owned
? ownedMetadata.map(m => m.metadata)
: (activeKey === ArtworkViewState.Created
? createdMetadata
: (activeKey === ArtworkViewState.Created
? createdMetadata
: metadata));
useEffect(() => {
@ -54,7 +54,7 @@ export const ArtworksView = () => {
>
{!isLoading
? items.map((m, idx) => {
const id = m.pubkey.toBase58();
const id = m.pubkey;
return (
<Link to={`/art/${id}`} key={idx}>
<ArtCard

56
js/packages/web/src/views/auction/billing.tsx
View File

@ -22,6 +22,8 @@ import {
programIds,
Bid,
useUserAccounts,
StringPublicKey,
toPublicKey,
} from '@oyster/common';
import { useMeta } from '../../contexts';
import {
@ -32,7 +34,7 @@ import {
WinningConstraint,
} from '../../models/metaplex';
import { WalletAdapter } from '@solana/wallet-base';
import { Connection, PublicKey } from '@solana/web3.js';
import { Connection } from '@solana/web3.js';
import { settle } from '../../actions/settle';
import { MintInfo } from '@solana/spl-token';
const { useWallet } = contexts.Wallet;
@ -91,7 +93,7 @@ function useWinnerPotsByBidderKey(
useEffect(() => {
(async () => {
const promises: Promise<{ winner: Bid; key: PublicKey }>[] =
const promises: Promise<{ winner: Bid; key: StringPublicKey }>[] =
truWinners.map(winner =>
getBidderPotKey({
auctionProgramId: PROGRAM_IDS.auction,
@ -107,7 +109,7 @@ function useWinnerPotsByBidderKey(
const newPots = values.reduce((agg, value) => {
const el = cache.get(value.key) as ParsedAccount<BidderPot>;
if (el) {
agg[value.winner.key.toBase58()] = el;
agg[value.winner.key] = el;
}
return agg;
@ -146,7 +148,7 @@ function usePayoutTickets(
? [[auctionView.participationItem]]
: []),
];
const payoutPromises: { key: string; promise: Promise<PublicKey> }[] = [];
const payoutPromises: { key: string; promise: Promise<StringPublicKey> }[] = [];
let total = 0;
for (let i = 0; i < prizeArrays.length; i++) {
const items = prizeArrays[i];
@ -161,9 +163,9 @@ function usePayoutTickets(
for (let k = 0; k < recipientAddresses.length; k++) {
// Ensure no clashes with tickets from other safety deposits in other winning configs even if from same creator by making long keys
const key = `${auctionView.auctionManager.pubkey.toBase58()}-${i}-${j}-${item.safetyDeposit.pubkey.toBase58()}-${recipientAddresses[
const key = `${auctionView.auctionManager.pubkey}-${i}-${j}-${item.safetyDeposit.pubkey}-${recipientAddresses[
k
].toBase58()}-${k}`;
]}-${k}`;
if (!currFound[key]) {
payoutPromises.push({
@ -183,11 +185,11 @@ function usePayoutTickets(
}
}
Promise.all(payoutPromises.map(p => p.promise)).then(
(payoutKeys: PublicKey[]) => {
payoutKeys.forEach((payoutKey: PublicKey, i: number) => {
if (payoutTickets[payoutKey.toBase58()])
(payoutKeys: StringPublicKey[]) => {
payoutKeys.forEach((payoutKey: StringPublicKey, i: number) => {
if (payoutTickets[payoutKey])
currFound[payoutPromises[i].key] =
payoutTickets[payoutKey.toBase58()];
payoutTickets[payoutKey];
});
setFoundPayoutTickets(pt => ({ ...pt, ...currFound }));
@ -209,14 +211,14 @@ function usePayoutTickets(
>,
el: ParsedAccount<PayoutTicket>,
) => {
if (!acc[el.info.recipient.toBase58()]) {
acc[el.info.recipient.toBase58()] = {
if (!acc[el.info.recipient]) {
acc[el.info.recipient] = {
sum: 0,
tickets: [],
};
}
acc[el.info.recipient.toBase58()].tickets.push(el);
acc[el.info.recipient.toBase58()].sum += el.info.amountPaid.toNumber();
acc[el.info.recipient].tickets.push(el);
acc[el.info.recipient].sum += el.info.amountPaid.toNumber();
return acc;
},
{},
@ -225,10 +227,10 @@ function usePayoutTickets(
export function useBillingInfo({ auctionView }: { auctionView: AuctionView }) {
const { bidRedemptions, bidderMetadataByAuctionAndBidder } = useMeta();
const auctionKey = auctionView.auction.pubkey.toBase58();
const auctionKey = auctionView.auction.pubkey;
const [participationBidRedemptionKeys, setParticipationBidRedemptionKeys] =
useState<Record<string, PublicKey>>({});
useState<Record<string, StringPublicKey>>({});
const bids = useBidsForAuction(auctionView.auction.pubkey);
@ -244,7 +246,7 @@ export function useBillingInfo({ auctionView }: { auctionView: AuctionView }) {
b =>
!b.info.cancelled ||
bidRedemptions[
participationBidRedemptionKeys[b.pubkey.toBase58()]?.toBase58()
participationBidRedemptionKeys[b.pubkey]
]?.info.getBidRedeemed(
auctionView.participationItem?.safetyDeposit.info.order || 0,
),
@ -256,12 +258,12 @@ export function useBillingInfo({ auctionView }: { auctionView: AuctionView }) {
let participationEligible = hasParticipation ? usableBids : [];
useMemo(async () => {
const newKeys: Record<string, PublicKey> = {};
const newKeys: Record<string, StringPublicKey> = {};
for (let i = 0; i < bids.length; i++) {
const o = bids[i];
if (!participationBidRedemptionKeys[o.pubkey.toBase58()]) {
newKeys[o.pubkey.toBase58()] = (
if (!participationBidRedemptionKeys[o.pubkey]) {
newKeys[o.pubkey] = (
await getBidderKeys(auctionView.auction.pubkey, o.info.bidderPubkey)
).bidRedemption;
}
@ -280,7 +282,7 @@ export function useBillingInfo({ auctionView }: { auctionView: AuctionView }) {
// Filter winners out of the open edition eligible
participationEligible = participationEligible.filter(
// winners are stored by pot key, not bidder key, so we translate
b => !winnerPotsByBidderKey[b.info.bidderPubkey.toBase58()],
b => !winnerPotsByBidderKey[b.info.bidderPubkey],
);
const nonWinnerConstraint =
@ -289,7 +291,7 @@ export function useBillingInfo({ auctionView }: { auctionView: AuctionView }) {
const participationEligibleUnredeemable: ParsedAccount<BidderMetadata>[] = [];
participationEligible.forEach(o => {
const isWinner = winnerPotsByBidderKey[o.info.bidderPubkey.toBase58()];
const isWinner = winnerPotsByBidderKey[o.info.bidderPubkey];
// Winners automatically pay nothing for open editions, and are getting claimed anyway right now
// so no need to add them to list
if (isWinner) {
@ -300,9 +302,9 @@ export function useBillingInfo({ auctionView }: { auctionView: AuctionView }) {
nonWinnerConstraint === NonWinningConstraint.GivenForFixedPrice ||
nonWinnerConstraint === NonWinningConstraint.GivenForBidPrice
) {
const key = participationBidRedemptionKeys[o.pubkey.toBase58()];
const key = participationBidRedemptionKeys[o.pubkey];
if (key) {
const redemption = bidRedemptions[key.toBase58()];
const redemption = bidRedemptions[key];
if (
!redemption ||
!redemption.info.getBidRedeemed(
@ -322,7 +324,7 @@ export function useBillingInfo({ auctionView }: { auctionView: AuctionView }) {
// Winners always get it for free so pay zero for them - figure out among all
// eligible open edition winners what is the total possible for display.
const participationPossibleTotal = participationEligible.reduce((acc, el) => {
const isWinner = winnerPotsByBidderKey[el.info.bidderPubkey.toBase58()];
const isWinner = winnerPotsByBidderKey[el.info.bidderPubkey];
let price = 0;
if (!isWinner) price = getLosingParticipationPrice(el, auctionView);
@ -345,7 +347,7 @@ export function useBillingInfo({ auctionView }: { auctionView: AuctionView }) {
...winnersThatCanBeEmptied.map(pot => ({
metadata:
bidderMetadataByAuctionAndBidder[
`${auctionKey}-${pot.info.bidderAct.toBase58()}`
`${auctionKey}-${pot.info.bidderAct}`
],
pot,
})),
@ -383,7 +385,7 @@ export const InnerBillingView = ({
useEffect(() => {
connection
.getTokenAccountBalance(auctionView.auctionManager.acceptPayment)
.getTokenAccountBalance(toPublicKey(auctionView.auctionManager.acceptPayment))
.then(resp => {
if (resp.value.uiAmount !== undefined && resp.value.uiAmount !== null)
setEscrowBalance(resp.value.uiAmount);

18
js/packages/web/src/views/auction/index.tsx
View File

@ -1,8 +1,8 @@
import React, { useRef, useState, useEffect } from 'react';
import React, { useState, useEffect } from 'react';
import { useParams } from 'react-router-dom';
import { Row, Col, Button, Skeleton, Carousel } from 'antd';
import { AuctionCard } from '../../components/AuctionCard';
import { Connection, PublicKey } from '@solana/web3.js';
import { Connection } from '@solana/web3.js';
import {
AuctionView as Auction,
AuctionViewItem,
@ -25,6 +25,8 @@ import {
useMint,
useWallet,
AuctionState,
StringPublicKey,
toPublicKey,
} from '@oyster/common';
import { MintInfo } from '@solana/spl-token';
import { getHandleAndRegistryKey } from '@solana/spl-name-service';
@ -98,7 +100,7 @@ export const AuctionView = () => {
...(auction?.items
.flat()
.reduce((agg, item) => {
agg.set(item.metadata.pubkey.toBase58(), item);
agg.set(item.metadata.pubkey, item);
return agg;
}, new Map<string, AuctionViewItem>())
.values() || []),
@ -110,7 +112,7 @@ export const AuctionView = () => {
return (
<AuctionItem
key={item.metadata.pubkey.toBase58()}
key={item.metadata.pubkey}
item={item}
index={index}
size={arr.length}
@ -226,7 +228,7 @@ const BidLine = (props: {
}) => {
const { bid, index, mint, isCancelled, isActive } = props;
const { wallet } = useWallet();
const bidder = bid.info.bidderPubkey.toBase58();
const bidder = bid.info.bidderPubkey;
const isme = wallet?.publicKey?.toBase58() === bidder;
// Get Twitter Handle from address
@ -235,12 +237,12 @@ const BidLine = (props: {
useEffect(() => {
const getTwitterHandle = async (
connection: Connection,
bidder: PublicKey,
bidder: StringPublicKey,
): Promise<string | undefined> => {
try {
const [twitterHandle] = await getHandleAndRegistryKey(
connection,
bidder,
toPublicKey(bidder),
);
setBidderTwitterHandle(twitterHandle);
} catch (err) {
@ -350,7 +352,7 @@ export const AuctionBids = ({
const winnersCount = auctionView?.auction.info.bidState.max.toNumber() || 0;
const activeBids = auctionView?.auction.info.bidState.bids || [];
const activeBidders = useMemo(() => {
return new Set(activeBids.map(b => b.key.toBase58()));
return new Set(activeBids.map(b => b.key));
}, [activeBids]);
const auctionState = auctionView

10
js/packages/web/src/views/auctionCreate/artSelector.tsx
View File

@ -17,7 +17,7 @@ export const ArtSelector = (props: ArtSelectorProps) => {
let items = useUserArts();
if (props.filter) items = items.filter(props.filter);
const selectedItems = useMemo<Set<string>>(
() => new Set(selected.map(item => item.metadata.pubkey.toBase58())),
() => new Set(selected.map(item => item.metadata.pubkey)),
[selected],
);
@ -56,7 +56,7 @@ export const ArtSelector = (props: ArtSelectorProps) => {
columnClassName="my-masonry-grid_column"
>
{selected.map(m => {
let key = m?.metadata.pubkey.toBase58() || '';
let key = m?.metadata.pubkey || '';
return (
<ArtCard
@ -66,7 +66,7 @@ export const ArtSelector = (props: ArtSelectorProps) => {
onClick={open}
close={() => {
setSelected(
selected.filter(_ => _.metadata.pubkey.toBase58() !== key),
selected.filter(_ => _.metadata.pubkey !== key),
);
confirm();
}}
@ -107,7 +107,7 @@ export const ArtSelector = (props: ArtSelectorProps) => {
columnClassName="my-masonry-grid_column"
>
{items.map(m => {
const id = m.metadata.pubkey.toBase58();
const id = m.metadata.pubkey;
const isSelected = selectedItems.has(id);
const onSelect = () => {
@ -121,7 +121,7 @@ export const ArtSelector = (props: ArtSelectorProps) => {
: new Set([...list, id]);
let selected = items.filter(item =>
newSet.has(item.metadata.pubkey.toBase58()),
newSet.has(item.metadata.pubkey),
);
setSelected(selected);

37
js/packages/web/src/views/auctionCreate/index.tsx
View File

@ -31,8 +31,9 @@ import {
PriceFloorType,
IPartialCreateAuctionArgs,
MetadataKey,
StringPublicKey,
} from '@oyster/common';
import { Connection, LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.js';
import { Connection, LAMPORTS_PER_SOL } from '@solana/web3.js';
import { MintLayout } from '@solana/spl-token';
import { useHistory, useParams } from 'react-router-dom';
import { capitalize } from 'lodash';
@ -134,9 +135,9 @@ export const AuctionCreateView = () => {
const [stepsVisible, setStepsVisible] = useState<boolean>(true);
const [auctionObj, setAuctionObj] = useState<
| {
vault: PublicKey;
auction: PublicKey;
auctionManager: PublicKey;
vault: StringPublicKey;
auction: StringPublicKey;
auctionManager: StringPublicKey;
}
| undefined
>(undefined);
@ -192,11 +193,11 @@ export const AuctionCreateView = () => {
attributes.category == AuctionCategory.Single &&
item.masterEdition
) {
item.winningConfigType = item.metadata.info.updateAuthority.equals(
wallet?.publicKey || SystemProgram.programId,
)
? WinningConfigType.FullRightsTransfer
: WinningConfigType.TokenOnlyTransfer;
item.winningConfigType =
item.metadata.info.updateAuthority ===
(wallet?.publicKey || SystemProgram.programId).toBase58()
? WinningConfigType.FullRightsTransfer
: WinningConfigType.TokenOnlyTransfer;
}
item.amountRanges = [
new AmountRange({
@ -403,7 +404,7 @@ export const AuctionCreateView = () => {
: PriceFloorType.None,
minPrice: new BN((attributes.priceFloor || 0) * LAMPORTS_PER_SOL),
}),
tokenMint: QUOTE_MINT,
tokenMint: QUOTE_MINT.toBase58(),
gapTickSizePercentage: attributes.tickSizeEndingPhase || null,
tickSize: attributes.priceTick
? new BN(attributes.priceTick * LAMPORTS_PER_SOL)
@ -427,7 +428,7 @@ export const AuctionCreateView = () => {
attributes.category === AuctionCategory.Open
? attributes.items[0]
: attributes.participationNFT,
QUOTE_MINT,
QUOTE_MINT.toBase58(),
);
setAuctionObj(_auctionObj);
};
@ -1511,12 +1512,12 @@ const TierTableStep = (props: {
const newTiers = newImmutableTiers(props.attributes.tiers);
if (items[0]) {
const existing = props.attributes.items.find(it =>
it.metadata.pubkey.equals(items[0].metadata.pubkey),
const existing = props.attributes.items.find(
it => it.metadata.pubkey === items[0].metadata.pubkey,
);
if (!existing) newItems.push(items[0]);
const index = newItems.findIndex(it =>
it.metadata.pubkey.equals(items[0].metadata.pubkey),
const index = newItems.findIndex(
it => it.metadata.pubkey === items[0].metadata.pubkey,
);
const myNewTier = newTiers[configIndex].items[itemIndex];
@ -1941,9 +1942,9 @@ const WaitingStep = (props: {
const Congrats = (props: {
auction?: {
vault: PublicKey;
auction: PublicKey;
auctionManager: PublicKey;
vault: StringPublicKey;
auction: StringPublicKey;
auctionManager: StringPublicKey;
};
}) => {
const history = useHistory();

14
js/packages/web/src/views/home/index.tsx
View File

@ -45,9 +45,9 @@ export const HomeView = () => {
// Check if the auction is primary sale or not
const checkPrimarySale = (auc:AuctionView) => {
var flag = 0;
auc.items.forEach(i =>
auc.items.forEach(i =>
{
i.forEach(j => {
i.forEach(j => {
if (j.metadata.info.primarySaleHappened == true) {
flag = 1;
return true;
@ -73,7 +73,7 @@ export const HomeView = () => {
items = liveAuctions;
break;
case LiveAuctionViewState.Participated:
items = liveAuctions.concat(auctionsEnded).filter((m, idx) => m.myBidderMetadata?.info.bidderPubkey.toBase58() == wallet?.publicKey?.toBase58());
items = liveAuctions.concat(auctionsEnded).filter((m, idx) => m.myBidderMetadata?.info.bidderPubkey == wallet?.publicKey?.toBase58());
break;
case LiveAuctionViewState.Resale:
items = resaleAuctions;
@ -106,7 +106,7 @@ export const HomeView = () => {
return;
}
const id = m.auction.pubkey.toBase58();
const id = m.auction.pubkey;
return (
<Link to={`/auction/${id}`} key={idx}>
<AuctionRenderCard key={id} auctionView={m} />
@ -129,7 +129,7 @@ export const HomeView = () => {
return;
}
const id = m.auction.pubkey.toBase58();
const id = m.auction.pubkey;
return (
<Link to={`/auction/${id}`} key={idx}>
<AuctionRenderCard key={id} auctionView={m} />
@ -181,7 +181,7 @@ export const HomeView = () => {
await saveAdmin(connection, wallet, false, [
new WhitelistedCreator({
address: wallet?.publicKey,
address: wallet?.publicKey.toBase58(),
activated: true,
}),
]);
@ -244,4 +244,4 @@ export const HomeView = () => {
</Layout>
</Layout>
);
};
};

8
rust/token-metadata/test/src/main.rs
View File

@ -51,7 +51,7 @@ fn puff_unpuffed_metadata(_app_matches: &ArgMatches, payer: Keypair, client: Rpc
}
}
println!("Found {} accounts needing puffing", needing_puffing.len());
let mut instructions = vec![];
let mut i = 0;
while i < needing_puffing.len() {
@ -568,7 +568,7 @@ fn create_metadata_account_call(
.unwrap(),
];
let new_metadata_instruction =
let new_metadata_instruction =
create_metadata_accounts(
program_key,
metadata_key,
@ -801,7 +801,7 @@ fn main() {
.validator(is_valid_signer)
.takes_value(true)
.required(false)
.help("Filepath or URL to a keypair representing mint authority, defaults to you"),
.help("Filepath or URL to a keypair representing mint authority, defaults to you"),
)
).subcommand(
SubCommand::with_name("mint_new_edition_from_master_edition_via_token")
@ -831,7 +831,7 @@ fn main() {
.takes_value(true)
.help("Account's authority, defaults to you"),
)
).subcommand(
SubCommand::with_name("puff_unpuffed_metadata")
.about("Take metadata that still have variable length name, symbol, and uri fields and stretch them out with null symbols so they can be searched more easily by RPC.")).get_matches();