3land_sdk 1.0.0

package/src/types/types/ShortMetadataArgs.ts

@@ -0,0 +1,111 @@
+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 ShortMetadataArgsFields {
+  name: string
+  uri: string
+  uriType: number
+  sellerFeeBasisPoints: number
+  collection: PublicKey
+  creators: Array<types.ShortCreatorFields>
+}
+
+export interface ShortMetadataArgsJSON {
+  name: string
+  uri: string
+  uriType: number
+  sellerFeeBasisPoints: number
+  collection: string
+  creators: Array<types.ShortCreatorJSON>
+}
+
+export class ShortMetadataArgs {
+  readonly name: string
+  readonly uri: string
+  readonly uriType: number
+  readonly sellerFeeBasisPoints: number
+  readonly collection: PublicKey
+  readonly creators: Array<types.ShortCreator>
+
+  constructor(fields: ShortMetadataArgsFields) {
+    this.name = fields.name
+    this.uri = fields.uri
+    this.uriType = fields.uriType
+    this.sellerFeeBasisPoints = fields.sellerFeeBasisPoints
+    this.collection = fields.collection
+    this.creators = fields.creators.map(
+      (item) => new types.ShortCreator({ ...item })
+    )
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.str("name"),
+        borsh.str("uri"),
+        borsh.u8("uriType"),
+        borsh.u16("sellerFeeBasisPoints"),
+        borsh.publicKey("collection"),
+        borsh.vec(types.ShortCreator.layout(), "creators"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new ShortMetadataArgs({
+      name: obj.name,
+      uri: obj.uri,
+      uriType: obj.uriType,
+      sellerFeeBasisPoints: obj.sellerFeeBasisPoints,
+      collection: obj.collection,
+      creators: obj.creators.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.ShortCreator.fromDecoded(item)
+      ),
+    })
+  }
+
+  static toEncodable(fields: ShortMetadataArgsFields) {
+    return {
+      name: fields.name,
+      uri: fields.uri,
+      uriType: fields.uriType,
+      sellerFeeBasisPoints: fields.sellerFeeBasisPoints,
+      collection: fields.collection,
+      creators: fields.creators.map((item) =>
+        types.ShortCreator.toEncodable(item)
+      ),
+    }
+  }
+
+  toJSON(): ShortMetadataArgsJSON {
+    return {
+      name: this.name,
+      uri: this.uri,
+      uriType: this.uriType,
+      sellerFeeBasisPoints: this.sellerFeeBasisPoints,
+      collection: this.collection.toString(),
+      creators: this.creators.map((item) => item.toJSON()),
+    }
+  }
+
+  static fromJSON(obj: ShortMetadataArgsJSON): ShortMetadataArgs {
+    return new ShortMetadataArgs({
+      name: obj.name,
+      uri: obj.uri,
+      uriType: obj.uriType,
+      sellerFeeBasisPoints: obj.sellerFeeBasisPoints,
+      collection: new PublicKey(obj.collection),
+      creators: obj.creators.map((item) => types.ShortCreator.fromJSON(item)),
+    })
+  }
+
+  toEncodable() {
+    return ShortMetadataArgs.toEncodable(this)
+  }
+}

package/src/types/types/StoreConfig.ts

@@ -0,0 +1,98 @@
+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 StoreConfigFields {
+  fee: BN
+  feePercentage: number
+  feeType: types.FeeTypeKind
+  trust: PublicKey
+  rules: Array<types.StoreRuleKind>
+}
+
+export interface StoreConfigJSON {
+  fee: string
+  feePercentage: number
+  feeType: types.FeeTypeJSON
+  trust: string
+  rules: Array<types.StoreRuleJSON>
+}
+
+export class StoreConfig {
+  readonly fee: BN
+  readonly feePercentage: number
+  readonly feeType: types.FeeTypeKind
+  readonly trust: PublicKey
+  readonly rules: Array<types.StoreRuleKind>
+
+  constructor(fields: StoreConfigFields) {
+    this.fee = fields.fee
+    this.feePercentage = fields.feePercentage
+    this.feeType = fields.feeType
+    this.trust = fields.trust
+    this.rules = fields.rules
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.u64("fee"),
+        borsh.u16("feePercentage"),
+        types.FeeType.layout("feeType"),
+        borsh.publicKey("trust"),
+        borsh.vec(types.StoreRule.layout(), "rules"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new StoreConfig({
+      fee: obj.fee,
+      feePercentage: obj.feePercentage,
+      feeType: types.FeeType.fromDecoded(obj.feeType),
+      trust: obj.trust,
+      rules: obj.rules.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.StoreRule.fromDecoded(item)
+      ),
+    })
+  }
+
+  static toEncodable(fields: StoreConfigFields) {
+    return {
+      fee: fields.fee,
+      feePercentage: fields.feePercentage,
+      feeType: fields.feeType.toEncodable(),
+      trust: fields.trust,
+      rules: fields.rules.map((item) => item.toEncodable()),
+    }
+  }
+
+  toJSON(): StoreConfigJSON {
+    return {
+      fee: this.fee.toString(),
+      feePercentage: this.feePercentage,
+      feeType: this.feeType.toJSON(),
+      trust: this.trust.toString(),
+      rules: this.rules.map((item) => item.toJSON()),
+    }
+  }
+
+  static fromJSON(obj: StoreConfigJSON): StoreConfig {
+    return new StoreConfig({
+      fee: new BN(obj.fee),
+      feePercentage: obj.feePercentage,
+      feeType: types.FeeType.fromJSON(obj.feeType),
+      trust: new PublicKey(obj.trust),
+      rules: obj.rules.map((item) => types.StoreRule.fromJSON(item)),
+    })
+  }
+
+  toEncodable() {
+    return StoreConfig.toEncodable(this)
+  }
+}

package/src/types/types/StoreRule.ts

@@ -0,0 +1,145 @@
+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 ListingPerWalletFields = {
+  config: types.ListingPerWalletArgsFields
+}
+export type ListingPerWalletValue = {
+  config: types.ListingPerWalletArgs
+}
+
+export interface ListingPerWalletJSON {
+  kind: "ListingPerWallet"
+  value: {
+    config: types.ListingPerWalletArgsJSON
+  }
+}
+
+export class ListingPerWallet {
+  static readonly discriminator = 0
+  static readonly kind = "ListingPerWallet"
+  readonly discriminator = 0
+  readonly kind = "ListingPerWallet"
+  readonly value: ListingPerWalletValue
+
+  constructor(value: ListingPerWalletFields) {
+    this.value = {
+      config: new types.ListingPerWalletArgs({ ...value.config }),
+    }
+  }
+
+  toJSON(): ListingPerWalletJSON {
+    return {
+      kind: "ListingPerWallet",
+      value: {
+        config: this.value.config.toJSON(),
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      ListingPerWallet: {
+        config: types.ListingPerWalletArgs.toEncodable(this.value.config),
+      },
+    }
+  }
+}
+
+export type AllowedCurrencyFields = {
+  config: types.CurrencyTypeKind
+}
+export type AllowedCurrencyValue = {
+  config: types.CurrencyTypeKind
+}
+
+export interface AllowedCurrencyJSON {
+  kind: "AllowedCurrency"
+  value: {
+    config: types.CurrencyTypeJSON
+  }
+}
+
+export class AllowedCurrency {
+  static readonly discriminator = 1
+  static readonly kind = "AllowedCurrency"
+  readonly discriminator = 1
+  readonly kind = "AllowedCurrency"
+  readonly value: AllowedCurrencyValue
+
+  constructor(value: AllowedCurrencyFields) {
+    this.value = {
+      config: value.config,
+    }
+  }
+
+  toJSON(): AllowedCurrencyJSON {
+    return {
+      kind: "AllowedCurrency",
+      value: {
+        config: this.value.config.toJSON(),
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      AllowedCurrency: {
+        config: this.value.config.toEncodable(),
+      },
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.StoreRuleKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("ListingPerWallet" in obj) {
+    const val = obj["ListingPerWallet"]
+    return new ListingPerWallet({
+      config: types.ListingPerWalletArgs.fromDecoded(val["config"]),
+    })
+  }
+  if ("AllowedCurrency" in obj) {
+    const val = obj["AllowedCurrency"]
+    return new AllowedCurrency({
+      config: types.CurrencyType.fromDecoded(val["config"]),
+    })
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.StoreRuleJSON): types.StoreRuleKind {
+  switch (obj.kind) {
+    case "ListingPerWallet": {
+      return new ListingPerWallet({
+        config: types.ListingPerWalletArgs.fromJSON(obj.value.config),
+      })
+    }
+    case "AllowedCurrency": {
+      return new AllowedCurrency({
+        config: types.CurrencyType.fromJSON(obj.value.config),
+      })
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct(
+      [types.ListingPerWalletArgs.layout("config")],
+      "ListingPerWallet"
+    ),
+    borsh.struct([types.CurrencyType.layout("config")], "AllowedCurrency"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/SuperCategory.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 SuperCategoryFields {
+  cat1: number
+  cat2: number
+}
+
+export interface SuperCategoryJSON {
+  cat1: number
+  cat2: number
+}
+
+export class SuperCategory {
+  readonly cat1: number
+  readonly cat2: number
+
+  constructor(fields: SuperCategoryFields) {
+    this.cat1 = fields.cat1
+    this.cat2 = fields.cat2
+  }
+
+  static layout(property?: string) {
+    return borsh.struct([borsh.u8("cat1"), borsh.u8("cat2")], property)
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new SuperCategory({
+      cat1: obj.cat1,
+      cat2: obj.cat2,
+    })
+  }
+
+  static toEncodable(fields: SuperCategoryFields) {
+    return {
+      cat1: fields.cat1,
+      cat2: fields.cat2,
+    }
+  }
+
+  toJSON(): SuperCategoryJSON {
+    return {
+      cat1: this.cat1,
+      cat2: this.cat2,
+    }
+  }
+
+  static fromJSON(obj: SuperCategoryJSON): SuperCategory {
+    return new SuperCategory({
+      cat1: obj.cat1,
+      cat2: obj.cat2,
+    })
+  }
+
+  toEncodable() {
+    return SuperCategory.toEncodable(this)
+  }
+}

package/src/types/types/TightCardMetadata.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 TightCardMetadataFields {
+  traitHash: BN
+  name: string
+  arweave: string
+  royalty: number
+  chunkSize: number
+  creators: Array<types.ShortCreatorFields>
+  uploader: PublicKey | null
+}
+
+export interface TightCardMetadataJSON {
+  traitHash: string
+  name: string
+  arweave: string
+  royalty: number
+  chunkSize: number
+  creators: Array<types.ShortCreatorJSON>
+  uploader: string | null
+}
+
+export class TightCardMetadata {
+  readonly traitHash: BN
+  readonly name: string
+  readonly arweave: string
+  readonly royalty: number
+  readonly chunkSize: number
+  readonly creators: Array<types.ShortCreator>
+  readonly uploader: PublicKey | null
+
+  constructor(fields: TightCardMetadataFields) {
+    this.traitHash = fields.traitHash
+    this.name = fields.name
+    this.arweave = fields.arweave
+    this.royalty = fields.royalty
+    this.chunkSize = fields.chunkSize
+    this.creators = fields.creators.map(
+      (item) => new types.ShortCreator({ ...item })
+    )
+    this.uploader = fields.uploader
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.u64("traitHash"),
+        borsh.str("name"),
+        borsh.str("arweave"),
+        borsh.u16("royalty"),
+        borsh.u8("chunkSize"),
+        borsh.vec(types.ShortCreator.layout(), "creators"),
+        borsh.option(borsh.publicKey(), "uploader"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new TightCardMetadata({
+      traitHash: obj.traitHash,
+      name: obj.name,
+      arweave: obj.arweave,
+      royalty: obj.royalty,
+      chunkSize: obj.chunkSize,
+      creators: obj.creators.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.ShortCreator.fromDecoded(item)
+      ),
+      uploader: obj.uploader,
+    })
+  }
+
+  static toEncodable(fields: TightCardMetadataFields) {
+    return {
+      traitHash: fields.traitHash,
+      name: fields.name,
+      arweave: fields.arweave,
+      royalty: fields.royalty,
+      chunkSize: fields.chunkSize,
+      creators: fields.creators.map((item) =>
+        types.ShortCreator.toEncodable(item)
+      ),
+      uploader: fields.uploader,
+    }
+  }
+
+  toJSON(): TightCardMetadataJSON {
+    return {
+      traitHash: this.traitHash.toString(),
+      name: this.name,
+      arweave: this.arweave,
+      royalty: this.royalty,
+      chunkSize: this.chunkSize,
+      creators: this.creators.map((item) => item.toJSON()),
+      uploader: (this.uploader && this.uploader.toString()) || null,
+    }
+  }
+
+  static fromJSON(obj: TightCardMetadataJSON): TightCardMetadata {
+    return new TightCardMetadata({
+      traitHash: new BN(obj.traitHash),
+      name: obj.name,
+      arweave: obj.arweave,
+      royalty: obj.royalty,
+      chunkSize: obj.chunkSize,
+      creators: obj.creators.map((item) => types.ShortCreator.fromJSON(item)),
+      uploader: (obj.uploader && new PublicKey(obj.uploader)) || null,
+    })
+  }
+
+  toEncodable() {
+    return TightCardMetadata.toEncodable(this)
+  }
+}

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

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