3land_sdk 1.0.0

package/src/types/accounts/PackContent.ts

@@ -0,0 +1,97 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+import BN from "bn.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 interface PackContentFields {
+  class: types.AccountClassKind
+  cards: PublicKey
+}
+
+export interface PackContentJSON {
+  class: types.AccountClassJSON
+  cards: string
+}
+
+export class PackContent {
+  readonly class: types.AccountClassKind
+  readonly cards: PublicKey
+
+  static readonly discriminator = Buffer.from([
+    89, 183, 142, 94, 35, 115, 253, 159,
+  ])
+
+  static readonly layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    borsh.publicKey("cards"),
+  ])
+
+  constructor(fields: PackContentFields) {
+    this.class = fields.class
+    this.cards = fields.cards
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<PackContent | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Array<PackContent | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): PackContent {
+    if (!data.slice(0, 8).equals(PackContent.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = PackContent.layout.decode(data.slice(8))
+
+    return new PackContent({
+      class: types.AccountClass.fromDecoded(dec.class),
+      cards: dec.cards,
+    })
+  }
+
+  toJSON(): PackContentJSON {
+    return {
+      class: this.class.toJSON(),
+      cards: this.cards.toString(),
+    }
+  }
+
+  static fromJSON(obj: PackContentJSON): PackContent {
+    return new PackContent({
+      class: types.AccountClass.fromJSON(obj.class),
+      cards: new PublicKey(obj.cards),
+    })
+  }
+}

package/src/types/accounts/PackOpenHolder.ts

@@ -0,0 +1,141 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+import BN from "bn.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 interface PackOpenHolderFields {
+  class: types.AccountClassKind
+  state: types.PackOpenHolderStateKind
+  pack: PublicKey
+  creator: PublicKey
+  claimer: PublicKey
+  packType: types.PackTypeKind
+  items: Array<types.SelectedCardFields>
+}
+
+export interface PackOpenHolderJSON {
+  class: types.AccountClassJSON
+  state: types.PackOpenHolderStateJSON
+  pack: string
+  creator: string
+  claimer: string
+  packType: types.PackTypeJSON
+  items: Array<types.SelectedCardJSON>
+}
+
+export class PackOpenHolder {
+  readonly class: types.AccountClassKind
+  readonly state: types.PackOpenHolderStateKind
+  readonly pack: PublicKey
+  readonly creator: PublicKey
+  readonly claimer: PublicKey
+  readonly packType: types.PackTypeKind
+  readonly items: Array<types.SelectedCard>
+
+  static readonly discriminator = Buffer.from([
+    54, 190, 160, 171, 255, 212, 144, 120,
+  ])
+
+  static readonly layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    types.PackOpenHolderState.layout("state"),
+    borsh.publicKey("pack"),
+    borsh.publicKey("creator"),
+    borsh.publicKey("claimer"),
+    types.PackType.layout("packType"),
+    borsh.vec(types.SelectedCard.layout(), "items"),
+  ])
+
+  constructor(fields: PackOpenHolderFields) {
+    this.class = fields.class
+    this.state = fields.state
+    this.pack = fields.pack
+    this.creator = fields.creator
+    this.claimer = fields.claimer
+    this.packType = fields.packType
+    this.items = fields.items.map((item) => new types.SelectedCard({ ...item }))
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<PackOpenHolder | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Array<PackOpenHolder | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): PackOpenHolder {
+    if (!data.slice(0, 8).equals(PackOpenHolder.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = PackOpenHolder.layout.decode(data.slice(8))
+
+    return new PackOpenHolder({
+      class: types.AccountClass.fromDecoded(dec.class),
+      state: types.PackOpenHolderState.fromDecoded(dec.state),
+      pack: dec.pack,
+      creator: dec.creator,
+      claimer: dec.claimer,
+      packType: types.PackType.fromDecoded(dec.packType),
+      items: dec.items.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.SelectedCard.fromDecoded(item)
+      ),
+    })
+  }
+
+  toJSON(): PackOpenHolderJSON {
+    return {
+      class: this.class.toJSON(),
+      state: this.state.toJSON(),
+      pack: this.pack.toString(),
+      creator: this.creator.toString(),
+      claimer: this.claimer.toString(),
+      packType: this.packType.toJSON(),
+      items: this.items.map((item) => item.toJSON()),
+    }
+  }
+
+  static fromJSON(obj: PackOpenHolderJSON): PackOpenHolder {
+    return new PackOpenHolder({
+      class: types.AccountClass.fromJSON(obj.class),
+      state: types.PackOpenHolderState.fromJSON(obj.state),
+      pack: new PublicKey(obj.pack),
+      creator: new PublicKey(obj.creator),
+      claimer: new PublicKey(obj.claimer),
+      packType: types.PackType.fromJSON(obj.packType),
+      items: obj.items.map((item) => types.SelectedCard.fromJSON(item)),
+    })
+  }
+}

package/src/types/accounts/PackReceipt.ts

@@ -0,0 +1,145 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+import BN from "bn.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 interface PackReceiptFields {
+  class: types.AccountClassKind
+  cnft: PublicKey
+  pack: PublicKey
+  creator: PublicKey
+  state: types.PackStateKind
+  cardsInside: number
+  slot: BN
+  created: number
+}
+
+export interface PackReceiptJSON {
+  class: types.AccountClassJSON
+  cnft: string
+  pack: string
+  creator: string
+  state: types.PackStateJSON
+  cardsInside: number
+  slot: string
+  created: number
+}
+
+export class PackReceipt {
+  readonly class: types.AccountClassKind
+  readonly cnft: PublicKey
+  readonly pack: PublicKey
+  readonly creator: PublicKey
+  readonly state: types.PackStateKind
+  readonly cardsInside: number
+  readonly slot: BN
+  readonly created: number
+
+  static readonly discriminator = Buffer.from([
+    117, 14, 250, 166, 162, 131, 180, 180,
+  ])
+
+  static readonly layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    borsh.publicKey("cnft"),
+    borsh.publicKey("pack"),
+    borsh.publicKey("creator"),
+    types.PackState.layout("state"),
+    borsh.u8("cardsInside"),
+    borsh.u64("slot"),
+    borsh.u32("created"),
+  ])
+
+  constructor(fields: PackReceiptFields) {
+    this.class = fields.class
+    this.cnft = fields.cnft
+    this.pack = fields.pack
+    this.creator = fields.creator
+    this.state = fields.state
+    this.cardsInside = fields.cardsInside
+    this.slot = fields.slot
+    this.created = fields.created
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<PackReceipt | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Array<PackReceipt | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): PackReceipt {
+    if (!data.slice(0, 8).equals(PackReceipt.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = PackReceipt.layout.decode(data.slice(8))
+
+    return new PackReceipt({
+      class: types.AccountClass.fromDecoded(dec.class),
+      cnft: dec.cnft,
+      pack: dec.pack,
+      creator: dec.creator,
+      state: types.PackState.fromDecoded(dec.state),
+      cardsInside: dec.cardsInside,
+      slot: dec.slot,
+      created: dec.created,
+    })
+  }
+
+  toJSON(): PackReceiptJSON {
+    return {
+      class: this.class.toJSON(),
+      cnft: this.cnft.toString(),
+      pack: this.pack.toString(),
+      creator: this.creator.toString(),
+      state: this.state.toJSON(),
+      cardsInside: this.cardsInside,
+      slot: this.slot.toString(),
+      created: this.created,
+    }
+  }
+
+  static fromJSON(obj: PackReceiptJSON): PackReceipt {
+    return new PackReceipt({
+      class: types.AccountClass.fromJSON(obj.class),
+      cnft: new PublicKey(obj.cnft),
+      pack: new PublicKey(obj.pack),
+      creator: new PublicKey(obj.creator),
+      state: types.PackState.fromJSON(obj.state),
+      cardsInside: obj.cardsInside,
+      slot: new BN(obj.slot),
+      created: obj.created,
+    })
+  }
+}

package/src/types/accounts/PackTraits.ts

@@ -0,0 +1,101 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+import BN from "bn.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 interface PackTraitsFields {
+  class: types.AccountClassKind
+  list: Array<types.TraitTypeKind>
+}
+
+export interface PackTraitsJSON {
+  class: types.AccountClassJSON
+  list: Array<types.TraitTypeJSON>
+}
+
+export class PackTraits {
+  readonly class: types.AccountClassKind
+  readonly list: Array<types.TraitTypeKind>
+
+  static readonly discriminator = Buffer.from([
+    238, 139, 229, 97, 133, 123, 168, 248,
+  ])
+
+  static readonly layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    borsh.vec(types.TraitType.layout(), "list"),
+  ])
+
+  constructor(fields: PackTraitsFields) {
+    this.class = fields.class
+    this.list = fields.list
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<PackTraits | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Array<PackTraits | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): PackTraits {
+    if (!data.slice(0, 8).equals(PackTraits.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = PackTraits.layout.decode(data.slice(8))
+
+    return new PackTraits({
+      class: types.AccountClass.fromDecoded(dec.class),
+      list: dec.list.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.TraitType.fromDecoded(item)
+      ),
+    })
+  }
+
+  toJSON(): PackTraitsJSON {
+    return {
+      class: this.class.toJSON(),
+      list: this.list.map((item) => item.toJSON()),
+    }
+  }
+
+  static fromJSON(obj: PackTraitsJSON): PackTraits {
+    return new PackTraits({
+      class: types.AccountClass.fromJSON(obj.class),
+      list: obj.list.map((item) => types.TraitType.fromJSON(item)),
+    })
+  }
+}

package/src/types/accounts/Payment.ts

@@ -0,0 +1,97 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+import BN from "bn.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 interface PaymentFields {
+  class: types.PaymentClassKind
+  hash: Array<number>
+}
+
+export interface PaymentJSON {
+  class: types.PaymentClassJSON
+  hash: Array<number>
+}
+
+export class Payment {
+  readonly class: types.PaymentClassKind
+  readonly hash: Array<number>
+
+  static readonly discriminator = Buffer.from([
+    227, 231, 51, 26, 244, 88, 4, 148,
+  ])
+
+  static readonly layout = borsh.struct([
+    types.PaymentClass.layout("class"),
+    borsh.array(borsh.u8(), 32, "hash"),
+  ])
+
+  constructor(fields: PaymentFields) {
+    this.class = fields.class
+    this.hash = fields.hash
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Payment | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Array<Payment | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): Payment {
+    if (!data.slice(0, 8).equals(Payment.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = Payment.layout.decode(data.slice(8))
+
+    return new Payment({
+      class: types.PaymentClass.fromDecoded(dec.class),
+      hash: dec.hash,
+    })
+  }
+
+  toJSON(): PaymentJSON {
+    return {
+      class: this.class.toJSON(),
+      hash: this.hash,
+    }
+  }
+
+  static fromJSON(obj: PaymentJSON): Payment {
+    return new Payment({
+      class: types.PaymentClass.fromJSON(obj.class),
+      hash: obj.hash,
+    })
+  }
+}