3land_sdk 1.0.1 → 1.0.2

package/dist/types/instructions/feedPool.js

@@ -0,0 +1,32 @@
+import { TransactionInstruction } from "@solana/web3.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export const layout = borsh.struct([
+    borsh.str("name"),
+    borsh.u64("amount"),
+    borsh.u8("decimals"),
+    borsh.u8("withdraw"),
+]);
+export function feedPool(args, accounts, programId = PROGRAM_ID) {
+    const keys = [
+        { pubkey: accounts.poolVault, isSigner: false, isWritable: true },
+        { pubkey: accounts.currency, isSigner: false, isWritable: false },
+        { pubkey: accounts.fromAta, isSigner: false, isWritable: true },
+        { pubkey: accounts.toAta, isSigner: false, isWritable: true },
+        { pubkey: accounts.storeAccount, isSigner: false, isWritable: false },
+        { pubkey: accounts.payer, isSigner: true, isWritable: true },
+        { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+        { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    ];
+    const identifier = Buffer.from([209, 238, 252, 180, 229, 87, 69, 160]);
+    const buffer = Buffer.alloc(1000);
+    const len = layout.encode({
+        name: args.name,
+        amount: args.amount,
+        decimals: args.decimals,
+        withdraw: args.withdraw,
+    }, buffer);
+    const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len);
+    const ix = new TransactionInstruction({ keys, programId, data });
+    return ix;
+}

package/dist/types/instructions/feedTraits.d.ts

@@ -0,0 +1,14 @@
+import { PublicKey } from "@solana/web3.js";
+import * as types from "../types";
+export interface FeedTraitsArgs {
+    traits: types.FeedingTraitsFields;
+}
+export interface FeedTraitsAccounts {
+    packAccount: PublicKey;
+    packTraits: PublicKey;
+    packTraitsRegistry: PublicKey;
+    payer: PublicKey;
+    systemProgram: PublicKey;
+}
+export declare const layout: any;
+export declare function feedTraits(args: FeedTraitsArgs, accounts: FeedTraitsAccounts, programId?: PublicKey): any;

package/dist/types/instructions/feedTraits.js

@@ -0,0 +1,22 @@
+import { TransactionInstruction } from "@solana/web3.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export const layout = borsh.struct([types.FeedingTraits.layout("traits")]);
+export function feedTraits(args, accounts, programId = PROGRAM_ID) {
+    const keys = [
+        { pubkey: accounts.packAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.packTraits, isSigner: false, isWritable: true },
+        { pubkey: accounts.packTraitsRegistry, isSigner: false, isWritable: true },
+        { pubkey: accounts.payer, isSigner: true, isWritable: true },
+        { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    ];
+    const identifier = Buffer.from([105, 113, 240, 80, 105, 198, 78, 164]);
+    const buffer = Buffer.alloc(1000);
+    const len = layout.encode({
+        traits: types.FeedingTraits.toEncodable(args.traits),
+    }, buffer);
+    const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len);
+    const ix = new TransactionInstruction({ keys, programId, data });
+    return ix;
+}

package/dist/types/instructions/feedTree.d.ts

@@ -0,0 +1,20 @@
+import { PublicKey } from "@solana/web3.js";
+export interface FeedTreeArgs {
+    managerBump: number;
+    maxDepth: number;
+    maxBufferSize: number;
+    public: boolean | null;
+}
+export interface FeedTreeAccounts {
+    merkleAccount: PublicKey;
+    merkleManager: PublicKey;
+    lutAccount: PublicKey;
+    treeAuthority: PublicKey;
+    logWrapper: PublicKey;
+    bubblegumProgram: PublicKey;
+    compressionProgram: PublicKey;
+    payer: PublicKey;
+    systemProgram: PublicKey;
+}
+export declare const layout: any;
+export declare function feedTree(args: FeedTreeArgs, accounts: FeedTreeAccounts, programId?: PublicKey): any;

package/dist/types/instructions/feedTree.js

@@ -0,0 +1,33 @@
+import { TransactionInstruction } from "@solana/web3.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export const layout = borsh.struct([
+    borsh.u8("managerBump"),
+    borsh.u32("maxDepth"),
+    borsh.u32("maxBufferSize"),
+    borsh.option(borsh.bool(), "public"),
+]);
+export function feedTree(args, accounts, programId = PROGRAM_ID) {
+    const keys = [
+        { pubkey: accounts.merkleAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.merkleManager, isSigner: false, isWritable: true },
+        { pubkey: accounts.lutAccount, isSigner: false, isWritable: false },
+        { pubkey: accounts.treeAuthority, isSigner: false, isWritable: true },
+        { pubkey: accounts.logWrapper, isSigner: false, isWritable: false },
+        { pubkey: accounts.bubblegumProgram, isSigner: false, isWritable: false },
+        { pubkey: accounts.compressionProgram, isSigner: false, isWritable: false },
+        { pubkey: accounts.payer, isSigner: true, isWritable: true },
+        { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    ];
+    const identifier = Buffer.from([51, 38, 94, 153, 131, 98, 81, 20]);
+    const buffer = Buffer.alloc(1000);
+    const len = layout.encode({
+        managerBump: args.managerBump,
+        maxDepth: args.maxDepth,
+        maxBufferSize: args.maxBufferSize,
+        public: args.public,
+    }, buffer);
+    const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len);
+    const ix = new TransactionInstruction({ keys, programId, data });
+    return ix;
+}

package/dist/types/instructions/flagPack.d.ts

@@ -0,0 +1,15 @@
+import { PublicKey } from "@solana/web3.js";
+import * as types from "../types";
+export interface FlagPackArgs {
+    globalState: types.GlobalStateKind | null;
+    state: types.ItemStateKind | null;
+    serverless: number | null;
+}
+export interface FlagPackAccounts {
+    storeAccount: PublicKey;
+    packAccount: PublicKey;
+    creator: PublicKey;
+    systemProgram: PublicKey;
+}
+export declare const layout: any;
+export declare function flagPack(args: FlagPackArgs, accounts: FlagPackAccounts, programId?: PublicKey): any;

package/dist/types/instructions/flagPack.js

@@ -0,0 +1,27 @@
+import { TransactionInstruction } from "@solana/web3.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export const layout = borsh.struct([
+    borsh.option(types.GlobalState.layout(), "globalState"),
+    borsh.option(types.ItemState.layout(), "state"),
+    borsh.option(borsh.u8(), "serverless"),
+]);
+export function flagPack(args, accounts, programId = PROGRAM_ID) {
+    const keys = [
+        { pubkey: accounts.storeAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.packAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.creator, isSigner: true, isWritable: true },
+        { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    ];
+    const identifier = Buffer.from([239, 234, 126, 90, 79, 52, 91, 71]);
+    const buffer = Buffer.alloc(1000);
+    const len = layout.encode({
+        globalState: (args.globalState && args.globalState.toEncodable()) || null,
+        state: (args.state && args.state.toEncodable()) || null,
+        serverless: args.serverless,
+    }, buffer);
+    const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len);
+    const ix = new TransactionInstruction({ keys, programId, data });
+    return ix;
+}

package/dist/types/instructions/flagSingle.d.ts

@@ -0,0 +1,14 @@
+import { PublicKey } from "@solana/web3.js";
+import * as types from "../types";
+export interface FlagSingleArgs {
+    globalState: types.GlobalStateKind;
+    state: types.ItemStateKind;
+}
+export interface FlagSingleAccounts {
+    storeAccount: PublicKey;
+    itemAccount: PublicKey;
+    creator: PublicKey;
+    systemProgram: PublicKey;
+}
+export declare const layout: any;
+export declare function flagSingle(args: FlagSingleArgs, accounts: FlagSingleAccounts, programId?: PublicKey): any;

package/dist/types/instructions/flagSingle.js

@@ -0,0 +1,25 @@
+import { TransactionInstruction } from "@solana/web3.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export const layout = borsh.struct([
+    types.GlobalState.layout("globalState"),
+    types.ItemState.layout("state"),
+]);
+export function flagSingle(args, accounts, programId = PROGRAM_ID) {
+    const keys = [
+        { pubkey: accounts.storeAccount, isSigner: false, isWritable: false },
+        { pubkey: accounts.itemAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.creator, isSigner: true, isWritable: true },
+        { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    ];
+    const identifier = Buffer.from([8, 218, 103, 215, 236, 37, 163, 190]);
+    const buffer = Buffer.alloc(1000);
+    const len = layout.encode({
+        globalState: args.globalState.toEncodable(),
+        state: args.state.toEncodable(),
+    }, buffer);
+    const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len);
+    const ix = new TransactionInstruction({ keys, programId, data });
+    return ix;
+}

package/dist/types/instructions/gatePay.d.ts

@@ -0,0 +1,21 @@
+import { PublicKey } from "@solana/web3.js";
+import * as types from "../types";
+export interface GatePayArgs {
+    index: number;
+    metadata: types.MetadataArgsFields;
+}
+export interface GatePayAccounts {
+    paymentAccount: PublicKey;
+    itemAccount: PublicKey;
+    packAccount: PublicKey;
+    holderAccount: PublicKey;
+    /** CHECK */
+    merkleTree: PublicKey;
+    /** CHECK */
+    owner: PublicKey;
+    payer: PublicKey;
+    bubblegumProgram: PublicKey;
+    systemProgram: PublicKey;
+}
+export declare const layout: any;
+export declare function gatePay(args: GatePayArgs, accounts: GatePayAccounts, programId?: PublicKey): any;

package/dist/types/instructions/gatePay.js

@@ -0,0 +1,30 @@
+import { TransactionInstruction } from "@solana/web3.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export const layout = borsh.struct([
+    borsh.u32("index"),
+    types.MetadataArgs.layout("metadata"),
+]);
+export function gatePay(args, accounts, programId = PROGRAM_ID) {
+    const keys = [
+        { pubkey: accounts.paymentAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.itemAccount, isSigner: false, isWritable: false },
+        { pubkey: accounts.packAccount, isSigner: false, isWritable: false },
+        { pubkey: accounts.holderAccount, isSigner: false, isWritable: false },
+        { pubkey: accounts.merkleTree, isSigner: false, isWritable: false },
+        { pubkey: accounts.owner, isSigner: false, isWritable: false },
+        { pubkey: accounts.payer, isSigner: true, isWritable: true },
+        { pubkey: accounts.bubblegumProgram, isSigner: false, isWritable: false },
+        { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    ];
+    const identifier = Buffer.from([10, 221, 234, 101, 181, 180, 75, 191]);
+    const buffer = Buffer.alloc(1000);
+    const len = layout.encode({
+        index: args.index,
+        metadata: types.MetadataArgs.toEncodable(args.metadata),
+    }, buffer);
+    const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len);
+    const ix = new TransactionInstruction({ keys, programId, data });
+    return ix;
+}

package/dist/types/instructions/index.d.ts

@@ -0,0 +1,104 @@
+export { initialize } from "./initialize";
+export type { InitializeArgs, InitializeAccounts } from "./initialize";
+export { createCollection } from "./createCollection";
+export type { CreateCollectionArgs, CreateCollectionAccounts, } from "./createCollection";
+export { deleteTokenLauncher } from "./deleteTokenLauncher";
+export type { DeleteTokenLauncherAccounts } from "./deleteTokenLauncher";
+export { buyToken } from "./buyToken";
+export type { BuyTokenArgs, BuyTokenAccounts } from "./buyToken";
+export { createTokenLauncher } from "./createTokenLauncher";
+export type { CreateTokenLauncherArgs, CreateTokenLauncherAccounts, } from "./createTokenLauncher";
+export { registerGenericUser } from "./registerGenericUser";
+export type { RegisterGenericUserArgs, RegisterGenericUserAccounts, } from "./registerGenericUser";
+export { registerUser } from "./registerUser";
+export type { RegisterUserArgs, RegisterUserAccounts } from "./registerUser";
+export { createStore } from "./createStore";
+export type { CreateStoreArgs, CreateStoreAccounts } from "./createStore";
+export { updatePack } from "./updatePack";
+export type { UpdatePackArgs, UpdatePackAccounts } from "./updatePack";
+export { updateStore } from "./updateStore";
+export type { UpdateStoreArgs, UpdateStoreAccounts } from "./updateStore";
+export { prepareCreator } from "./prepareCreator";
+export type { PrepareCreatorAccounts } from "./prepareCreator";
+export { prepareTraits } from "./prepareTraits";
+export type { PrepareTraitsAccounts } from "./prepareTraits";
+export { preparePack } from "./preparePack";
+export type { PreparePackArgs, PreparePackAccounts } from "./preparePack";
+export { createPack } from "./createPack";
+export type { CreatePackArgs, CreatePackAccounts } from "./createPack";
+export { flagPack } from "./flagPack";
+export type { FlagPackArgs, FlagPackAccounts } from "./flagPack";
+export { flagSingle } from "./flagSingle";
+export type { FlagSingleArgs, FlagSingleAccounts } from "./flagSingle";
+export { updateSingle } from "./updateSingle";
+export type { UpdateSingleArgs, UpdateSingleAccounts } from "./updateSingle";
+export { updateCard } from "./updateCard";
+export type { UpdateCardArgs, UpdateCardAccounts } from "./updateCard";
+export { createCard } from "./createCard";
+export type { CreateCardArgs, CreateCardAccounts } from "./createCard";
+export { storeLutFor } from "./storeLutFor";
+export type { StoreLutForArgs, StoreLutForAccounts } from "./storeLutFor";
+export { assignPackDelegate } from "./assignPackDelegate";
+export type { AssignPackDelegateAccounts } from "./assignPackDelegate";
+export { createZeroCard } from "./createZeroCard";
+export type { CreateZeroCardArgs, CreateZeroCardAccounts, } from "./createZeroCard";
+export { createSingle } from "./createSingle";
+export type { CreateSingleArgs, CreateSingleAccounts } from "./createSingle";
+export { deleteSingle } from "./deleteSingle";
+export type { DeleteSingleAccounts } from "./deleteSingle";
+export { archiveItem } from "./archiveItem";
+export type { ArchiveItemArgs, ArchiveItemAccounts } from "./archiveItem";
+export { buyPack } from "./buyPack";
+export type { BuyPackArgs, BuyPackAccounts } from "./buyPack";
+export { gatePay } from "./gatePay";
+export type { GatePayArgs, GatePayAccounts } from "./gatePay";
+export { closeDepositBurn } from "./closeDepositBurn";
+export type { CloseDepositBurnArgs, CloseDepositBurnAccounts, } from "./closeDepositBurn";
+export { unwrapAndDestroy } from "./unwrapAndDestroy";
+export type { UnwrapAndDestroyArgs, UnwrapAndDestroyAccounts, } from "./unwrapAndDestroy";
+export { buyPay } from "./buyPay";
+export type { BuyPayArgs, BuyPayAccounts } from "./buyPay";
+export { addBurn } from "./addBurn";
+export type { AddBurnArgs, AddBurnAccounts } from "./addBurn";
+export { burnPay } from "./burnPay";
+export type { BurnPayArgs, BurnPayAccounts } from "./burnPay";
+export { openPack } from "./openPack";
+export type { OpenPackArgs, OpenPackAccounts } from "./openPack";
+export { deletePack } from "./deletePack";
+export type { DeletePackAccounts } from "./deletePack";
+export { deleteCard } from "./deleteCard";
+export type { DeleteCardAccounts } from "./deleteCard";
+export { claimZeroCard } from "./claimZeroCard";
+export type { ClaimZeroCardArgs, ClaimZeroCardAccounts } from "./claimZeroCard";
+export { withdrawFromStore } from "./withdrawFromStore";
+export type { WithdrawFromStoreAccounts } from "./withdrawFromStore";
+export { registerTraits } from "./registerTraits";
+export type { RegisterTraitsArgs, RegisterTraitsAccounts, } from "./registerTraits";
+export { closeRegisterTraits } from "./closeRegisterTraits";
+export type { CloseRegisterTraitsAccounts } from "./closeRegisterTraits";
+export { feedTraits } from "./feedTraits";
+export type { FeedTraitsArgs, FeedTraitsAccounts } from "./feedTraits";
+export { registerCreator } from "./registerCreator";
+export type { RegisterCreatorArgs, RegisterCreatorAccounts, } from "./registerCreator";
+export { feedPool } from "./feedPool";
+export type { FeedPoolArgs, FeedPoolAccounts } from "./feedPool";
+export { donateUser } from "./donateUser";
+export type { DonateUserArgs, DonateUserAccounts } from "./donateUser";
+export { registerCollector } from "./registerCollector";
+export type { RegisterCollectorArgs, RegisterCollectorAccounts, } from "./registerCollector";
+export { registerActivity } from "./registerActivity";
+export type { RegisterActivityArgs, RegisterActivityAccounts, } from "./registerActivity";
+export { registerPackUploads } from "./registerPackUploads";
+export type { RegisterPackUploadsArgs, RegisterPackUploadsAccounts, } from "./registerPackUploads";
+export { printPack } from "./printPack";
+export type { PrintPackArgs, PrintPackAccounts } from "./printPack";
+export { recoverDepositBurn } from "./recoverDepositBurn";
+export type { RecoverDepositBurnArgs, RecoverDepositBurnAccounts, } from "./recoverDepositBurn";
+export { adjustDepositBurn } from "./adjustDepositBurn";
+export type { AdjustDepositBurnAccounts } from "./adjustDepositBurn";
+export { depositBurn } from "./depositBurn";
+export type { DepositBurnArgs, DepositBurnAccounts } from "./depositBurn";
+export { printSingle } from "./printSingle";
+export type { PrintSingleArgs, PrintSingleAccounts } from "./printSingle";
+export { feedTree } from "./feedTree";
+export type { FeedTreeArgs, FeedTreeAccounts } from "./feedTree";

package/dist/types/instructions/index.js

@@ -0,0 +1,52 @@
+export { initialize } from "./initialize";
+export { createCollection } from "./createCollection";
+export { deleteTokenLauncher } from "./deleteTokenLauncher";
+export { buyToken } from "./buyToken";
+export { createTokenLauncher } from "./createTokenLauncher";
+export { registerGenericUser } from "./registerGenericUser";
+export { registerUser } from "./registerUser";
+export { createStore } from "./createStore";
+export { updatePack } from "./updatePack";
+export { updateStore } from "./updateStore";
+export { prepareCreator } from "./prepareCreator";
+export { prepareTraits } from "./prepareTraits";
+export { preparePack } from "./preparePack";
+export { createPack } from "./createPack";
+export { flagPack } from "./flagPack";
+export { flagSingle } from "./flagSingle";
+export { updateSingle } from "./updateSingle";
+export { updateCard } from "./updateCard";
+export { createCard } from "./createCard";
+export { storeLutFor } from "./storeLutFor";
+export { assignPackDelegate } from "./assignPackDelegate";
+export { createZeroCard } from "./createZeroCard";
+export { createSingle } from "./createSingle";
+export { deleteSingle } from "./deleteSingle";
+export { archiveItem } from "./archiveItem";
+export { buyPack } from "./buyPack";
+export { gatePay } from "./gatePay";
+export { closeDepositBurn } from "./closeDepositBurn";
+export { unwrapAndDestroy } from "./unwrapAndDestroy";
+export { buyPay } from "./buyPay";
+export { addBurn } from "./addBurn";
+export { burnPay } from "./burnPay";
+export { openPack } from "./openPack";
+export { deletePack } from "./deletePack";
+export { deleteCard } from "./deleteCard";
+export { claimZeroCard } from "./claimZeroCard";
+export { withdrawFromStore } from "./withdrawFromStore";
+export { registerTraits } from "./registerTraits";
+export { closeRegisterTraits } from "./closeRegisterTraits";
+export { feedTraits } from "./feedTraits";
+export { registerCreator } from "./registerCreator";
+export { feedPool } from "./feedPool";
+export { donateUser } from "./donateUser";
+export { registerCollector } from "./registerCollector";
+export { registerActivity } from "./registerActivity";
+export { registerPackUploads } from "./registerPackUploads";
+export { printPack } from "./printPack";
+export { recoverDepositBurn } from "./recoverDepositBurn";
+export { adjustDepositBurn } from "./adjustDepositBurn";
+export { depositBurn } from "./depositBurn";
+export { printSingle } from "./printSingle";
+export { feedTree } from "./feedTree";

package/dist/types/instructions/initialize.d.ts

@@ -0,0 +1,14 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import * as types from "../types";
+export interface InitializeArgs {
+    slot: BN;
+    globalFee: types.GlobalFeeFields | null;
+}
+export interface InitializeAccounts {
+    holderAccount: PublicKey;
+    creator: PublicKey;
+    systemProgram: PublicKey;
+}
+export declare const layout: any;
+export declare function initialize(args: InitializeArgs, accounts: InitializeAccounts, programId?: PublicKey): any;

package/dist/types/instructions/initialize.js

@@ -0,0 +1,24 @@
+import { TransactionInstruction } from "@solana/web3.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export const layout = borsh.struct([
+    borsh.u64("slot"),
+    borsh.option(types.GlobalFee.layout(), "globalFee"),
+]);
+export function initialize(args, accounts, programId = PROGRAM_ID) {
+    const keys = [
+        { pubkey: accounts.holderAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.creator, isSigner: true, isWritable: true },
+        { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    ];
+    const identifier = Buffer.from([175, 175, 109, 31, 13, 152, 155, 237]);
+    const buffer = Buffer.alloc(1000);
+    const len = layout.encode({
+        slot: args.slot,
+        globalFee: (args.globalFee && types.GlobalFee.toEncodable(args.globalFee)) || null,
+    }, buffer);
+    const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len);
+    const ix = new TransactionInstruction({ keys, programId, data });
+    return ix;
+}

package/dist/types/instructions/openPack.d.ts

@@ -0,0 +1,28 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+export interface OpenPackArgs {
+    root: Array<number>;
+    dataHash: Array<number>;
+    creatorHash: Array<number>;
+    index: number;
+    randomBase: BN;
+    creatorAuthorityBump: number;
+}
+export interface OpenPackAccounts {
+    treeAuthority: PublicKey;
+    merkleTree: PublicKey;
+    packAccount: PublicKey;
+    packOpenAccount: PublicKey;
+    creatorAuthority: PublicKey;
+    packContent: PublicKey;
+    owner: PublicKey;
+    packReceipt: PublicKey;
+    payer: PublicKey;
+    openAuthority: PublicKey;
+    bubblegumProgram: PublicKey;
+    logWrapper: PublicKey;
+    compressionProgram: PublicKey;
+    systemProgram: PublicKey;
+}
+export declare const layout: any;
+export declare function openPack(args: OpenPackArgs, accounts: OpenPackAccounts, programId?: PublicKey): any;

package/dist/types/instructions/openPack.js

@@ -0,0 +1,42 @@
+import { TransactionInstruction } from "@solana/web3.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export const layout = borsh.struct([
+    borsh.array(borsh.u8(), 32, "root"),
+    borsh.array(borsh.u8(), 32, "dataHash"),
+    borsh.array(borsh.u8(), 32, "creatorHash"),
+    borsh.u32("index"),
+    borsh.u64("randomBase"),
+    borsh.u8("creatorAuthorityBump"),
+]);
+export function openPack(args, accounts, programId = PROGRAM_ID) {
+    const keys = [
+        { pubkey: accounts.treeAuthority, isSigner: false, isWritable: false },
+        { pubkey: accounts.merkleTree, isSigner: false, isWritable: true },
+        { pubkey: accounts.packAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.packOpenAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.creatorAuthority, isSigner: false, isWritable: true },
+        { pubkey: accounts.packContent, isSigner: false, isWritable: true },
+        { pubkey: accounts.owner, isSigner: false, isWritable: true },
+        { pubkey: accounts.packReceipt, isSigner: false, isWritable: true },
+        { pubkey: accounts.payer, isSigner: true, isWritable: true },
+        { pubkey: accounts.openAuthority, isSigner: true, isWritable: true },
+        { pubkey: accounts.bubblegumProgram, isSigner: false, isWritable: false },
+        { pubkey: accounts.logWrapper, isSigner: false, isWritable: false },
+        { pubkey: accounts.compressionProgram, isSigner: false, isWritable: false },
+        { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    ];
+    const identifier = Buffer.from([75, 203, 144, 65, 63, 253, 103, 85]);
+    const buffer = Buffer.alloc(1000);
+    const len = layout.encode({
+        root: args.root,
+        dataHash: args.dataHash,
+        creatorHash: args.creatorHash,
+        index: args.index,
+        randomBase: args.randomBase,
+        creatorAuthorityBump: args.creatorAuthorityBump,
+    }, buffer);
+    const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len);
+    const ix = new TransactionInstruction({ keys, programId, data });
+    return ix;
+}

package/dist/types/instructions/prepareCreator.d.ts

@@ -0,0 +1,9 @@
+import { PublicKey } from "@solana/web3.js";
+export interface PrepareCreatorAccounts {
+    storeAccount: PublicKey;
+    creatorAuthority: PublicKey;
+    creator: PublicKey;
+    payer: PublicKey;
+    systemProgram: PublicKey;
+}
+export declare function prepareCreator(accounts: PrepareCreatorAccounts, programId?: PublicKey): any;

package/dist/types/instructions/prepareCreator.js

@@ -0,0 +1,15 @@
+import { TransactionInstruction } from "@solana/web3.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export function prepareCreator(accounts, programId = PROGRAM_ID) {
+    const keys = [
+        { pubkey: accounts.storeAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.creatorAuthority, isSigner: false, isWritable: true },
+        { pubkey: accounts.creator, isSigner: false, isWritable: false },
+        { pubkey: accounts.payer, isSigner: true, isWritable: true },
+        { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    ];
+    const identifier = Buffer.from([6, 217, 148, 231, 102, 186, 94, 73]);
+    const data = identifier;
+    const ix = new TransactionInstruction({ keys, programId, data });
+    return ix;
+}

package/dist/types/instructions/preparePack.d.ts

@@ -0,0 +1,16 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+export interface PreparePackArgs {
+    supply: BN;
+    identifier: BN;
+}
+export interface PreparePackAccounts {
+    storeAccount: PublicKey;
+    packAccount: PublicKey;
+    packContent: PublicKey;
+    creator: PublicKey;
+    payer: PublicKey;
+    systemProgram: PublicKey;
+}
+export declare const layout: any;
+export declare function preparePack(args: PreparePackArgs, accounts: PreparePackAccounts, programId?: PublicKey): any;

package/dist/types/instructions/preparePack.js

@@ -0,0 +1,26 @@
+import { TransactionInstruction } from "@solana/web3.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export const layout = borsh.struct([
+    borsh.u64("supply"),
+    borsh.u64("identifier"),
+]);
+export function preparePack(args, accounts, programId = PROGRAM_ID) {
+    const keys = [
+        { pubkey: accounts.storeAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.packAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.packContent, isSigner: false, isWritable: true },
+        { pubkey: accounts.creator, isSigner: false, isWritable: false },
+        { pubkey: accounts.payer, isSigner: true, isWritable: true },
+        { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    ];
+    const identifier = Buffer.from([246, 136, 88, 116, 22, 62, 30, 154]);
+    const buffer = Buffer.alloc(1000);
+    const len = layout.encode({
+        supply: args.supply,
+        identifier: args.identifier,
+    }, buffer);
+    const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len);
+    const ix = new TransactionInstruction({ keys, programId, data });
+    return ix;
+}

package/dist/types/instructions/prepareTraits.d.ts

@@ -0,0 +1,8 @@
+import { PublicKey } from "@solana/web3.js";
+export interface PrepareTraitsAccounts {
+    packAccount: PublicKey;
+    packTraits: PublicKey;
+    payer: PublicKey;
+    systemProgram: PublicKey;
+}
+export declare function prepareTraits(accounts: PrepareTraitsAccounts, programId?: PublicKey): any;

package/dist/types/instructions/prepareTraits.js

@@ -0,0 +1,14 @@
+import { TransactionInstruction } from "@solana/web3.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export function prepareTraits(accounts, programId = PROGRAM_ID) {
+    const keys = [
+        { pubkey: accounts.packAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.packTraits, isSigner: false, isWritable: true },
+        { pubkey: accounts.payer, isSigner: true, isWritable: true },
+        { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    ];
+    const identifier = Buffer.from([44, 242, 4, 177, 221, 243, 62, 47]);
+    const data = identifier;
+    const ix = new TransactionInstruction({ keys, programId, data });
+    return ix;
+}