3land_sdk 1.0.0

package/src/types/types/AccountHasher.ts

@@ -0,0 +1,89 @@
+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 AccountHasherFields {
+  seeds: Array<types.SeedFields>
+  insertAt: number
+  program: PublicKey
+  bump: number
+}
+
+export interface AccountHasherJSON {
+  seeds: Array<types.SeedJSON>
+  insertAt: number
+  program: string
+  bump: number
+}
+
+export class AccountHasher {
+  readonly seeds: Array<types.Seed>
+  readonly insertAt: number
+  readonly program: PublicKey
+  readonly bump: number
+
+  constructor(fields: AccountHasherFields) {
+    this.seeds = fields.seeds.map((item) => new types.Seed({ ...item }))
+    this.insertAt = fields.insertAt
+    this.program = fields.program
+    this.bump = fields.bump
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.vec(types.Seed.layout(), "seeds"),
+        borsh.u8("insertAt"),
+        borsh.publicKey("program"),
+        borsh.u8("bump"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new AccountHasher({
+      seeds: obj.seeds.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.Seed.fromDecoded(item)
+      ),
+      insertAt: obj.insertAt,
+      program: obj.program,
+      bump: obj.bump,
+    })
+  }
+
+  static toEncodable(fields: AccountHasherFields) {
+    return {
+      seeds: fields.seeds.map((item) => types.Seed.toEncodable(item)),
+      insertAt: fields.insertAt,
+      program: fields.program,
+      bump: fields.bump,
+    }
+  }
+
+  toJSON(): AccountHasherJSON {
+    return {
+      seeds: this.seeds.map((item) => item.toJSON()),
+      insertAt: this.insertAt,
+      program: this.program.toString(),
+      bump: this.bump,
+    }
+  }
+
+  static fromJSON(obj: AccountHasherJSON): AccountHasher {
+    return new AccountHasher({
+      seeds: obj.seeds.map((item) => types.Seed.fromJSON(item)),
+      insertAt: obj.insertAt,
+      program: new PublicKey(obj.program),
+      bump: obj.bump,
+    })
+  }
+
+  toEncodable() {
+    return AccountHasher.toEncodable(this)
+  }
+}

package/src/types/types/ActionAfter.ts

@@ -0,0 +1,202 @@
+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 MintingOutJSON {
+  kind: "MintingOut"
+}
+
+export class MintingOut {
+  static readonly discriminator = 0
+  static readonly kind = "MintingOut"
+  readonly discriminator = 0
+  readonly kind = "MintingOut"
+
+  toJSON(): MintingOutJSON {
+    return {
+      kind: "MintingOut",
+    }
+  }
+
+  toEncodable() {
+    return {
+      MintingOut: {},
+    }
+  }
+}
+
+export type SupplyFields = {
+  limit: number
+}
+export type SupplyValue = {
+  limit: number
+}
+
+export interface SupplyJSON {
+  kind: "Supply"
+  value: {
+    limit: number
+  }
+}
+
+export class Supply {
+  static readonly discriminator = 1
+  static readonly kind = "Supply"
+  readonly discriminator = 1
+  readonly kind = "Supply"
+  readonly value: SupplyValue
+
+  constructor(value: SupplyFields) {
+    this.value = {
+      limit: value.limit,
+    }
+  }
+
+  toJSON(): SupplyJSON {
+    return {
+      kind: "Supply",
+      value: {
+        limit: this.value.limit,
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      Supply: {
+        limit: this.value.limit,
+      },
+    }
+  }
+}
+
+export type HoursFields = {
+  hours: number
+}
+export type HoursValue = {
+  hours: number
+}
+
+export interface HoursJSON {
+  kind: "Hours"
+  value: {
+    hours: number
+  }
+}
+
+export class Hours {
+  static readonly discriminator = 2
+  static readonly kind = "Hours"
+  readonly discriminator = 2
+  readonly kind = "Hours"
+  readonly value: HoursValue
+
+  constructor(value: HoursFields) {
+    this.value = {
+      hours: value.hours,
+    }
+  }
+
+  toJSON(): HoursJSON {
+    return {
+      kind: "Hours",
+      value: {
+        hours: this.value.hours,
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      Hours: {
+        hours: this.value.hours,
+      },
+    }
+  }
+}
+
+export interface SellingOutJSON {
+  kind: "SellingOut"
+}
+
+export class SellingOut {
+  static readonly discriminator = 3
+  static readonly kind = "SellingOut"
+  readonly discriminator = 3
+  readonly kind = "SellingOut"
+
+  toJSON(): SellingOutJSON {
+    return {
+      kind: "SellingOut",
+    }
+  }
+
+  toEncodable() {
+    return {
+      SellingOut: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.ActionAfterKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("MintingOut" in obj) {
+    return new MintingOut()
+  }
+  if ("Supply" in obj) {
+    const val = obj["Supply"]
+    return new Supply({
+      limit: val["limit"],
+    })
+  }
+  if ("Hours" in obj) {
+    const val = obj["Hours"]
+    return new Hours({
+      hours: val["hours"],
+    })
+  }
+  if ("SellingOut" in obj) {
+    return new SellingOut()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.ActionAfterJSON): types.ActionAfterKind {
+  switch (obj.kind) {
+    case "MintingOut": {
+      return new MintingOut()
+    }
+    case "Supply": {
+      return new Supply({
+        limit: obj.value.limit,
+      })
+    }
+    case "Hours": {
+      return new Hours({
+        hours: obj.value.hours,
+      })
+    }
+    case "SellingOut": {
+      return new SellingOut()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "MintingOut"),
+    borsh.struct([borsh.u32("limit")], "Supply"),
+    borsh.struct([borsh.u16("hours")], "Hours"),
+    borsh.struct([], "SellingOut"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/AllowedCurrencyArgs.ts

@@ -0,0 +1,53 @@
+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 AllowedCurrencyArgsFields {
+  id: number
+}
+
+export interface AllowedCurrencyArgsJSON {
+  id: number
+}
+
+export class AllowedCurrencyArgs {
+  readonly id: number
+
+  constructor(fields: AllowedCurrencyArgsFields) {
+    this.id = fields.id
+  }
+
+  static layout(property?: string) {
+    return borsh.struct([borsh.u16("id")], property)
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new AllowedCurrencyArgs({
+      id: obj.id,
+    })
+  }
+
+  static toEncodable(fields: AllowedCurrencyArgsFields) {
+    return {
+      id: fields.id,
+    }
+  }
+
+  toJSON(): AllowedCurrencyArgsJSON {
+    return {
+      id: this.id,
+    }
+  }
+
+  static fromJSON(obj: AllowedCurrencyArgsJSON): AllowedCurrencyArgs {
+    return new AllowedCurrencyArgs({
+      id: obj.id,
+    })
+  }
+
+  toEncodable() {
+    return AllowedCurrencyArgs.toEncodable(this)
+  }
+}

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

package/src/types/types/BurnCount.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 BurnCountFields {
+  list: Array<types.FakeBurnCountFields>
+}
+
+export interface BurnCountJSON {
+  list: Array<types.FakeBurnCountJSON>
+}
+
+export class BurnCount {
+  readonly list: Array<types.FakeBurnCount>
+
+  constructor(fields: BurnCountFields) {
+    this.list = fields.list.map((item) => new types.FakeBurnCount({ ...item }))
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [borsh.vec(types.FakeBurnCount.layout(), "list")],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new BurnCount({
+      list: obj.list.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.FakeBurnCount.fromDecoded(item)
+      ),
+    })
+  }
+
+  static toEncodable(fields: BurnCountFields) {
+    return {
+      list: fields.list.map((item) => types.FakeBurnCount.toEncodable(item)),
+    }
+  }
+
+  toJSON(): BurnCountJSON {
+    return {
+      list: this.list.map((item) => item.toJSON()),
+    }
+  }
+
+  static fromJSON(obj: BurnCountJSON): BurnCount {
+    return new BurnCount({
+      list: obj.list.map((item) => types.FakeBurnCount.fromJSON(item)),
+    })
+  }
+
+  toEncodable() {
+    return BurnCount.toEncodable(this)
+  }
+}

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

package/src/types/types/BurnTrack.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 BurnTrackFields {
+  amount: number
+  burnType: types.BurnTypeBurnKind
+}
+
+export interface BurnTrackJSON {
+  amount: number
+  burnType: types.BurnTypeBurnJSON
+}
+
+export class BurnTrack {
+  readonly amount: number
+  readonly burnType: types.BurnTypeBurnKind
+
+  constructor(fields: BurnTrackFields) {
+    this.amount = fields.amount
+    this.burnType = fields.burnType
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [borsh.u16("amount"), types.BurnTypeBurn.layout("burnType")],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new BurnTrack({
+      amount: obj.amount,
+      burnType: types.BurnTypeBurn.fromDecoded(obj.burnType),
+    })
+  }
+
+  static toEncodable(fields: BurnTrackFields) {
+    return {
+      amount: fields.amount,
+      burnType: fields.burnType.toEncodable(),
+    }
+  }
+
+  toJSON(): BurnTrackJSON {
+    return {
+      amount: this.amount,
+      burnType: this.burnType.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: BurnTrackJSON): BurnTrack {
+    return new BurnTrack({
+      amount: obj.amount,
+      burnType: types.BurnTypeBurn.fromJSON(obj.burnType),
+    })
+  }
+
+  toEncodable() {
+    return BurnTrack.toEncodable(this)
+  }
+}