3land_sdk 1.0.0

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

package/src/types/types/PriceRule.ts

@@ -0,0 +1,216 @@
+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 AndJSON {
+  kind: "And"
+}
+
+export class And {
+  static readonly discriminator = 1
+  static readonly kind = "And"
+  readonly discriminator = 1
+  readonly kind = "And"
+
+  toJSON(): AndJSON {
+    return {
+      kind: "And",
+    }
+  }
+
+  toEncodable() {
+    return {
+      And: {},
+    }
+  }
+}
+
+export interface OrJSON {
+  kind: "Or"
+}
+
+export class Or {
+  static readonly discriminator = 2
+  static readonly kind = "Or"
+  readonly discriminator = 2
+  readonly kind = "Or"
+
+  toJSON(): OrJSON {
+    return {
+      kind: "Or",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Or: {},
+    }
+  }
+}
+
+export type BondingLinearFields = {
+  initial: BN
+  rate: BN
+  index: number
+  max: number
+  min: number
+}
+export type BondingLinearValue = {
+  initial: BN
+  rate: BN
+  index: number
+  max: number
+  min: number
+}
+
+export interface BondingLinearJSON {
+  kind: "BondingLinear"
+  value: {
+    initial: string
+    rate: string
+    index: number
+    max: number
+    min: number
+  }
+}
+
+export class BondingLinear {
+  static readonly discriminator = 3
+  static readonly kind = "BondingLinear"
+  readonly discriminator = 3
+  readonly kind = "BondingLinear"
+  readonly value: BondingLinearValue
+
+  constructor(value: BondingLinearFields) {
+    this.value = {
+      initial: value.initial,
+      rate: value.rate,
+      index: value.index,
+      max: value.max,
+      min: value.min,
+    }
+  }
+
+  toJSON(): BondingLinearJSON {
+    return {
+      kind: "BondingLinear",
+      value: {
+        initial: this.value.initial.toString(),
+        rate: this.value.rate.toString(),
+        index: this.value.index,
+        max: this.value.max,
+        min: this.value.min,
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      BondingLinear: {
+        initial: this.value.initial,
+        rate: this.value.rate,
+        index: this.value.index,
+        max: this.value.max,
+        min: this.value.min,
+      },
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.PriceRuleKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("None" in obj) {
+    return new None()
+  }
+  if ("And" in obj) {
+    return new And()
+  }
+  if ("Or" in obj) {
+    return new Or()
+  }
+  if ("BondingLinear" in obj) {
+    const val = obj["BondingLinear"]
+    return new BondingLinear({
+      initial: val["initial"],
+      rate: val["rate"],
+      index: val["index"],
+      max: val["max"],
+      min: val["min"],
+    })
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.PriceRuleJSON): types.PriceRuleKind {
+  switch (obj.kind) {
+    case "None": {
+      return new None()
+    }
+    case "And": {
+      return new And()
+    }
+    case "Or": {
+      return new Or()
+    }
+    case "BondingLinear": {
+      return new BondingLinear({
+        initial: new BN(obj.value.initial),
+        rate: new BN(obj.value.rate),
+        index: obj.value.index,
+        max: obj.value.max,
+        min: obj.value.min,
+      })
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "None"),
+    borsh.struct([], "And"),
+    borsh.struct([], "Or"),
+    borsh.struct(
+      [
+        borsh.u64("initial"),
+        borsh.u64("rate"),
+        borsh.u8("index"),
+        borsh.u32("max"),
+        borsh.u16("min"),
+      ],
+      "BondingLinear"
+    ),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/RecoverDeposit.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 RecoverDepositFields {
+  cnft: types.CnftDataFields | null
+}
+
+export interface RecoverDepositJSON {
+  cnft: types.CnftDataJSON | null
+}
+
+export class RecoverDeposit {
+  readonly cnft: types.CnftData | null
+
+  constructor(fields: RecoverDepositFields) {
+    this.cnft = (fields.cnft && new types.CnftData({ ...fields.cnft })) || null
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [borsh.option(types.CnftData.layout(), "cnft")],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new RecoverDeposit({
+      cnft: (obj.cnft && types.CnftData.fromDecoded(obj.cnft)) || null,
+    })
+  }
+
+  static toEncodable(fields: RecoverDepositFields) {
+    return {
+      cnft: (fields.cnft && types.CnftData.toEncodable(fields.cnft)) || null,
+    }
+  }
+
+  toJSON(): RecoverDepositJSON {
+    return {
+      cnft: (this.cnft && this.cnft.toJSON()) || null,
+    }
+  }
+
+  static fromJSON(obj: RecoverDepositJSON): RecoverDeposit {
+    return new RecoverDeposit({
+      cnft: (obj.cnft && types.CnftData.fromJSON(obj.cnft)) || null,
+    })
+  }
+
+  toEncodable() {
+    return RecoverDeposit.toEncodable(this)
+  }
+}

package/src/types/types/Rule.ts

@@ -0,0 +1,199 @@
+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 UnlocksAfterFields = {
+  rule: types.ActionAfterKind
+}
+export type UnlocksAfterValue = {
+  rule: types.ActionAfterKind
+}
+
+export interface UnlocksAfterJSON {
+  kind: "UnlocksAfter"
+  value: {
+    rule: types.ActionAfterJSON
+  }
+}
+
+export class UnlocksAfter {
+  static readonly discriminator = 0
+  static readonly kind = "UnlocksAfter"
+  readonly discriminator = 0
+  readonly kind = "UnlocksAfter"
+  readonly value: UnlocksAfterValue
+
+  constructor(value: UnlocksAfterFields) {
+    this.value = {
+      rule: value.rule,
+    }
+  }
+
+  toJSON(): UnlocksAfterJSON {
+    return {
+      kind: "UnlocksAfter",
+      value: {
+        rule: this.value.rule.toJSON(),
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      UnlocksAfter: {
+        rule: this.value.rule.toEncodable(),
+      },
+    }
+  }
+}
+
+export type UnwrapsAfterFields = {
+  rule: types.ActionAfterKind
+}
+export type UnwrapsAfterValue = {
+  rule: types.ActionAfterKind
+}
+
+export interface UnwrapsAfterJSON {
+  kind: "UnwrapsAfter"
+  value: {
+    rule: types.ActionAfterJSON
+  }
+}
+
+export class UnwrapsAfter {
+  static readonly discriminator = 1
+  static readonly kind = "UnwrapsAfter"
+  readonly discriminator = 1
+  readonly kind = "UnwrapsAfter"
+  readonly value: UnwrapsAfterValue
+
+  constructor(value: UnwrapsAfterFields) {
+    this.value = {
+      rule: value.rule,
+    }
+  }
+
+  toJSON(): UnwrapsAfterJSON {
+    return {
+      kind: "UnwrapsAfter",
+      value: {
+        rule: this.value.rule.toJSON(),
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      UnwrapsAfter: {
+        rule: this.value.rule.toEncodable(),
+      },
+    }
+  }
+}
+
+export type WrappedSourceFields = {
+  rule: types.WrappedSourceFields
+}
+export type WrappedSourceValue = {
+  rule: types.WrappedSource
+}
+
+export interface WrappedSourceJSON {
+  kind: "WrappedSource"
+  value: {
+    rule: types.WrappedSourceJSON
+  }
+}
+
+export class WrappedSource {
+  static readonly discriminator = 2
+  static readonly kind = "WrappedSource"
+  readonly discriminator = 2
+  readonly kind = "WrappedSource"
+  readonly value: WrappedSourceValue
+
+  constructor(value: WrappedSourceFields) {
+    this.value = {
+      rule: new types.WrappedSource({ ...value.rule }),
+    }
+  }
+
+  toJSON(): WrappedSourceJSON {
+    return {
+      kind: "WrappedSource",
+      value: {
+        rule: this.value.rule.toJSON(),
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      WrappedSource: {
+        rule: types.WrappedSource.toEncodable(this.value.rule),
+      },
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.RuleKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("UnlocksAfter" in obj) {
+    const val = obj["UnlocksAfter"]
+    return new UnlocksAfter({
+      rule: types.ActionAfter.fromDecoded(val["rule"]),
+    })
+  }
+  if ("UnwrapsAfter" in obj) {
+    const val = obj["UnwrapsAfter"]
+    return new UnwrapsAfter({
+      rule: types.ActionAfter.fromDecoded(val["rule"]),
+    })
+  }
+  if ("WrappedSource" in obj) {
+    const val = obj["WrappedSource"]
+    return new WrappedSource({
+      rule: types.WrappedSource.fromDecoded(val["rule"]),
+    })
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.RuleJSON): types.RuleKind {
+  switch (obj.kind) {
+    case "UnlocksAfter": {
+      return new UnlocksAfter({
+        rule: types.ActionAfter.fromJSON(obj.value.rule),
+      })
+    }
+    case "UnwrapsAfter": {
+      return new UnwrapsAfter({
+        rule: types.ActionAfter.fromJSON(obj.value.rule),
+      })
+    }
+    case "WrappedSource": {
+      return new WrappedSource({
+        rule: types.WrappedSource.fromJSON(obj.value.rule),
+      })
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([types.ActionAfter.layout("rule")], "UnlocksAfter"),
+    borsh.struct([types.ActionAfter.layout("rule")], "UnwrapsAfter"),
+    borsh.struct([types.WrappedSource.layout("rule")], "WrappedSource"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/SaleConfig.ts

@@ -0,0 +1,102 @@
+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 SaleConfigFields {
+  prices: Array<types.PriceFields>
+  priceType: types.PriceRuleKind
+  rules: Array<types.RuleKind>
+  sendToVault: number
+  saleType: types.SaleTypeKind
+}
+
+export interface SaleConfigJSON {
+  prices: Array<types.PriceJSON>
+  priceType: types.PriceRuleJSON
+  rules: Array<types.RuleJSON>
+  sendToVault: number
+  saleType: types.SaleTypeJSON
+}
+
+export class SaleConfig {
+  readonly prices: Array<types.Price>
+  readonly priceType: types.PriceRuleKind
+  readonly rules: Array<types.RuleKind>
+  readonly sendToVault: number
+  readonly saleType: types.SaleTypeKind
+
+  constructor(fields: SaleConfigFields) {
+    this.prices = fields.prices.map((item) => new types.Price({ ...item }))
+    this.priceType = fields.priceType
+    this.rules = fields.rules
+    this.sendToVault = fields.sendToVault
+    this.saleType = fields.saleType
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.vec(types.Price.layout(), "prices"),
+        types.PriceRule.layout("priceType"),
+        borsh.vec(types.Rule.layout(), "rules"),
+        borsh.u8("sendToVault"),
+        types.SaleType.layout("saleType"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new SaleConfig({
+      prices: obj.prices.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.Price.fromDecoded(item)
+      ),
+      priceType: types.PriceRule.fromDecoded(obj.priceType),
+      rules: obj.rules.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.Rule.fromDecoded(item)
+      ),
+      sendToVault: obj.sendToVault,
+      saleType: types.SaleType.fromDecoded(obj.saleType),
+    })
+  }
+
+  static toEncodable(fields: SaleConfigFields) {
+    return {
+      prices: fields.prices.map((item) => types.Price.toEncodable(item)),
+      priceType: fields.priceType.toEncodable(),
+      rules: fields.rules.map((item) => item.toEncodable()),
+      sendToVault: fields.sendToVault,
+      saleType: fields.saleType.toEncodable(),
+    }
+  }
+
+  toJSON(): SaleConfigJSON {
+    return {
+      prices: this.prices.map((item) => item.toJSON()),
+      priceType: this.priceType.toJSON(),
+      rules: this.rules.map((item) => item.toJSON()),
+      sendToVault: this.sendToVault,
+      saleType: this.saleType.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: SaleConfigJSON): SaleConfig {
+    return new SaleConfig({
+      prices: obj.prices.map((item) => types.Price.fromJSON(item)),
+      priceType: types.PriceRule.fromJSON(obj.priceType),
+      rules: obj.rules.map((item) => types.Rule.fromJSON(item)),
+      sendToVault: obj.sendToVault,
+      saleType: types.SaleType.fromJSON(obj.saleType),
+    })
+  }
+
+  toEncodable() {
+    return SaleConfig.toEncodable(this)
+  }
+}

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