3land_sdk 1.0.0

package/src/types/types/EncryptedPayload.ts

@@ -0,0 +1,61 @@
+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 EncryptedPayloadFields {
+  encType: number
+  arweave: string
+}
+
+export interface EncryptedPayloadJSON {
+  encType: number
+  arweave: string
+}
+
+export class EncryptedPayload {
+  readonly encType: number
+  readonly arweave: string
+
+  constructor(fields: EncryptedPayloadFields) {
+    this.encType = fields.encType
+    this.arweave = fields.arweave
+  }
+
+  static layout(property?: string) {
+    return borsh.struct([borsh.u8("encType"), borsh.str("arweave")], property)
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new EncryptedPayload({
+      encType: obj.encType,
+      arweave: obj.arweave,
+    })
+  }
+
+  static toEncodable(fields: EncryptedPayloadFields) {
+    return {
+      encType: fields.encType,
+      arweave: fields.arweave,
+    }
+  }
+
+  toJSON(): EncryptedPayloadJSON {
+    return {
+      encType: this.encType,
+      arweave: this.arweave,
+    }
+  }
+
+  static fromJSON(obj: EncryptedPayloadJSON): EncryptedPayload {
+    return new EncryptedPayload({
+      encType: obj.encType,
+      arweave: obj.arweave,
+    })
+  }
+
+  toEncodable() {
+    return EncryptedPayload.toEncodable(this)
+  }
+}

package/src/types/types/ExtraParameter.ts

@@ -0,0 +1,117 @@
+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 NoneJSON {
+  kind: "None"
+}
+
+export class None {
+  static readonly discriminator = 0
+  static readonly kind = "None"
+  readonly discriminator = 0
+  readonly kind = "None"
+
+  toJSON(): NoneJSON {
+    return {
+      kind: "None",
+    }
+  }
+
+  toEncodable() {
+    return {
+      None: {},
+    }
+  }
+}
+
+export type RevealerFields = {
+  random: number
+}
+export type RevealerValue = {
+  random: number
+}
+
+export interface RevealerJSON {
+  kind: "Revealer"
+  value: {
+    random: number
+  }
+}
+
+export class Revealer {
+  static readonly discriminator = 1
+  static readonly kind = "Revealer"
+  readonly discriminator = 1
+  readonly kind = "Revealer"
+  readonly value: RevealerValue
+
+  constructor(value: RevealerFields) {
+    this.value = {
+      random: value.random,
+    }
+  }
+
+  toJSON(): RevealerJSON {
+    return {
+      kind: "Revealer",
+      value: {
+        random: this.value.random,
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      Revealer: {
+        random: this.value.random,
+      },
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.ExtraParameterKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("None" in obj) {
+    return new None()
+  }
+  if ("Revealer" in obj) {
+    const val = obj["Revealer"]
+    return new Revealer({
+      random: val["random"],
+    })
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(
+  obj: types.ExtraParameterJSON
+): types.ExtraParameterKind {
+  switch (obj.kind) {
+    case "None": {
+      return new None()
+    }
+    case "Revealer": {
+      return new Revealer({
+        random: obj.value.random,
+      })
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "None"),
+    borsh.struct([borsh.u16("random")], "Revealer"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/FakeBurnCount.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 FakeBurnCountFields {
+  key: BN
+  track: types.DepositTrackFields
+}
+
+export interface FakeBurnCountJSON {
+  key: string
+  track: types.DepositTrackJSON
+}
+
+export class FakeBurnCount {
+  readonly key: BN
+  readonly track: types.DepositTrack
+
+  constructor(fields: FakeBurnCountFields) {
+    this.key = fields.key
+    this.track = new types.DepositTrack({ ...fields.track })
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [borsh.u64("key"), types.DepositTrack.layout("track")],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new FakeBurnCount({
+      key: obj.key,
+      track: types.DepositTrack.fromDecoded(obj.track),
+    })
+  }
+
+  static toEncodable(fields: FakeBurnCountFields) {
+    return {
+      key: fields.key,
+      track: types.DepositTrack.toEncodable(fields.track),
+    }
+  }
+
+  toJSON(): FakeBurnCountJSON {
+    return {
+      key: this.key.toString(),
+      track: this.track.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: FakeBurnCountJSON): FakeBurnCount {
+    return new FakeBurnCount({
+      key: new BN(obj.key),
+      track: types.DepositTrack.fromJSON(obj.track),
+    })
+  }
+
+  toEncodable() {
+    return FakeBurnCount.toEncodable(this)
+  }
+}

package/src/types/types/FakeDeposit.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 FakeDepositFields {
+  key: BN
+  track: types.BurnCountFields
+}
+
+export interface FakeDepositJSON {
+  key: string
+  track: types.BurnCountJSON
+}
+
+export class FakeDeposit {
+  readonly key: BN
+  readonly track: types.BurnCount
+
+  constructor(fields: FakeDepositFields) {
+    this.key = fields.key
+    this.track = new types.BurnCount({ ...fields.track })
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [borsh.u64("key"), types.BurnCount.layout("track")],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new FakeDeposit({
+      key: obj.key,
+      track: types.BurnCount.fromDecoded(obj.track),
+    })
+  }
+
+  static toEncodable(fields: FakeDepositFields) {
+    return {
+      key: fields.key,
+      track: types.BurnCount.toEncodable(fields.track),
+    }
+  }
+
+  toJSON(): FakeDepositJSON {
+    return {
+      key: this.key.toString(),
+      track: this.track.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: FakeDepositJSON): FakeDeposit {
+    return new FakeDeposit({
+      key: new BN(obj.key),
+      track: types.BurnCount.fromJSON(obj.track),
+    })
+  }
+
+  toEncodable() {
+    return FakeDeposit.toEncodable(this)
+  }
+}

package/src/types/types/FakeTraitPair.ts

@@ -0,0 +1,61 @@
+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 FakeTraitPairFields {
+  trait_type: string
+  value: string
+}
+
+export interface FakeTraitPairJSON {
+  trait_type: string
+  value: string
+}
+
+export class FakeTraitPair {
+  readonly trait_type: string
+  readonly value: string
+
+  constructor(fields: FakeTraitPairFields) {
+    this.trait_type = fields.trait_type
+    this.value = fields.value
+  }
+
+  static layout(property?: string) {
+    return borsh.struct([borsh.str("trait_type"), borsh.str("value")], property)
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new FakeTraitPair({
+      trait_type: obj.trait_type,
+      value: obj.value,
+    })
+  }
+
+  static toEncodable(fields: FakeTraitPairFields) {
+    return {
+      trait_type: fields.trait_type,
+      value: fields.value,
+    }
+  }
+
+  toJSON(): FakeTraitPairJSON {
+    return {
+      trait_type: this.trait_type,
+      value: this.value,
+    }
+  }
+
+  static fromJSON(obj: FakeTraitPairJSON): FakeTraitPair {
+    return new FakeTraitPair({
+      trait_type: obj.trait_type,
+      value: obj.value,
+    })
+  }
+
+  toEncodable() {
+    return FakeTraitPair.toEncodable(this)
+  }
+}

package/src/types/types/FakeTraitValue.ts

@@ -0,0 +1,61 @@
+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 FakeTraitValueFields {
+  trait_value: BN
+  state: number
+}
+
+export interface FakeTraitValueJSON {
+  trait_value: string
+  state: number
+}
+
+export class FakeTraitValue {
+  readonly trait_value: BN
+  readonly state: number
+
+  constructor(fields: FakeTraitValueFields) {
+    this.trait_value = fields.trait_value
+    this.state = fields.state
+  }
+
+  static layout(property?: string) {
+    return borsh.struct([borsh.u64("trait_value"), borsh.u8("state")], property)
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new FakeTraitValue({
+      trait_value: obj.trait_value,
+      state: obj.state,
+    })
+  }
+
+  static toEncodable(fields: FakeTraitValueFields) {
+    return {
+      trait_value: fields.trait_value,
+      state: fields.state,
+    }
+  }
+
+  toJSON(): FakeTraitValueJSON {
+    return {
+      trait_value: this.trait_value.toString(),
+      state: this.state,
+    }
+  }
+
+  static fromJSON(obj: FakeTraitValueJSON): FakeTraitValue {
+    return new FakeTraitValue({
+      trait_value: new BN(obj.trait_value),
+      state: obj.state,
+    })
+  }
+
+  toEncodable() {
+    return FakeTraitValue.toEncodable(this)
+  }
+}

package/src/types/types/FakeVolumeTrack.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 FakeVolumeTrackFields {
+  key: PublicKey
+  track: types.VolumeTrackFields
+}
+
+export interface FakeVolumeTrackJSON {
+  key: string
+  track: types.VolumeTrackJSON
+}
+
+export class FakeVolumeTrack {
+  readonly key: PublicKey
+  readonly track: types.VolumeTrack
+
+  constructor(fields: FakeVolumeTrackFields) {
+    this.key = fields.key
+    this.track = new types.VolumeTrack({ ...fields.track })
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [borsh.publicKey("key"), types.VolumeTrack.layout("track")],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new FakeVolumeTrack({
+      key: obj.key,
+      track: types.VolumeTrack.fromDecoded(obj.track),
+    })
+  }
+
+  static toEncodable(fields: FakeVolumeTrackFields) {
+    return {
+      key: fields.key,
+      track: types.VolumeTrack.toEncodable(fields.track),
+    }
+  }
+
+  toJSON(): FakeVolumeTrackJSON {
+    return {
+      key: this.key.toString(),
+      track: this.track.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: FakeVolumeTrackJSON): FakeVolumeTrack {
+    return new FakeVolumeTrack({
+      key: new PublicKey(obj.key),
+      track: types.VolumeTrack.fromJSON(obj.track),
+    })
+  }
+
+  toEncodable() {
+    return FakeVolumeTrack.toEncodable(this)
+  }
+}

package/src/types/types/FeeType.ts

@@ -0,0 +1,118 @@
+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 AllMintsJSON {
+  kind: "AllMints"
+}
+
+export class AllMints {
+  static readonly discriminator = 0
+  static readonly kind = "AllMints"
+  readonly discriminator = 0
+  readonly kind = "AllMints"
+
+  toJSON(): AllMintsJSON {
+    return {
+      kind: "AllMints",
+    }
+  }
+
+  toEncodable() {
+    return {
+      AllMints: {},
+    }
+  }
+}
+
+export interface PricedMintsOnlyJSON {
+  kind: "PricedMintsOnly"
+}
+
+export class PricedMintsOnly {
+  static readonly discriminator = 1
+  static readonly kind = "PricedMintsOnly"
+  readonly discriminator = 1
+  readonly kind = "PricedMintsOnly"
+
+  toJSON(): PricedMintsOnlyJSON {
+    return {
+      kind: "PricedMintsOnly",
+    }
+  }
+
+  toEncodable() {
+    return {
+      PricedMintsOnly: {},
+    }
+  }
+}
+
+export interface SkipBurnMintsJSON {
+  kind: "SkipBurnMints"
+}
+
+export class SkipBurnMints {
+  static readonly discriminator = 2
+  static readonly kind = "SkipBurnMints"
+  readonly discriminator = 2
+  readonly kind = "SkipBurnMints"
+
+  toJSON(): SkipBurnMintsJSON {
+    return {
+      kind: "SkipBurnMints",
+    }
+  }
+
+  toEncodable() {
+    return {
+      SkipBurnMints: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.FeeTypeKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("AllMints" in obj) {
+    return new AllMints()
+  }
+  if ("PricedMintsOnly" in obj) {
+    return new PricedMintsOnly()
+  }
+  if ("SkipBurnMints" in obj) {
+    return new SkipBurnMints()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.FeeTypeJSON): types.FeeTypeKind {
+  switch (obj.kind) {
+    case "AllMints": {
+      return new AllMints()
+    }
+    case "PricedMintsOnly": {
+      return new PricedMintsOnly()
+    }
+    case "SkipBurnMints": {
+      return new SkipBurnMints()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "AllMints"),
+    borsh.struct([], "PricedMintsOnly"),
+    borsh.struct([], "SkipBurnMints"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/FeedingTraits.ts

@@ -0,0 +1,57 @@
+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 FeedingTraitsFields {
+  list: Array<types.TraitInitKind>
+}
+
+export interface FeedingTraitsJSON {
+  list: Array<types.TraitInitJSON>
+}
+
+export class FeedingTraits {
+  readonly list: Array<types.TraitInitKind>
+
+  constructor(fields: FeedingTraitsFields) {
+    this.list = fields.list
+  }
+
+  static layout(property?: string) {
+    return borsh.struct([borsh.vec(types.TraitInit.layout(), "list")], property)
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new FeedingTraits({
+      list: obj.list.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.TraitInit.fromDecoded(item)
+      ),
+    })
+  }
+
+  static toEncodable(fields: FeedingTraitsFields) {
+    return {
+      list: fields.list.map((item) => item.toEncodable()),
+    }
+  }
+
+  toJSON(): FeedingTraitsJSON {
+    return {
+      list: this.list.map((item) => item.toJSON()),
+    }
+  }
+
+  static fromJSON(obj: FeedingTraitsJSON): FeedingTraits {
+    return new FeedingTraits({
+      list: obj.list.map((item) => types.TraitInit.fromJSON(item)),
+    })
+  }
+
+  toEncodable() {
+    return FeedingTraits.toEncodable(this)
+  }
+}