3land_sdk 1.0.0

package/src/types/types/TrackRegistry.ts

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

package/src/types/types/TraitInit.ts

@@ -0,0 +1,210 @@
+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 SemiFungibleFields = {
+  hash: BN
+}
+export type SemiFungibleValue = {
+  hash: BN
+}
+
+export interface SemiFungibleJSON {
+  kind: "SemiFungible"
+  value: {
+    hash: string
+  }
+}
+
+export class SemiFungible {
+  static readonly discriminator = 0
+  static readonly kind = "SemiFungible"
+  readonly discriminator = 0
+  readonly kind = "SemiFungible"
+  readonly value: SemiFungibleValue
+
+  constructor(value: SemiFungibleFields) {
+    this.value = {
+      hash: value.hash,
+    }
+  }
+
+  toJSON(): SemiFungibleJSON {
+    return {
+      kind: "SemiFungible",
+      value: {
+        hash: this.value.hash.toString(),
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      SemiFungible: {
+        hash: this.value.hash,
+      },
+    }
+  }
+}
+
+export type DateFields = {
+  hash: BN
+}
+export type DateValue = {
+  hash: BN
+}
+
+export interface DateJSON {
+  kind: "Date"
+  value: {
+    hash: string
+  }
+}
+
+export class Date {
+  static readonly discriminator = 1
+  static readonly kind = "Date"
+  readonly discriminator = 1
+  readonly kind = "Date"
+  readonly value: DateValue
+
+  constructor(value: DateFields) {
+    this.value = {
+      hash: value.hash,
+    }
+  }
+
+  toJSON(): DateJSON {
+    return {
+      kind: "Date",
+      value: {
+        hash: this.value.hash.toString(),
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      Date: {
+        hash: this.value.hash,
+      },
+    }
+  }
+}
+
+export type NonFungibleFields = {
+  hash: BN
+  values: Array<BN>
+}
+export type NonFungibleValue = {
+  hash: BN
+  values: Array<BN>
+}
+
+export interface NonFungibleJSON {
+  kind: "NonFungible"
+  value: {
+    hash: string
+    values: Array<string>
+  }
+}
+
+export class NonFungible {
+  static readonly discriminator = 2
+  static readonly kind = "NonFungible"
+  readonly discriminator = 2
+  readonly kind = "NonFungible"
+  readonly value: NonFungibleValue
+
+  constructor(value: NonFungibleFields) {
+    this.value = {
+      hash: value.hash,
+      values: value.values,
+    }
+  }
+
+  toJSON(): NonFungibleJSON {
+    return {
+      kind: "NonFungible",
+      value: {
+        hash: this.value.hash.toString(),
+        values: this.value.values.map((item) => item.toString()),
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      NonFungible: {
+        hash: this.value.hash,
+        values: this.value.values,
+      },
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.TraitInitKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("SemiFungible" in obj) {
+    const val = obj["SemiFungible"]
+    return new SemiFungible({
+      hash: val["hash"],
+    })
+  }
+  if ("Date" in obj) {
+    const val = obj["Date"]
+    return new Date({
+      hash: val["hash"],
+    })
+  }
+  if ("NonFungible" in obj) {
+    const val = obj["NonFungible"]
+    return new NonFungible({
+      hash: val["hash"],
+      values: val["values"],
+    })
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.TraitInitJSON): types.TraitInitKind {
+  switch (obj.kind) {
+    case "SemiFungible": {
+      return new SemiFungible({
+        hash: new BN(obj.value.hash),
+      })
+    }
+    case "Date": {
+      return new Date({
+        hash: new BN(obj.value.hash),
+      })
+    }
+    case "NonFungible": {
+      return new NonFungible({
+        hash: new BN(obj.value.hash),
+        values: obj.value.values.map((item) => new BN(item)),
+      })
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([borsh.u64("hash")], "SemiFungible"),
+    borsh.struct([borsh.u64("hash")], "Date"),
+    borsh.struct(
+      [borsh.u64("hash"), borsh.vec(borsh.u64(), "values")],
+      "NonFungible"
+    ),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/TraitPass.ts

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

package/src/types/types/TraitPassType.ts

@@ -0,0 +1,225 @@
+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 SemiFungibleFields = {
+  typeId: number
+  amount: BN
+}
+export type SemiFungibleValue = {
+  typeId: number
+  amount: BN
+}
+
+export interface SemiFungibleJSON {
+  kind: "SemiFungible"
+  value: {
+    typeId: number
+    amount: string
+  }
+}
+
+export class SemiFungible {
+  static readonly discriminator = 0
+  static readonly kind = "SemiFungible"
+  readonly discriminator = 0
+  readonly kind = "SemiFungible"
+  readonly value: SemiFungibleValue
+
+  constructor(value: SemiFungibleFields) {
+    this.value = {
+      typeId: value.typeId,
+      amount: value.amount,
+    }
+  }
+
+  toJSON(): SemiFungibleJSON {
+    return {
+      kind: "SemiFungible",
+      value: {
+        typeId: this.value.typeId,
+        amount: this.value.amount.toString(),
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      SemiFungible: {
+        typeId: this.value.typeId,
+        amount: this.value.amount,
+      },
+    }
+  }
+}
+
+export type DateFields = {
+  typeId: number
+  date: number
+}
+export type DateValue = {
+  typeId: number
+  date: number
+}
+
+export interface DateJSON {
+  kind: "Date"
+  value: {
+    typeId: number
+    date: number
+  }
+}
+
+export class Date {
+  static readonly discriminator = 1
+  static readonly kind = "Date"
+  readonly discriminator = 1
+  readonly kind = "Date"
+  readonly value: DateValue
+
+  constructor(value: DateFields) {
+    this.value = {
+      typeId: value.typeId,
+      date: value.date,
+    }
+  }
+
+  toJSON(): DateJSON {
+    return {
+      kind: "Date",
+      value: {
+        typeId: this.value.typeId,
+        date: this.value.date,
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      Date: {
+        typeId: this.value.typeId,
+        date: this.value.date,
+      },
+    }
+  }
+}
+
+export type NonFungibleFields = {
+  typeId: number
+  valueId: number
+}
+export type NonFungibleValue = {
+  typeId: number
+  valueId: number
+}
+
+export interface NonFungibleJSON {
+  kind: "NonFungible"
+  value: {
+    typeId: number
+    valueId: number
+  }
+}
+
+export class NonFungible {
+  static readonly discriminator = 2
+  static readonly kind = "NonFungible"
+  readonly discriminator = 2
+  readonly kind = "NonFungible"
+  readonly value: NonFungibleValue
+
+  constructor(value: NonFungibleFields) {
+    this.value = {
+      typeId: value.typeId,
+      valueId: value.valueId,
+    }
+  }
+
+  toJSON(): NonFungibleJSON {
+    return {
+      kind: "NonFungible",
+      value: {
+        typeId: this.value.typeId,
+        valueId: this.value.valueId,
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      NonFungible: {
+        typeId: this.value.typeId,
+        valueId: this.value.valueId,
+      },
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.TraitPassTypeKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("SemiFungible" in obj) {
+    const val = obj["SemiFungible"]
+    return new SemiFungible({
+      typeId: val["typeId"],
+      amount: val["amount"],
+    })
+  }
+  if ("Date" in obj) {
+    const val = obj["Date"]
+    return new Date({
+      typeId: val["typeId"],
+      date: val["date"],
+    })
+  }
+  if ("NonFungible" in obj) {
+    const val = obj["NonFungible"]
+    return new NonFungible({
+      typeId: val["typeId"],
+      valueId: val["valueId"],
+    })
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(
+  obj: types.TraitPassTypeJSON
+): types.TraitPassTypeKind {
+  switch (obj.kind) {
+    case "SemiFungible": {
+      return new SemiFungible({
+        typeId: obj.value.typeId,
+        amount: new BN(obj.value.amount),
+      })
+    }
+    case "Date": {
+      return new Date({
+        typeId: obj.value.typeId,
+        date: obj.value.date,
+      })
+    }
+    case "NonFungible": {
+      return new NonFungible({
+        typeId: obj.value.typeId,
+        valueId: obj.value.valueId,
+      })
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([borsh.u16("typeId"), borsh.u64("amount")], "SemiFungible"),
+    borsh.struct([borsh.u16("typeId"), borsh.u32("date")], "Date"),
+    borsh.struct([borsh.u16("typeId"), borsh.u16("valueId")], "NonFungible"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}