3land_sdk 1.0.0

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

package/src/types/types/Uses.ts

@@ -0,0 +1,76 @@
+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 UsesFields {
+  useMethod: types.UseMethodKind
+  remaining: BN
+  total: BN
+}
+
+export interface UsesJSON {
+  useMethod: types.UseMethodJSON
+  remaining: string
+  total: string
+}
+
+export class Uses {
+  readonly useMethod: types.UseMethodKind
+  readonly remaining: BN
+  readonly total: BN
+
+  constructor(fields: UsesFields) {
+    this.useMethod = fields.useMethod
+    this.remaining = fields.remaining
+    this.total = fields.total
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        types.UseMethod.layout("useMethod"),
+        borsh.u64("remaining"),
+        borsh.u64("total"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new Uses({
+      useMethod: types.UseMethod.fromDecoded(obj.useMethod),
+      remaining: obj.remaining,
+      total: obj.total,
+    })
+  }
+
+  static toEncodable(fields: UsesFields) {
+    return {
+      useMethod: fields.useMethod.toEncodable(),
+      remaining: fields.remaining,
+      total: fields.total,
+    }
+  }
+
+  toJSON(): UsesJSON {
+    return {
+      useMethod: this.useMethod.toJSON(),
+      remaining: this.remaining.toString(),
+      total: this.total.toString(),
+    }
+  }
+
+  static fromJSON(obj: UsesJSON): Uses {
+    return new Uses({
+      useMethod: types.UseMethod.fromJSON(obj.useMethod),
+      remaining: new BN(obj.remaining),
+      total: new BN(obj.total),
+    })
+  }
+
+  toEncodable() {
+    return Uses.toEncodable(this)
+  }
+}

package/src/types/types/VerifyCollectionMetadata.ts

@@ -0,0 +1,109 @@
+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 VerifyCollectionMetadataFields {
+  name: string
+  symbol: string
+  uri: string
+  royalty: number
+  collection: number
+  creators: Array<types.CreatorFields>
+}
+
+export interface VerifyCollectionMetadataJSON {
+  name: string
+  symbol: string
+  uri: string
+  royalty: number
+  collection: number
+  creators: Array<types.CreatorJSON>
+}
+
+export class VerifyCollectionMetadata {
+  readonly name: string
+  readonly symbol: string
+  readonly uri: string
+  readonly royalty: number
+  readonly collection: number
+  readonly creators: Array<types.Creator>
+
+  constructor(fields: VerifyCollectionMetadataFields) {
+    this.name = fields.name
+    this.symbol = fields.symbol
+    this.uri = fields.uri
+    this.royalty = fields.royalty
+    this.collection = fields.collection
+    this.creators = fields.creators.map(
+      (item) => new types.Creator({ ...item })
+    )
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.str("name"),
+        borsh.str("symbol"),
+        borsh.str("uri"),
+        borsh.u16("royalty"),
+        borsh.u8("collection"),
+        borsh.vec(types.Creator.layout(), "creators"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new VerifyCollectionMetadata({
+      name: obj.name,
+      symbol: obj.symbol,
+      uri: obj.uri,
+      royalty: obj.royalty,
+      collection: obj.collection,
+      creators: obj.creators.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.Creator.fromDecoded(item)
+      ),
+    })
+  }
+
+  static toEncodable(fields: VerifyCollectionMetadataFields) {
+    return {
+      name: fields.name,
+      symbol: fields.symbol,
+      uri: fields.uri,
+      royalty: fields.royalty,
+      collection: fields.collection,
+      creators: fields.creators.map((item) => types.Creator.toEncodable(item)),
+    }
+  }
+
+  toJSON(): VerifyCollectionMetadataJSON {
+    return {
+      name: this.name,
+      symbol: this.symbol,
+      uri: this.uri,
+      royalty: this.royalty,
+      collection: this.collection,
+      creators: this.creators.map((item) => item.toJSON()),
+    }
+  }
+
+  static fromJSON(obj: VerifyCollectionMetadataJSON): VerifyCollectionMetadata {
+    return new VerifyCollectionMetadata({
+      name: obj.name,
+      symbol: obj.symbol,
+      uri: obj.uri,
+      royalty: obj.royalty,
+      collection: obj.collection,
+      creators: obj.creators.map((item) => types.Creator.fromJSON(item)),
+    })
+  }
+
+  toEncodable() {
+    return VerifyCollectionMetadata.toEncodable(this)
+  }
+}

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

package/src/types/types/WrappedSource.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 WrappedSourceFields {
+  pool: PublicKey
+  amount: BN
+  distribution: number
+  track: number
+}
+
+export interface WrappedSourceJSON {
+  pool: string
+  amount: string
+  distribution: number
+  track: number
+}
+
+export class WrappedSource {
+  readonly pool: PublicKey
+  readonly amount: BN
+  readonly distribution: number
+  readonly track: number
+
+  constructor(fields: WrappedSourceFields) {
+    this.pool = fields.pool
+    this.amount = fields.amount
+    this.distribution = fields.distribution
+    this.track = fields.track
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.publicKey("pool"),
+        borsh.u64("amount"),
+        borsh.u16("distribution"),
+        borsh.u8("track"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new WrappedSource({
+      pool: obj.pool,
+      amount: obj.amount,
+      distribution: obj.distribution,
+      track: obj.track,
+    })
+  }
+
+  static toEncodable(fields: WrappedSourceFields) {
+    return {
+      pool: fields.pool,
+      amount: fields.amount,
+      distribution: fields.distribution,
+      track: fields.track,
+    }
+  }
+
+  toJSON(): WrappedSourceJSON {
+    return {
+      pool: this.pool.toString(),
+      amount: this.amount.toString(),
+      distribution: this.distribution,
+      track: this.track,
+    }
+  }
+
+  static fromJSON(obj: WrappedSourceJSON): WrappedSource {
+    return new WrappedSource({
+      pool: new PublicKey(obj.pool),
+      amount: new BN(obj.amount),
+      distribution: obj.distribution,
+      track: obj.track,
+    })
+  }
+
+  toEncodable() {
+    return WrappedSource.toEncodable(this)
+  }
+}

package/src/types/types/ZeroConfig.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 ZeroConfigFields {
+  bytes: number
+  chunks: Array<number>
+  chunkSize: number
+  supplyChunkBytes: number
+}
+
+export interface ZeroConfigJSON {
+  bytes: number
+  chunks: Array<number>
+  chunkSize: number
+  supplyChunkBytes: number
+}
+
+export class ZeroConfig {
+  readonly bytes: number
+  readonly chunks: Array<number>
+  readonly chunkSize: number
+  readonly supplyChunkBytes: number
+
+  constructor(fields: ZeroConfigFields) {
+    this.bytes = fields.bytes
+    this.chunks = fields.chunks
+    this.chunkSize = fields.chunkSize
+    this.supplyChunkBytes = fields.supplyChunkBytes
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.u8("bytes"),
+        borsh.array(borsh.u8(), 2, "chunks"),
+        borsh.u8("chunkSize"),
+        borsh.u8("supplyChunkBytes"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new ZeroConfig({
+      bytes: obj.bytes,
+      chunks: obj.chunks,
+      chunkSize: obj.chunkSize,
+      supplyChunkBytes: obj.supplyChunkBytes,
+    })
+  }
+
+  static toEncodable(fields: ZeroConfigFields) {
+    return {
+      bytes: fields.bytes,
+      chunks: fields.chunks,
+      chunkSize: fields.chunkSize,
+      supplyChunkBytes: fields.supplyChunkBytes,
+    }
+  }
+
+  toJSON(): ZeroConfigJSON {
+    return {
+      bytes: this.bytes,
+      chunks: this.chunks,
+      chunkSize: this.chunkSize,
+      supplyChunkBytes: this.supplyChunkBytes,
+    }
+  }
+
+  static fromJSON(obj: ZeroConfigJSON): ZeroConfig {
+    return new ZeroConfig({
+      bytes: obj.bytes,
+      chunks: obj.chunks,
+      chunkSize: obj.chunkSize,
+      supplyChunkBytes: obj.supplyChunkBytes,
+    })
+  }
+
+  toEncodable() {
+    return ZeroConfig.toEncodable(this)
+  }
+}