3land_sdk 1.0.0

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

package/src/types/types/DepositTrack.ts

@@ -0,0 +1,69 @@
+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 DepositTrackFields {
+  depositTrackType: types.DepositTrackTypeKind
+  depositState: types.DepositStateKind
+}
+
+export interface DepositTrackJSON {
+  depositTrackType: types.DepositTrackTypeJSON
+  depositState: types.DepositStateJSON
+}
+
+export class DepositTrack {
+  readonly depositTrackType: types.DepositTrackTypeKind
+  readonly depositState: types.DepositStateKind
+
+  constructor(fields: DepositTrackFields) {
+    this.depositTrackType = fields.depositTrackType
+    this.depositState = fields.depositState
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        types.DepositTrackType.layout("depositTrackType"),
+        types.DepositState.layout("depositState"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new DepositTrack({
+      depositTrackType: types.DepositTrackType.fromDecoded(
+        obj.depositTrackType
+      ),
+      depositState: types.DepositState.fromDecoded(obj.depositState),
+    })
+  }
+
+  static toEncodable(fields: DepositTrackFields) {
+    return {
+      depositTrackType: fields.depositTrackType.toEncodable(),
+      depositState: fields.depositState.toEncodable(),
+    }
+  }
+
+  toJSON(): DepositTrackJSON {
+    return {
+      depositTrackType: this.depositTrackType.toJSON(),
+      depositState: this.depositState.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: DepositTrackJSON): DepositTrack {
+    return new DepositTrack({
+      depositTrackType: types.DepositTrackType.fromJSON(obj.depositTrackType),
+      depositState: types.DepositState.fromJSON(obj.depositState),
+    })
+  }
+
+  toEncodable() {
+    return DepositTrack.toEncodable(this)
+  }
+}

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

package/src/types/types/DepositType.ts

@@ -0,0 +1,245 @@
+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 CreatorFields = {
+  creators: Array<types.CreatorFields>
+}
+export type CreatorValue = {
+  creators: Array<types.Creator>
+}
+
+export interface CreatorJSON {
+  kind: "Creator"
+  value: {
+    creators: Array<types.CreatorJSON>
+  }
+}
+
+export class Creator {
+  static readonly discriminator = 0
+  static readonly kind = "Creator"
+  readonly discriminator = 0
+  readonly kind = "Creator"
+  readonly value: CreatorValue
+
+  constructor(value: CreatorFields) {
+    this.value = {
+      creators: value.creators.map((item) => new types.Creator({ ...item })),
+    }
+  }
+
+  toJSON(): CreatorJSON {
+    return {
+      kind: "Creator",
+      value: {
+        creators: this.value.creators.map((item) => item.toJSON()),
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      Creator: {
+        creators: this.value.creators.map((item) =>
+          types.Creator.toEncodable(item)
+        ),
+      },
+    }
+  }
+}
+
+export type PdaCreatorFields = {
+  creators: Array<types.CreatorFields>
+  hasher: types.AccountHasherFields
+}
+export type PdaCreatorValue = {
+  creators: Array<types.Creator>
+  hasher: types.AccountHasher
+}
+
+export interface PdaCreatorJSON {
+  kind: "PdaCreator"
+  value: {
+    creators: Array<types.CreatorJSON>
+    hasher: types.AccountHasherJSON
+  }
+}
+
+export class PdaCreator {
+  static readonly discriminator = 1
+  static readonly kind = "PdaCreator"
+  readonly discriminator = 1
+  readonly kind = "PdaCreator"
+  readonly value: PdaCreatorValue
+
+  constructor(value: PdaCreatorFields) {
+    this.value = {
+      creators: value.creators.map((item) => new types.Creator({ ...item })),
+      hasher: new types.AccountHasher({ ...value.hasher }),
+    }
+  }
+
+  toJSON(): PdaCreatorJSON {
+    return {
+      kind: "PdaCreator",
+      value: {
+        creators: this.value.creators.map((item) => item.toJSON()),
+        hasher: this.value.hasher.toJSON(),
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      PdaCreator: {
+        creators: this.value.creators.map((item) =>
+          types.Creator.toEncodable(item)
+        ),
+        hasher: types.AccountHasher.toEncodable(this.value.hasher),
+      },
+    }
+  }
+}
+
+export type CollectionFields = {
+  metadata: types.VerifyCollectionMetadataFields
+  subtype: types.DepositSubtypeKind
+}
+export type CollectionValue = {
+  metadata: types.VerifyCollectionMetadata
+  subtype: types.DepositSubtypeKind
+}
+
+export interface CollectionJSON {
+  kind: "Collection"
+  value: {
+    metadata: types.VerifyCollectionMetadataJSON
+    subtype: types.DepositSubtypeJSON
+  }
+}
+
+export class Collection {
+  static readonly discriminator = 2
+  static readonly kind = "Collection"
+  readonly discriminator = 2
+  readonly kind = "Collection"
+  readonly value: CollectionValue
+
+  constructor(value: CollectionFields) {
+    this.value = {
+      metadata: new types.VerifyCollectionMetadata({ ...value.metadata }),
+      subtype: value.subtype,
+    }
+  }
+
+  toJSON(): CollectionJSON {
+    return {
+      kind: "Collection",
+      value: {
+        metadata: this.value.metadata.toJSON(),
+        subtype: this.value.subtype.toJSON(),
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      Collection: {
+        metadata: types.VerifyCollectionMetadata.toEncodable(
+          this.value.metadata
+        ),
+        subtype: this.value.subtype.toEncodable(),
+      },
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.DepositTypeKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("Creator" in obj) {
+    const val = obj["Creator"]
+    return new Creator({
+      creators: val["creators"].map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.Creator.fromDecoded(item)
+      ),
+    })
+  }
+  if ("PdaCreator" in obj) {
+    const val = obj["PdaCreator"]
+    return new PdaCreator({
+      creators: val["creators"].map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.Creator.fromDecoded(item)
+      ),
+      hasher: types.AccountHasher.fromDecoded(val["hasher"]),
+    })
+  }
+  if ("Collection" in obj) {
+    const val = obj["Collection"]
+    return new Collection({
+      metadata: types.VerifyCollectionMetadata.fromDecoded(val["metadata"]),
+      subtype: types.DepositSubtype.fromDecoded(val["subtype"]),
+    })
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.DepositTypeJSON): types.DepositTypeKind {
+  switch (obj.kind) {
+    case "Creator": {
+      return new Creator({
+        creators: obj.value.creators.map((item) =>
+          types.Creator.fromJSON(item)
+        ),
+      })
+    }
+    case "PdaCreator": {
+      return new PdaCreator({
+        creators: obj.value.creators.map((item) =>
+          types.Creator.fromJSON(item)
+        ),
+        hasher: types.AccountHasher.fromJSON(obj.value.hasher),
+      })
+    }
+    case "Collection": {
+      return new Collection({
+        metadata: types.VerifyCollectionMetadata.fromJSON(obj.value.metadata),
+        subtype: types.DepositSubtype.fromJSON(obj.value.subtype),
+      })
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([borsh.vec(types.Creator.layout(), "creators")], "Creator"),
+    borsh.struct(
+      [
+        borsh.vec(types.Creator.layout(), "creators"),
+        types.AccountHasher.layout("hasher"),
+      ],
+      "PdaCreator"
+    ),
+    borsh.struct(
+      [
+        types.VerifyCollectionMetadata.layout("metadata"),
+        types.DepositSubtype.layout("subtype"),
+      ],
+      "Collection"
+    ),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/Earnings.ts

@@ -0,0 +1,37 @@
+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 EarningsFields {}
+
+export interface EarningsJSON {}
+
+export class Earnings {
+  constructor(fields: EarningsFields) {}
+
+  static layout(property?: string) {
+    return borsh.struct([], property)
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new Earnings({})
+  }
+
+  static toEncodable(fields: EarningsFields) {
+    return {}
+  }
+
+  toJSON(): EarningsJSON {
+    return {}
+  }
+
+  static fromJSON(obj: EarningsJSON): Earnings {
+    return new Earnings({})
+  }
+
+  toEncodable() {
+    return Earnings.toEncodable(this)
+  }
+}

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