3land_sdk 1.0.0

package/src/types/accounts/BuyHistory.ts

@@ -0,0 +1,121 @@
+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 BuyHistoryFields {
+  class: types.AccountClassKind
+  buyType: types.BuyHistoryClassKind
+  owner: PublicKey
+  item: PublicKey
+  store: PublicKey
+}
+
+export interface BuyHistoryJSON {
+  class: types.AccountClassJSON
+  buyType: types.BuyHistoryClassJSON
+  owner: string
+  item: string
+  store: string
+}
+
+export class BuyHistory {
+  readonly class: types.AccountClassKind
+  readonly buyType: types.BuyHistoryClassKind
+  readonly owner: PublicKey
+  readonly item: PublicKey
+  readonly store: PublicKey
+
+  static readonly discriminator = Buffer.from([
+    10, 217, 83, 243, 244, 164, 203, 202,
+  ])
+
+  static readonly layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    types.BuyHistoryClass.layout("buyType"),
+    borsh.publicKey("owner"),
+    borsh.publicKey("item"),
+    borsh.publicKey("store"),
+  ])
+
+  constructor(fields: BuyHistoryFields) {
+    this.class = fields.class
+    this.buyType = fields.buyType
+    this.owner = fields.owner
+    this.item = fields.item
+    this.store = fields.store
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<BuyHistory | 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<BuyHistory | 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): BuyHistory {
+    if (!data.slice(0, 8).equals(BuyHistory.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = BuyHistory.layout.decode(data.slice(8))
+
+    return new BuyHistory({
+      class: types.AccountClass.fromDecoded(dec.class),
+      buyType: types.BuyHistoryClass.fromDecoded(dec.buyType),
+      owner: dec.owner,
+      item: dec.item,
+      store: dec.store,
+    })
+  }
+
+  toJSON(): BuyHistoryJSON {
+    return {
+      class: this.class.toJSON(),
+      buyType: this.buyType.toJSON(),
+      owner: this.owner.toString(),
+      item: this.item.toString(),
+      store: this.store.toString(),
+    }
+  }
+
+  static fromJSON(obj: BuyHistoryJSON): BuyHistory {
+    return new BuyHistory({
+      class: types.AccountClass.fromJSON(obj.class),
+      buyType: types.BuyHistoryClass.fromJSON(obj.buyType),
+      owner: new PublicKey(obj.owner),
+      item: new PublicKey(obj.item),
+      store: new PublicKey(obj.store),
+    })
+  }
+}

package/src/types/accounts/BuyTrack.ts

@@ -0,0 +1,94 @@
+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 BuyTrackFields {
+  count: number
+  time: number
+}
+
+export interface BuyTrackJSON {
+  count: number
+  time: number
+}
+
+export class BuyTrack {
+  readonly count: number
+  readonly time: number
+
+  static readonly discriminator = Buffer.from([
+    127, 195, 236, 128, 20, 28, 179, 140,
+  ])
+
+  static readonly layout = borsh.struct([borsh.u32("count"), borsh.u32("time")])
+
+  constructor(fields: BuyTrackFields) {
+    this.count = fields.count
+    this.time = fields.time
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<BuyTrack | 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<BuyTrack | 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): BuyTrack {
+    if (!data.slice(0, 8).equals(BuyTrack.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = BuyTrack.layout.decode(data.slice(8))
+
+    return new BuyTrack({
+      count: dec.count,
+      time: dec.time,
+    })
+  }
+
+  toJSON(): BuyTrackJSON {
+    return {
+      count: this.count,
+      time: this.time,
+    }
+  }
+
+  static fromJSON(obj: BuyTrackJSON): BuyTrack {
+    return new BuyTrack({
+      count: obj.count,
+      time: obj.time,
+    })
+  }
+}

package/src/types/accounts/Card.ts

@@ -0,0 +1,185 @@
+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 CardFields {
+  class: types.AccountClassKind
+  globalState: types.GlobalStateKind
+  store: PublicKey
+  creator: PublicKey
+  holder: PublicKey
+  hash: BN
+  page: BN
+  manager: PublicKey
+  index: number
+  hashTraits: BN
+  created: number
+  reserved: Array<number>
+  item: types.ItemFields
+}
+
+export interface CardJSON {
+  class: types.AccountClassJSON
+  globalState: types.GlobalStateJSON
+  store: string
+  creator: string
+  holder: string
+  hash: string
+  page: string
+  manager: string
+  index: number
+  hashTraits: string
+  created: number
+  reserved: Array<number>
+  item: types.ItemJSON
+}
+
+export class Card {
+  readonly class: types.AccountClassKind
+  readonly globalState: types.GlobalStateKind
+  readonly store: PublicKey
+  readonly creator: PublicKey
+  readonly holder: PublicKey
+  readonly hash: BN
+  readonly page: BN
+  readonly manager: PublicKey
+  readonly index: number
+  readonly hashTraits: BN
+  readonly created: number
+  readonly reserved: Array<number>
+  readonly item: types.Item
+
+  static readonly discriminator = Buffer.from([
+    166, 250, 46, 230, 152, 63, 140, 182,
+  ])
+
+  static readonly layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    types.GlobalState.layout("globalState"),
+    borsh.publicKey("store"),
+    borsh.publicKey("creator"),
+    borsh.publicKey("holder"),
+    borsh.u64("hash"),
+    borsh.u64("page"),
+    borsh.publicKey("manager"),
+    borsh.u16("index"),
+    borsh.u64("hashTraits"),
+    borsh.u32("created"),
+    borsh.array(borsh.u8(), 16, "reserved"),
+    types.Item.layout("item"),
+  ])
+
+  constructor(fields: CardFields) {
+    this.class = fields.class
+    this.globalState = fields.globalState
+    this.store = fields.store
+    this.creator = fields.creator
+    this.holder = fields.holder
+    this.hash = fields.hash
+    this.page = fields.page
+    this.manager = fields.manager
+    this.index = fields.index
+    this.hashTraits = fields.hashTraits
+    this.created = fields.created
+    this.reserved = fields.reserved
+    this.item = new types.Item({ ...fields.item })
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Card | 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<Card | 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): Card {
+    if (!data.slice(0, 8).equals(Card.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = Card.layout.decode(data.slice(8))
+
+    return new Card({
+      class: types.AccountClass.fromDecoded(dec.class),
+      globalState: types.GlobalState.fromDecoded(dec.globalState),
+      store: dec.store,
+      creator: dec.creator,
+      holder: dec.holder,
+      hash: dec.hash,
+      page: dec.page,
+      manager: dec.manager,
+      index: dec.index,
+      hashTraits: dec.hashTraits,
+      created: dec.created,
+      reserved: dec.reserved,
+      item: types.Item.fromDecoded(dec.item),
+    })
+  }
+
+  toJSON(): CardJSON {
+    return {
+      class: this.class.toJSON(),
+      globalState: this.globalState.toJSON(),
+      store: this.store.toString(),
+      creator: this.creator.toString(),
+      holder: this.holder.toString(),
+      hash: this.hash.toString(),
+      page: this.page.toString(),
+      manager: this.manager.toString(),
+      index: this.index,
+      hashTraits: this.hashTraits.toString(),
+      created: this.created,
+      reserved: this.reserved,
+      item: this.item.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: CardJSON): Card {
+    return new Card({
+      class: types.AccountClass.fromJSON(obj.class),
+      globalState: types.GlobalState.fromJSON(obj.globalState),
+      store: new PublicKey(obj.store),
+      creator: new PublicKey(obj.creator),
+      holder: new PublicKey(obj.holder),
+      hash: new BN(obj.hash),
+      page: new BN(obj.page),
+      manager: new PublicKey(obj.manager),
+      index: obj.index,
+      hashTraits: new BN(obj.hashTraits),
+      created: obj.created,
+      reserved: obj.reserved,
+      item: types.Item.fromJSON(obj.item),
+    })
+  }
+}

package/src/types/accounts/CollectionRegistry.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 CollectionRegistryFields {
+  class: types.AccountClassKind
+  storeHash: BN
+  currency: PublicKey
+  collection: PublicKey
+  donations: BN
+  date: types.IndexDateFields
+  filters: Array<number>
+  track: types.SaleTrackFields
+}
+
+export interface CollectionRegistryJSON {
+  class: types.AccountClassJSON
+  storeHash: string
+  currency: string
+  collection: string
+  donations: string
+  date: types.IndexDateJSON
+  filters: Array<number>
+  track: types.SaleTrackJSON
+}
+
+export class CollectionRegistry {
+  readonly class: types.AccountClassKind
+  readonly storeHash: BN
+  readonly currency: PublicKey
+  readonly collection: PublicKey
+  readonly donations: BN
+  readonly date: types.IndexDate
+  readonly filters: Array<number>
+  readonly track: types.SaleTrack
+
+  static readonly discriminator = Buffer.from([
+    103, 157, 231, 9, 181, 43, 15, 106,
+  ])
+
+  static readonly layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    borsh.u64("storeHash"),
+    borsh.publicKey("currency"),
+    borsh.publicKey("collection"),
+    borsh.u64("donations"),
+    types.IndexDate.layout("date"),
+    borsh.array(borsh.u8(), 8, "filters"),
+    types.SaleTrack.layout("track"),
+  ])
+
+  constructor(fields: CollectionRegistryFields) {
+    this.class = fields.class
+    this.storeHash = fields.storeHash
+    this.currency = fields.currency
+    this.collection = fields.collection
+    this.donations = fields.donations
+    this.date = new types.IndexDate({ ...fields.date })
+    this.filters = fields.filters
+    this.track = new types.SaleTrack({ ...fields.track })
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<CollectionRegistry | 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<CollectionRegistry | 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): CollectionRegistry {
+    if (!data.slice(0, 8).equals(CollectionRegistry.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = CollectionRegistry.layout.decode(data.slice(8))
+
+    return new CollectionRegistry({
+      class: types.AccountClass.fromDecoded(dec.class),
+      storeHash: dec.storeHash,
+      currency: dec.currency,
+      collection: dec.collection,
+      donations: dec.donations,
+      date: types.IndexDate.fromDecoded(dec.date),
+      filters: dec.filters,
+      track: types.SaleTrack.fromDecoded(dec.track),
+    })
+  }
+
+  toJSON(): CollectionRegistryJSON {
+    return {
+      class: this.class.toJSON(),
+      storeHash: this.storeHash.toString(),
+      currency: this.currency.toString(),
+      collection: this.collection.toString(),
+      donations: this.donations.toString(),
+      date: this.date.toJSON(),
+      filters: this.filters,
+      track: this.track.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: CollectionRegistryJSON): CollectionRegistry {
+    return new CollectionRegistry({
+      class: types.AccountClass.fromJSON(obj.class),
+      storeHash: new BN(obj.storeHash),
+      currency: new PublicKey(obj.currency),
+      collection: new PublicKey(obj.collection),
+      donations: new BN(obj.donations),
+      date: types.IndexDate.fromJSON(obj.date),
+      filters: obj.filters,
+      track: types.SaleTrack.fromJSON(obj.track),
+    })
+  }
+}

package/src/types/accounts/CollectorRegistry.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 CollectorRegistryFields {
+  class: types.AccountClassKind
+  storeHash: BN
+  creator: PublicKey
+  holder: PublicKey
+  currency: PublicKey
+  date: types.IndexDateFields
+  filters: Array<number>
+  track: types.CollectTrackFields
+}
+
+export interface CollectorRegistryJSON {
+  class: types.AccountClassJSON
+  storeHash: string
+  creator: string
+  holder: string
+  currency: string
+  date: types.IndexDateJSON
+  filters: Array<number>
+  track: types.CollectTrackJSON
+}
+
+export class CollectorRegistry {
+  readonly class: types.AccountClassKind
+  readonly storeHash: BN
+  readonly creator: PublicKey
+  readonly holder: PublicKey
+  readonly currency: PublicKey
+  readonly date: types.IndexDate
+  readonly filters: Array<number>
+  readonly track: types.CollectTrack
+
+  static readonly discriminator = Buffer.from([
+    25, 164, 62, 184, 54, 145, 8, 211,
+  ])
+
+  static readonly layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    borsh.u64("storeHash"),
+    borsh.publicKey("creator"),
+    borsh.publicKey("holder"),
+    borsh.publicKey("currency"),
+    types.IndexDate.layout("date"),
+    borsh.array(borsh.u8(), 4, "filters"),
+    types.CollectTrack.layout("track"),
+  ])
+
+  constructor(fields: CollectorRegistryFields) {
+    this.class = fields.class
+    this.storeHash = fields.storeHash
+    this.creator = fields.creator
+    this.holder = fields.holder
+    this.currency = fields.currency
+    this.date = new types.IndexDate({ ...fields.date })
+    this.filters = fields.filters
+    this.track = new types.CollectTrack({ ...fields.track })
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<CollectorRegistry | 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<CollectorRegistry | 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): CollectorRegistry {
+    if (!data.slice(0, 8).equals(CollectorRegistry.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = CollectorRegistry.layout.decode(data.slice(8))
+
+    return new CollectorRegistry({
+      class: types.AccountClass.fromDecoded(dec.class),
+      storeHash: dec.storeHash,
+      creator: dec.creator,
+      holder: dec.holder,
+      currency: dec.currency,
+      date: types.IndexDate.fromDecoded(dec.date),
+      filters: dec.filters,
+      track: types.CollectTrack.fromDecoded(dec.track),
+    })
+  }
+
+  toJSON(): CollectorRegistryJSON {
+    return {
+      class: this.class.toJSON(),
+      storeHash: this.storeHash.toString(),
+      creator: this.creator.toString(),
+      holder: this.holder.toString(),
+      currency: this.currency.toString(),
+      date: this.date.toJSON(),
+      filters: this.filters,
+      track: this.track.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: CollectorRegistryJSON): CollectorRegistry {
+    return new CollectorRegistry({
+      class: types.AccountClass.fromJSON(obj.class),
+      storeHash: new BN(obj.storeHash),
+      creator: new PublicKey(obj.creator),
+      holder: new PublicKey(obj.holder),
+      currency: new PublicKey(obj.currency),
+      date: types.IndexDate.fromJSON(obj.date),
+      filters: obj.filters,
+      track: types.CollectTrack.fromJSON(obj.track),
+    })
+  }
+}