3land_sdk 1.0.0

package/src/types/types/Filter.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 FilterFields {
+  filter1: types.FilterTypeKind
+  filter2: types.FilterTypeKind
+}
+
+export interface FilterJSON {
+  filter1: types.FilterTypeJSON
+  filter2: types.FilterTypeJSON
+}
+
+export class Filter {
+  readonly filter1: types.FilterTypeKind
+  readonly filter2: types.FilterTypeKind
+
+  constructor(fields: FilterFields) {
+    this.filter1 = fields.filter1
+    this.filter2 = fields.filter2
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [types.FilterType.layout("filter1"), types.FilterType.layout("filter2")],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new Filter({
+      filter1: types.FilterType.fromDecoded(obj.filter1),
+      filter2: types.FilterType.fromDecoded(obj.filter2),
+    })
+  }
+
+  static toEncodable(fields: FilterFields) {
+    return {
+      filter1: fields.filter1.toEncodable(),
+      filter2: fields.filter2.toEncodable(),
+    }
+  }
+
+  toJSON(): FilterJSON {
+    return {
+      filter1: this.filter1.toJSON(),
+      filter2: this.filter2.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: FilterJSON): Filter {
+    return new Filter({
+      filter1: types.FilterType.fromJSON(obj.filter1),
+      filter2: types.FilterType.fromJSON(obj.filter2),
+    })
+  }
+
+  toEncodable() {
+    return Filter.toEncodable(this)
+  }
+}

package/src/types/types/FilterType.ts

@@ -0,0 +1,56 @@
+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: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.FilterTypeKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("None" in obj) {
+    return new None()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.FilterTypeJSON): types.FilterTypeKind {
+  switch (obj.kind) {
+    case "None": {
+      return new None()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([borsh.struct([], "None")])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/GeneralStore.ts

@@ -0,0 +1,56 @@
+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: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.GeneralStoreKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("None" in obj) {
+    return new None()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.GeneralStoreJSON): types.GeneralStoreKind {
+  switch (obj.kind) {
+    case "None": {
+      return new None()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([borsh.struct([], "None")])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/GenericStore.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 GenericStoreFields {
+  storeType: number
+  data: types.GenericValueKind
+}
+
+export interface GenericStoreJSON {
+  storeType: number
+  data: types.GenericValueJSON
+}
+
+export class GenericStore {
+  readonly storeType: number
+  readonly data: types.GenericValueKind
+
+  constructor(fields: GenericStoreFields) {
+    this.storeType = fields.storeType
+    this.data = fields.data
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [borsh.u16("storeType"), types.GenericValue.layout("data")],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new GenericStore({
+      storeType: obj.storeType,
+      data: types.GenericValue.fromDecoded(obj.data),
+    })
+  }
+
+  static toEncodable(fields: GenericStoreFields) {
+    return {
+      storeType: fields.storeType,
+      data: fields.data.toEncodable(),
+    }
+  }
+
+  toJSON(): GenericStoreJSON {
+    return {
+      storeType: this.storeType,
+      data: this.data.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: GenericStoreJSON): GenericStore {
+    return new GenericStore({
+      storeType: obj.storeType,
+      data: types.GenericValue.fromJSON(obj.data),
+    })
+  }
+
+  toEncodable() {
+    return GenericStore.toEncodable(this)
+  }
+}

package/src/types/types/GenericValue.ts

@@ -0,0 +1,172 @@
+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 KeyFields = {
+  value: PublicKey
+}
+export type KeyValue = {
+  value: PublicKey
+}
+
+export interface KeyJSON {
+  kind: "Key"
+  value: {
+    value: string
+  }
+}
+
+export class Key {
+  static readonly discriminator = 1
+  static readonly kind = "Key"
+  readonly discriminator = 1
+  readonly kind = "Key"
+  readonly value: KeyValue
+
+  constructor(value: KeyFields) {
+    this.value = {
+      value: value.value,
+    }
+  }
+
+  toJSON(): KeyJSON {
+    return {
+      kind: "Key",
+      value: {
+        value: this.value.value.toString(),
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      Key: {
+        value: this.value.value,
+      },
+    }
+  }
+}
+
+export type EightBytesFields = {
+  value: BN
+}
+export type EightBytesValue = {
+  value: BN
+}
+
+export interface EightBytesJSON {
+  kind: "EightBytes"
+  value: {
+    value: string
+  }
+}
+
+export class EightBytes {
+  static readonly discriminator = 2
+  static readonly kind = "EightBytes"
+  readonly discriminator = 2
+  readonly kind = "EightBytes"
+  readonly value: EightBytesValue
+
+  constructor(value: EightBytesFields) {
+    this.value = {
+      value: value.value,
+    }
+  }
+
+  toJSON(): EightBytesJSON {
+    return {
+      kind: "EightBytes",
+      value: {
+        value: this.value.value.toString(),
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      EightBytes: {
+        value: this.value.value,
+      },
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.GenericValueKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("None" in obj) {
+    return new None()
+  }
+  if ("Key" in obj) {
+    const val = obj["Key"]
+    return new Key({
+      value: val["value"],
+    })
+  }
+  if ("EightBytes" in obj) {
+    const val = obj["EightBytes"]
+    return new EightBytes({
+      value: val["value"],
+    })
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.GenericValueJSON): types.GenericValueKind {
+  switch (obj.kind) {
+    case "None": {
+      return new None()
+    }
+    case "Key": {
+      return new Key({
+        value: new PublicKey(obj.value.value),
+      })
+    }
+    case "EightBytes": {
+      return new EightBytes({
+        value: new BN(obj.value.value),
+      })
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "None"),
+    borsh.struct([borsh.publicKey("value")], "Key"),
+    borsh.struct([borsh.u64("value")], "EightBytes"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/GlobalFee.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 interface GlobalFeeFields {
+  delegate: PublicKey
+  fee: BN
+  feePercentage: number
+  feeType: types.FeeTypeKind
+}
+
+export interface GlobalFeeJSON {
+  delegate: string
+  fee: string
+  feePercentage: number
+  feeType: types.FeeTypeJSON
+}
+
+export class GlobalFee {
+  readonly delegate: PublicKey
+  readonly fee: BN
+  readonly feePercentage: number
+  readonly feeType: types.FeeTypeKind
+
+  constructor(fields: GlobalFeeFields) {
+    this.delegate = fields.delegate
+    this.fee = fields.fee
+    this.feePercentage = fields.feePercentage
+    this.feeType = fields.feeType
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.publicKey("delegate"),
+        borsh.u64("fee"),
+        borsh.u16("feePercentage"),
+        types.FeeType.layout("feeType"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new GlobalFee({
+      delegate: obj.delegate,
+      fee: obj.fee,
+      feePercentage: obj.feePercentage,
+      feeType: types.FeeType.fromDecoded(obj.feeType),
+    })
+  }
+
+  static toEncodable(fields: GlobalFeeFields) {
+    return {
+      delegate: fields.delegate,
+      fee: fields.fee,
+      feePercentage: fields.feePercentage,
+      feeType: fields.feeType.toEncodable(),
+    }
+  }
+
+  toJSON(): GlobalFeeJSON {
+    return {
+      delegate: this.delegate.toString(),
+      fee: this.fee.toString(),
+      feePercentage: this.feePercentage,
+      feeType: this.feeType.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: GlobalFeeJSON): GlobalFee {
+    return new GlobalFee({
+      delegate: new PublicKey(obj.delegate),
+      fee: new BN(obj.fee),
+      feePercentage: obj.feePercentage,
+      feeType: types.FeeType.fromJSON(obj.feeType),
+    })
+  }
+
+  toEncodable() {
+    return GlobalFee.toEncodable(this)
+  }
+}

package/src/types/types/GlobalState.ts

@@ -0,0 +1,148 @@
+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 HiddenBySystemJSON {
+  kind: "HiddenBySystem"
+}
+
+export class HiddenBySystem {
+  static readonly discriminator = 0
+  static readonly kind = "HiddenBySystem"
+  readonly discriminator = 0
+  readonly kind = "HiddenBySystem"
+
+  toJSON(): HiddenBySystemJSON {
+    return {
+      kind: "HiddenBySystem",
+    }
+  }
+
+  toEncodable() {
+    return {
+      HiddenBySystem: {},
+    }
+  }
+}
+
+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: {},
+    }
+  }
+}
+
+export interface HiddenByUserJSON {
+  kind: "HiddenByUser"
+}
+
+export class HiddenByUser {
+  static readonly discriminator = 2
+  static readonly kind = "HiddenByUser"
+  readonly discriminator = 2
+  readonly kind = "HiddenByUser"
+
+  toJSON(): HiddenByUserJSON {
+    return {
+      kind: "HiddenByUser",
+    }
+  }
+
+  toEncodable() {
+    return {
+      HiddenByUser: {},
+    }
+  }
+}
+
+export interface FlaggedPirateJSON {
+  kind: "FlaggedPirate"
+}
+
+export class FlaggedPirate {
+  static readonly discriminator = 3
+  static readonly kind = "FlaggedPirate"
+  readonly discriminator = 3
+  readonly kind = "FlaggedPirate"
+
+  toJSON(): FlaggedPirateJSON {
+    return {
+      kind: "FlaggedPirate",
+    }
+  }
+
+  toEncodable() {
+    return {
+      FlaggedPirate: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.GlobalStateKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("HiddenBySystem" in obj) {
+    return new HiddenBySystem()
+  }
+  if ("Public" in obj) {
+    return new Public()
+  }
+  if ("HiddenByUser" in obj) {
+    return new HiddenByUser()
+  }
+  if ("FlaggedPirate" in obj) {
+    return new FlaggedPirate()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.GlobalStateJSON): types.GlobalStateKind {
+  switch (obj.kind) {
+    case "HiddenBySystem": {
+      return new HiddenBySystem()
+    }
+    case "Public": {
+      return new Public()
+    }
+    case "HiddenByUser": {
+      return new HiddenByUser()
+    }
+    case "FlaggedPirate": {
+      return new FlaggedPirate()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "HiddenBySystem"),
+    borsh.struct([], "Public"),
+    borsh.struct([], "HiddenByUser"),
+    borsh.struct([], "FlaggedPirate"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}