3land_sdk 1.0.0

package/src/types/types/IndexDate.ts

@@ -0,0 +1,94 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface IndexDateFields {
+  hour: number
+  day: number
+  week: number
+  month: number
+  minRelative: number
+}
+
+export interface IndexDateJSON {
+  hour: number
+  day: number
+  week: number
+  month: number
+  minRelative: number
+}
+
+export class IndexDate {
+  readonly hour: number
+  readonly day: number
+  readonly week: number
+  readonly month: number
+  readonly minRelative: number
+
+  constructor(fields: IndexDateFields) {
+    this.hour = fields.hour
+    this.day = fields.day
+    this.week = fields.week
+    this.month = fields.month
+    this.minRelative = fields.minRelative
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.u32("hour"),
+        borsh.u32("day"),
+        borsh.u32("week"),
+        borsh.u32("month"),
+        borsh.u8("minRelative"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new IndexDate({
+      hour: obj.hour,
+      day: obj.day,
+      week: obj.week,
+      month: obj.month,
+      minRelative: obj.minRelative,
+    })
+  }
+
+  static toEncodable(fields: IndexDateFields) {
+    return {
+      hour: fields.hour,
+      day: fields.day,
+      week: fields.week,
+      month: fields.month,
+      minRelative: fields.minRelative,
+    }
+  }
+
+  toJSON(): IndexDateJSON {
+    return {
+      hour: this.hour,
+      day: this.day,
+      week: this.week,
+      month: this.month,
+      minRelative: this.minRelative,
+    }
+  }
+
+  static fromJSON(obj: IndexDateJSON): IndexDate {
+    return new IndexDate({
+      hour: obj.hour,
+      day: obj.day,
+      week: obj.week,
+      month: obj.month,
+      minRelative: obj.minRelative,
+    })
+  }
+
+  toEncodable() {
+    return IndexDate.toEncodable(this)
+  }
+}

package/src/types/types/IndexDates.ts

@@ -0,0 +1,64 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface IndexDatesFields {
+  created: types.IndexDateFields
+  activity: types.IndexDateFields
+}
+
+export interface IndexDatesJSON {
+  created: types.IndexDateJSON
+  activity: types.IndexDateJSON
+}
+
+export class IndexDates {
+  readonly created: types.IndexDate
+  readonly activity: types.IndexDate
+
+  constructor(fields: IndexDatesFields) {
+    this.created = new types.IndexDate({ ...fields.created })
+    this.activity = new types.IndexDate({ ...fields.activity })
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [types.IndexDate.layout("created"), types.IndexDate.layout("activity")],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new IndexDates({
+      created: types.IndexDate.fromDecoded(obj.created),
+      activity: types.IndexDate.fromDecoded(obj.activity),
+    })
+  }
+
+  static toEncodable(fields: IndexDatesFields) {
+    return {
+      created: types.IndexDate.toEncodable(fields.created),
+      activity: types.IndexDate.toEncodable(fields.activity),
+    }
+  }
+
+  toJSON(): IndexDatesJSON {
+    return {
+      created: this.created.toJSON(),
+      activity: this.activity.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: IndexDatesJSON): IndexDates {
+    return new IndexDates({
+      created: types.IndexDate.fromJSON(obj.created),
+      activity: types.IndexDate.fromJSON(obj.activity),
+    })
+  }
+
+  toEncodable() {
+    return IndexDates.toEncodable(this)
+  }
+}

package/src/types/types/Item.ts

@@ -0,0 +1,53 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface ItemFields {
+  metadata: types.MetadataArgsFields
+}
+
+export interface ItemJSON {
+  metadata: types.MetadataArgsJSON
+}
+
+export class Item {
+  readonly metadata: types.MetadataArgs
+
+  constructor(fields: ItemFields) {
+    this.metadata = new types.MetadataArgs({ ...fields.metadata })
+  }
+
+  static layout(property?: string) {
+    return borsh.struct([types.MetadataArgs.layout("metadata")], property)
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new Item({
+      metadata: types.MetadataArgs.fromDecoded(obj.metadata),
+    })
+  }
+
+  static toEncodable(fields: ItemFields) {
+    return {
+      metadata: types.MetadataArgs.toEncodable(fields.metadata),
+    }
+  }
+
+  toJSON(): ItemJSON {
+    return {
+      metadata: this.metadata.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: ItemJSON): Item {
+    return new Item({
+      metadata: types.MetadataArgs.fromJSON(obj.metadata),
+    })
+  }
+
+  toEncodable() {
+    return Item.toEncodable(this)
+  }
+}

package/src/types/types/ItemClass.ts

@@ -0,0 +1,88 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface SingleJSON {
+  kind: "Single"
+}
+
+export class Single {
+  static readonly discriminator = 0
+  static readonly kind = "Single"
+  readonly discriminator = 0
+  readonly kind = "Single"
+
+  toJSON(): SingleJSON {
+    return {
+      kind: "Single",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Single: {},
+    }
+  }
+}
+
+export interface PackJSON {
+  kind: "Pack"
+}
+
+export class Pack {
+  static readonly discriminator = 1
+  static readonly kind = "Pack"
+  readonly discriminator = 1
+  readonly kind = "Pack"
+
+  toJSON(): PackJSON {
+    return {
+      kind: "Pack",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Pack: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.ItemClassKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("Single" in obj) {
+    return new Single()
+  }
+  if ("Pack" in obj) {
+    return new Pack()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.ItemClassJSON): types.ItemClassKind {
+  switch (obj.kind) {
+    case "Single": {
+      return new Single()
+    }
+    case "Pack": {
+      return new Pack()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "Single"),
+    borsh.struct([], "Pack"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/ItemState.ts

@@ -0,0 +1,298 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface ActiveJSON {
+  kind: "Active"
+}
+
+export class Active {
+  static readonly discriminator = 0
+  static readonly kind = "Active"
+  readonly discriminator = 0
+  readonly kind = "Active"
+
+  toJSON(): ActiveJSON {
+    return {
+      kind: "Active",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Active: {},
+    }
+  }
+}
+
+export interface HiddenJSON {
+  kind: "Hidden"
+}
+
+export class Hidden {
+  static readonly discriminator = 1
+  static readonly kind = "Hidden"
+  readonly discriminator = 1
+  readonly kind = "Hidden"
+
+  toJSON(): HiddenJSON {
+    return {
+      kind: "Hidden",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Hidden: {},
+    }
+  }
+}
+
+export interface InactiveJSON {
+  kind: "Inactive"
+}
+
+export class Inactive {
+  static readonly discriminator = 2
+  static readonly kind = "Inactive"
+  readonly discriminator = 2
+  readonly kind = "Inactive"
+
+  toJSON(): InactiveJSON {
+    return {
+      kind: "Inactive",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Inactive: {},
+    }
+  }
+}
+
+export interface RetiredJSON {
+  kind: "Retired"
+}
+
+export class Retired {
+  static readonly discriminator = 3
+  static readonly kind = "Retired"
+  readonly discriminator = 3
+  readonly kind = "Retired"
+
+  toJSON(): RetiredJSON {
+    return {
+      kind: "Retired",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Retired: {},
+    }
+  }
+}
+
+export interface SoldOutJSON {
+  kind: "SoldOut"
+}
+
+export class SoldOut {
+  static readonly discriminator = 4
+  static readonly kind = "SoldOut"
+  readonly discriminator = 4
+  readonly kind = "SoldOut"
+
+  toJSON(): SoldOutJSON {
+    return {
+      kind: "SoldOut",
+    }
+  }
+
+  toEncodable() {
+    return {
+      SoldOut: {},
+    }
+  }
+}
+
+export interface NoneJSON {
+  kind: "None"
+}
+
+export class None {
+  static readonly discriminator = 5
+  static readonly kind = "None"
+  readonly discriminator = 5
+  readonly kind = "None"
+
+  toJSON(): NoneJSON {
+    return {
+      kind: "None",
+    }
+  }
+
+  toEncodable() {
+    return {
+      None: {},
+    }
+  }
+}
+
+export interface NotReadyJSON {
+  kind: "NotReady"
+}
+
+export class NotReady {
+  static readonly discriminator = 6
+  static readonly kind = "NotReady"
+  readonly discriminator = 6
+  readonly kind = "NotReady"
+
+  toJSON(): NotReadyJSON {
+    return {
+      kind: "NotReady",
+    }
+  }
+
+  toEncodable() {
+    return {
+      NotReady: {},
+    }
+  }
+}
+
+export interface NotReadyStartedJSON {
+  kind: "NotReadyStarted"
+}
+
+export class NotReadyStarted {
+  static readonly discriminator = 7
+  static readonly kind = "NotReadyStarted"
+  readonly discriminator = 7
+  readonly kind = "NotReadyStarted"
+
+  toJSON(): NotReadyStartedJSON {
+    return {
+      kind: "NotReadyStarted",
+    }
+  }
+
+  toEncodable() {
+    return {
+      NotReadyStarted: {},
+    }
+  }
+}
+
+export interface FlaggedJSON {
+  kind: "Flagged"
+}
+
+export class Flagged {
+  static readonly discriminator = 8
+  static readonly kind = "Flagged"
+  readonly discriminator = 8
+  readonly kind = "Flagged"
+
+  toJSON(): FlaggedJSON {
+    return {
+      kind: "Flagged",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Flagged: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.ItemStateKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("Active" in obj) {
+    return new Active()
+  }
+  if ("Hidden" in obj) {
+    return new Hidden()
+  }
+  if ("Inactive" in obj) {
+    return new Inactive()
+  }
+  if ("Retired" in obj) {
+    return new Retired()
+  }
+  if ("SoldOut" in obj) {
+    return new SoldOut()
+  }
+  if ("None" in obj) {
+    return new None()
+  }
+  if ("NotReady" in obj) {
+    return new NotReady()
+  }
+  if ("NotReadyStarted" in obj) {
+    return new NotReadyStarted()
+  }
+  if ("Flagged" in obj) {
+    return new Flagged()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.ItemStateJSON): types.ItemStateKind {
+  switch (obj.kind) {
+    case "Active": {
+      return new Active()
+    }
+    case "Hidden": {
+      return new Hidden()
+    }
+    case "Inactive": {
+      return new Inactive()
+    }
+    case "Retired": {
+      return new Retired()
+    }
+    case "SoldOut": {
+      return new SoldOut()
+    }
+    case "None": {
+      return new None()
+    }
+    case "NotReady": {
+      return new NotReady()
+    }
+    case "NotReadyStarted": {
+      return new NotReadyStarted()
+    }
+    case "Flagged": {
+      return new Flagged()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "Active"),
+    borsh.struct([], "Hidden"),
+    borsh.struct([], "Inactive"),
+    borsh.struct([], "Retired"),
+    borsh.struct([], "SoldOut"),
+    borsh.struct([], "None"),
+    borsh.struct([], "NotReady"),
+    borsh.struct([], "NotReadyStarted"),
+    borsh.struct([], "Flagged"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/ItemTrack.ts

@@ -0,0 +1,76 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface ItemTrackFields {
+  state: types.ItemStateKind
+  supply: BN
+  created: BN
+}
+
+export interface ItemTrackJSON {
+  state: types.ItemStateJSON
+  supply: string
+  created: string
+}
+
+export class ItemTrack {
+  readonly state: types.ItemStateKind
+  readonly supply: BN
+  readonly created: BN
+
+  constructor(fields: ItemTrackFields) {
+    this.state = fields.state
+    this.supply = fields.supply
+    this.created = fields.created
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        types.ItemState.layout("state"),
+        borsh.u64("supply"),
+        borsh.u64("created"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new ItemTrack({
+      state: types.ItemState.fromDecoded(obj.state),
+      supply: obj.supply,
+      created: obj.created,
+    })
+  }
+
+  static toEncodable(fields: ItemTrackFields) {
+    return {
+      state: fields.state.toEncodable(),
+      supply: fields.supply,
+      created: fields.created,
+    }
+  }
+
+  toJSON(): ItemTrackJSON {
+    return {
+      state: this.state.toJSON(),
+      supply: this.supply.toString(),
+      created: this.created.toString(),
+    }
+  }
+
+  static fromJSON(obj: ItemTrackJSON): ItemTrack {
+    return new ItemTrack({
+      state: types.ItemState.fromJSON(obj.state),
+      supply: new BN(obj.supply),
+      created: new BN(obj.created),
+    })
+  }
+
+  toEncodable() {
+    return ItemTrack.toEncodable(this)
+  }
+}