3land_sdk 1.0.0

package/src/types/types/PackOpenHolderState.ts

@@ -0,0 +1,120 @@
+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 UnclaimedJSON {
+  kind: "Unclaimed"
+}
+
+export class Unclaimed {
+  static readonly discriminator = 0
+  static readonly kind = "Unclaimed"
+  readonly discriminator = 0
+  readonly kind = "Unclaimed"
+
+  toJSON(): UnclaimedJSON {
+    return {
+      kind: "Unclaimed",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Unclaimed: {},
+    }
+  }
+}
+
+export interface ClaimingJSON {
+  kind: "Claiming"
+}
+
+export class Claiming {
+  static readonly discriminator = 1
+  static readonly kind = "Claiming"
+  readonly discriminator = 1
+  readonly kind = "Claiming"
+
+  toJSON(): ClaimingJSON {
+    return {
+      kind: "Claiming",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Claiming: {},
+    }
+  }
+}
+
+export interface ClaimedJSON {
+  kind: "Claimed"
+}
+
+export class Claimed {
+  static readonly discriminator = 2
+  static readonly kind = "Claimed"
+  readonly discriminator = 2
+  readonly kind = "Claimed"
+
+  toJSON(): ClaimedJSON {
+    return {
+      kind: "Claimed",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Claimed: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.PackOpenHolderStateKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("Unclaimed" in obj) {
+    return new Unclaimed()
+  }
+  if ("Claiming" in obj) {
+    return new Claiming()
+  }
+  if ("Claimed" in obj) {
+    return new Claimed()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(
+  obj: types.PackOpenHolderStateJSON
+): types.PackOpenHolderStateKind {
+  switch (obj.kind) {
+    case "Unclaimed": {
+      return new Unclaimed()
+    }
+    case "Claiming": {
+      return new Claiming()
+    }
+    case "Claimed": {
+      return new Claimed()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "Unclaimed"),
+    borsh.struct([], "Claiming"),
+    borsh.struct([], "Claimed"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/PackRule.ts

@@ -0,0 +1,85 @@
+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 type CoolDownToOpenFields = {
+  seconds: number
+}
+export type CoolDownToOpenValue = {
+  seconds: number
+}
+
+export interface CoolDownToOpenJSON {
+  kind: "CoolDownToOpen"
+  value: {
+    seconds: number
+  }
+}
+
+export class CoolDownToOpen {
+  static readonly discriminator = 0
+  static readonly kind = "CoolDownToOpen"
+  readonly discriminator = 0
+  readonly kind = "CoolDownToOpen"
+  readonly value: CoolDownToOpenValue
+
+  constructor(value: CoolDownToOpenFields) {
+    this.value = {
+      seconds: value.seconds,
+    }
+  }
+
+  toJSON(): CoolDownToOpenJSON {
+    return {
+      kind: "CoolDownToOpen",
+      value: {
+        seconds: this.value.seconds,
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      CoolDownToOpen: {
+        seconds: this.value.seconds,
+      },
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.PackRuleKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("CoolDownToOpen" in obj) {
+    const val = obj["CoolDownToOpen"]
+    return new CoolDownToOpen({
+      seconds: val["seconds"],
+    })
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.PackRuleJSON): types.PackRuleKind {
+  switch (obj.kind) {
+    case "CoolDownToOpen": {
+      return new CoolDownToOpen({
+        seconds: obj.value.seconds,
+      })
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([borsh.u32("seconds")], "CoolDownToOpen"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/PackState.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 ClosedJSON {
+  kind: "Closed"
+}
+
+export class Closed {
+  static readonly discriminator = 0
+  static readonly kind = "Closed"
+  readonly discriminator = 0
+  readonly kind = "Closed"
+
+  toJSON(): ClosedJSON {
+    return {
+      kind: "Closed",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Closed: {},
+    }
+  }
+}
+
+export interface OpenedJSON {
+  kind: "Opened"
+}
+
+export class Opened {
+  static readonly discriminator = 1
+  static readonly kind = "Opened"
+  readonly discriminator = 1
+  readonly kind = "Opened"
+
+  toJSON(): OpenedJSON {
+    return {
+      kind: "Opened",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Opened: {},
+    }
+  }
+}
+
+export interface UnassignedJSON {
+  kind: "Unassigned"
+}
+
+export class Unassigned {
+  static readonly discriminator = 2
+  static readonly kind = "Unassigned"
+  readonly discriminator = 2
+  readonly kind = "Unassigned"
+
+  toJSON(): UnassignedJSON {
+    return {
+      kind: "Unassigned",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Unassigned: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.PackStateKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("Closed" in obj) {
+    return new Closed()
+  }
+  if ("Opened" in obj) {
+    return new Opened()
+  }
+  if ("Unassigned" in obj) {
+    return new Unassigned()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.PackStateJSON): types.PackStateKind {
+  switch (obj.kind) {
+    case "Closed": {
+      return new Closed()
+    }
+    case "Opened": {
+      return new Opened()
+    }
+    case "Unassigned": {
+      return new Unassigned()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "Closed"),
+    borsh.struct([], "Opened"),
+    borsh.struct([], "Unassigned"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/PackType.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 RandomDirectJSON {
+  kind: "RandomDirect"
+}
+
+export class RandomDirect {
+  static readonly discriminator = 0
+  static readonly kind = "RandomDirect"
+  readonly discriminator = 0
+  readonly kind = "RandomDirect"
+
+  toJSON(): RandomDirectJSON {
+    return {
+      kind: "RandomDirect",
+    }
+  }
+
+  toEncodable() {
+    return {
+      RandomDirect: {},
+    }
+  }
+}
+
+export interface RandomPackJSON {
+  kind: "RandomPack"
+}
+
+export class RandomPack {
+  static readonly discriminator = 1
+  static readonly kind = "RandomPack"
+  readonly discriminator = 1
+  readonly kind = "RandomPack"
+
+  toJSON(): RandomPackJSON {
+    return {
+      kind: "RandomPack",
+    }
+  }
+
+  toEncodable() {
+    return {
+      RandomPack: {},
+    }
+  }
+}
+
+export interface BundleJSON {
+  kind: "Bundle"
+}
+
+export class Bundle {
+  static readonly discriminator = 2
+  static readonly kind = "Bundle"
+  readonly discriminator = 2
+  readonly kind = "Bundle"
+
+  toJSON(): BundleJSON {
+    return {
+      kind: "Bundle",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Bundle: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.PackTypeKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("RandomDirect" in obj) {
+    return new RandomDirect()
+  }
+  if ("RandomPack" in obj) {
+    return new RandomPack()
+  }
+  if ("Bundle" in obj) {
+    return new Bundle()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.PackTypeJSON): types.PackTypeKind {
+  switch (obj.kind) {
+    case "RandomDirect": {
+      return new RandomDirect()
+    }
+    case "RandomPack": {
+      return new RandomPack()
+    }
+    case "Bundle": {
+      return new Bundle()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "RandomDirect"),
+    borsh.struct([], "RandomPack"),
+    borsh.struct([], "Bundle"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/PaymentClass.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 PaymentV1JSON {
+  kind: "PaymentV1"
+}
+
+export class PaymentV1 {
+  static readonly discriminator = 0
+  static readonly kind = "PaymentV1"
+  readonly discriminator = 0
+  readonly kind = "PaymentV1"
+
+  toJSON(): PaymentV1JSON {
+    return {
+      kind: "PaymentV1",
+    }
+  }
+
+  toEncodable() {
+    return {
+      PaymentV1: {},
+    }
+  }
+}
+
+export interface BurnPaymentV1JSON {
+  kind: "BurnPaymentV1"
+}
+
+export class BurnPaymentV1 {
+  static readonly discriminator = 1
+  static readonly kind = "BurnPaymentV1"
+  readonly discriminator = 1
+  readonly kind = "BurnPaymentV1"
+
+  toJSON(): BurnPaymentV1JSON {
+    return {
+      kind: "BurnPaymentV1",
+    }
+  }
+
+  toEncodable() {
+    return {
+      BurnPaymentV1: {},
+    }
+  }
+}
+
+export interface GatePaymentV1JSON {
+  kind: "GatePaymentV1"
+}
+
+export class GatePaymentV1 {
+  static readonly discriminator = 2
+  static readonly kind = "GatePaymentV1"
+  readonly discriminator = 2
+  readonly kind = "GatePaymentV1"
+
+  toJSON(): GatePaymentV1JSON {
+    return {
+      kind: "GatePaymentV1",
+    }
+  }
+
+  toEncodable() {
+    return {
+      GatePaymentV1: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.PaymentClassKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("PaymentV1" in obj) {
+    return new PaymentV1()
+  }
+  if ("BurnPaymentV1" in obj) {
+    return new BurnPaymentV1()
+  }
+  if ("GatePaymentV1" in obj) {
+    return new GatePaymentV1()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.PaymentClassJSON): types.PaymentClassKind {
+  switch (obj.kind) {
+    case "PaymentV1": {
+      return new PaymentV1()
+    }
+    case "BurnPaymentV1": {
+      return new BurnPaymentV1()
+    }
+    case "GatePaymentV1": {
+      return new GatePaymentV1()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "PaymentV1"),
+    borsh.struct([], "BurnPaymentV1"),
+    borsh.struct([], "GatePaymentV1"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/PoolAccess.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 CpiJSON {
+  kind: "Cpi"
+}
+
+export class Cpi {
+  static readonly discriminator = 0
+  static readonly kind = "Cpi"
+  readonly discriminator = 0
+  readonly kind = "Cpi"
+
+  toJSON(): CpiJSON {
+    return {
+      kind: "Cpi",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Cpi: {},
+    }
+  }
+}
+
+export interface PublicJSON {
+  kind: "Public"
+}
+
+export class Public {
+  static readonly discriminator = 1
+  static readonly kind = "Public"
+  readonly discriminator = 1
+  readonly kind = "Public"
+
+  toJSON(): PublicJSON {
+    return {
+      kind: "Public",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Public: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.PoolAccessKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("Cpi" in obj) {
+    return new Cpi()
+  }
+  if ("Public" in obj) {
+    return new Public()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.PoolAccessJSON): types.PoolAccessKind {
+  switch (obj.kind) {
+    case "Cpi": {
+      return new Cpi()
+    }
+    case "Public": {
+      return new Public()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "Cpi"),
+    borsh.struct([], "Public"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}