3land_sdk 1.0.0

package/src/types/types/TraitType.ts

@@ -0,0 +1,267 @@
+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 SemiFungibleFields = {
+  hash: BN
+  count: number
+  supply: BN
+  total: BN
+}
+export type SemiFungibleValue = {
+  hash: BN
+  count: number
+  supply: BN
+  total: BN
+}
+
+export interface SemiFungibleJSON {
+  kind: "SemiFungible"
+  value: {
+    hash: string
+    count: number
+    supply: string
+    total: string
+  }
+}
+
+export class SemiFungible {
+  static readonly discriminator = 0
+  static readonly kind = "SemiFungible"
+  readonly discriminator = 0
+  readonly kind = "SemiFungible"
+  readonly value: SemiFungibleValue
+
+  constructor(value: SemiFungibleFields) {
+    this.value = {
+      hash: value.hash,
+      count: value.count,
+      supply: value.supply,
+      total: value.total,
+    }
+  }
+
+  toJSON(): SemiFungibleJSON {
+    return {
+      kind: "SemiFungible",
+      value: {
+        hash: this.value.hash.toString(),
+        count: this.value.count,
+        supply: this.value.supply.toString(),
+        total: this.value.total.toString(),
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      SemiFungible: {
+        hash: this.value.hash,
+        count: this.value.count,
+        supply: this.value.supply,
+        total: this.value.total,
+      },
+    }
+  }
+}
+
+export type DateFields = {
+  hash: BN
+  count: number
+  supply: BN
+}
+export type DateValue = {
+  hash: BN
+  count: number
+  supply: BN
+}
+
+export interface DateJSON {
+  kind: "Date"
+  value: {
+    hash: string
+    count: number
+    supply: string
+  }
+}
+
+export class Date {
+  static readonly discriminator = 1
+  static readonly kind = "Date"
+  readonly discriminator = 1
+  readonly kind = "Date"
+  readonly value: DateValue
+
+  constructor(value: DateFields) {
+    this.value = {
+      hash: value.hash,
+      count: value.count,
+      supply: value.supply,
+    }
+  }
+
+  toJSON(): DateJSON {
+    return {
+      kind: "Date",
+      value: {
+        hash: this.value.hash.toString(),
+        count: this.value.count,
+        supply: this.value.supply.toString(),
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      Date: {
+        hash: this.value.hash,
+        count: this.value.count,
+        supply: this.value.supply,
+      },
+    }
+  }
+}
+
+export type NonFungibleFields = {
+  hash: BN
+  values: Array<types.TraitValueFields>
+}
+export type NonFungibleValue = {
+  hash: BN
+  values: Array<types.TraitValue>
+}
+
+export interface NonFungibleJSON {
+  kind: "NonFungible"
+  value: {
+    hash: string
+    values: Array<types.TraitValueJSON>
+  }
+}
+
+export class NonFungible {
+  static readonly discriminator = 2
+  static readonly kind = "NonFungible"
+  readonly discriminator = 2
+  readonly kind = "NonFungible"
+  readonly value: NonFungibleValue
+
+  constructor(value: NonFungibleFields) {
+    this.value = {
+      hash: value.hash,
+      values: value.values.map((item) => new types.TraitValue({ ...item })),
+    }
+  }
+
+  toJSON(): NonFungibleJSON {
+    return {
+      kind: "NonFungible",
+      value: {
+        hash: this.value.hash.toString(),
+        values: this.value.values.map((item) => item.toJSON()),
+      },
+    }
+  }
+
+  toEncodable() {
+    return {
+      NonFungible: {
+        hash: this.value.hash,
+        values: this.value.values.map((item) =>
+          types.TraitValue.toEncodable(item)
+        ),
+      },
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.TraitTypeKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("SemiFungible" in obj) {
+    const val = obj["SemiFungible"]
+    return new SemiFungible({
+      hash: val["hash"],
+      count: val["count"],
+      supply: val["supply"],
+      total: val["total"],
+    })
+  }
+  if ("Date" in obj) {
+    const val = obj["Date"]
+    return new Date({
+      hash: val["hash"],
+      count: val["count"],
+      supply: val["supply"],
+    })
+  }
+  if ("NonFungible" in obj) {
+    const val = obj["NonFungible"]
+    return new NonFungible({
+      hash: val["hash"],
+      values: val["values"].map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.TraitValue.fromDecoded(item)
+      ),
+    })
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.TraitTypeJSON): types.TraitTypeKind {
+  switch (obj.kind) {
+    case "SemiFungible": {
+      return new SemiFungible({
+        hash: new BN(obj.value.hash),
+        count: obj.value.count,
+        supply: new BN(obj.value.supply),
+        total: new BN(obj.value.total),
+      })
+    }
+    case "Date": {
+      return new Date({
+        hash: new BN(obj.value.hash),
+        count: obj.value.count,
+        supply: new BN(obj.value.supply),
+      })
+    }
+    case "NonFungible": {
+      return new NonFungible({
+        hash: new BN(obj.value.hash),
+        values: obj.value.values.map((item) => types.TraitValue.fromJSON(item)),
+      })
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct(
+      [
+        borsh.u64("hash"),
+        borsh.u32("count"),
+        borsh.u64("supply"),
+        borsh.u64("total"),
+      ],
+      "SemiFungible"
+    ),
+    borsh.struct(
+      [borsh.u64("hash"), borsh.u32("count"), borsh.u64("supply")],
+      "Date"
+    ),
+    borsh.struct(
+      [borsh.u64("hash"), borsh.vec(types.TraitValue.layout(), "values")],
+      "NonFungible"
+    ),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/TraitValue.ts

@@ -0,0 +1,72 @@
+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 TraitValueFields {
+  hash: BN
+  count: number
+  supply: BN
+}
+
+export interface TraitValueJSON {
+  hash: string
+  count: number
+  supply: string
+}
+
+export class TraitValue {
+  readonly hash: BN
+  readonly count: number
+  readonly supply: BN
+
+  constructor(fields: TraitValueFields) {
+    this.hash = fields.hash
+    this.count = fields.count
+    this.supply = fields.supply
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [borsh.u64("hash"), borsh.u32("count"), borsh.u64("supply")],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new TraitValue({
+      hash: obj.hash,
+      count: obj.count,
+      supply: obj.supply,
+    })
+  }
+
+  static toEncodable(fields: TraitValueFields) {
+    return {
+      hash: fields.hash,
+      count: fields.count,
+      supply: fields.supply,
+    }
+  }
+
+  toJSON(): TraitValueJSON {
+    return {
+      hash: this.hash.toString(),
+      count: this.count,
+      supply: this.supply.toString(),
+    }
+  }
+
+  static fromJSON(obj: TraitValueJSON): TraitValue {
+    return new TraitValue({
+      hash: new BN(obj.hash),
+      count: obj.count,
+      supply: new BN(obj.supply),
+    })
+  }
+
+  toEncodable() {
+    return TraitValue.toEncodable(this)
+  }
+}

package/src/types/types/UnlocksAfter.ts

@@ -0,0 +1,172 @@
+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,
+      },
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.UnlocksAfterKind {
+  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"],
+    })
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.UnlocksAfterJSON): types.UnlocksAfterKind {
+  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,
+      })
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "MintingOut"),
+    borsh.struct([borsh.u32("limit")], "Supply"),
+    borsh.struct([borsh.u16("hours")], "Hours"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/UnwrapMetadata.ts

@@ -0,0 +1,156 @@
+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 UnwrapMetadataFields {
+  wrappedAmount: BN
+  decimals: number
+  traitHash: BN
+  name: string
+  arweave: string
+  edition: number
+  leafIndex: number
+  cardIndex: number | null
+  royalty: number
+  creators: Array<types.ShortCreatorFields>
+  bumps: Array<number>
+}
+
+export interface UnwrapMetadataJSON {
+  wrappedAmount: string
+  decimals: number
+  traitHash: string
+  name: string
+  arweave: string
+  edition: number
+  leafIndex: number
+  cardIndex: number | null
+  royalty: number
+  creators: Array<types.ShortCreatorJSON>
+  bumps: Array<number>
+}
+
+export class UnwrapMetadata {
+  readonly wrappedAmount: BN
+  readonly decimals: number
+  readonly traitHash: BN
+  readonly name: string
+  readonly arweave: string
+  readonly edition: number
+  readonly leafIndex: number
+  readonly cardIndex: number | null
+  readonly royalty: number
+  readonly creators: Array<types.ShortCreator>
+  readonly bumps: Array<number>
+
+  constructor(fields: UnwrapMetadataFields) {
+    this.wrappedAmount = fields.wrappedAmount
+    this.decimals = fields.decimals
+    this.traitHash = fields.traitHash
+    this.name = fields.name
+    this.arweave = fields.arweave
+    this.edition = fields.edition
+    this.leafIndex = fields.leafIndex
+    this.cardIndex = fields.cardIndex
+    this.royalty = fields.royalty
+    this.creators = fields.creators.map(
+      (item) => new types.ShortCreator({ ...item })
+    )
+    this.bumps = fields.bumps
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.u64("wrappedAmount"),
+        borsh.u8("decimals"),
+        borsh.u64("traitHash"),
+        borsh.str("name"),
+        borsh.str("arweave"),
+        borsh.u32("edition"),
+        borsh.u32("leafIndex"),
+        borsh.option(borsh.u32(), "cardIndex"),
+        borsh.u16("royalty"),
+        borsh.vec(types.ShortCreator.layout(), "creators"),
+        borsh.array(borsh.u8(), 2, "bumps"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new UnwrapMetadata({
+      wrappedAmount: obj.wrappedAmount,
+      decimals: obj.decimals,
+      traitHash: obj.traitHash,
+      name: obj.name,
+      arweave: obj.arweave,
+      edition: obj.edition,
+      leafIndex: obj.leafIndex,
+      cardIndex: obj.cardIndex,
+      royalty: obj.royalty,
+      creators: obj.creators.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.ShortCreator.fromDecoded(item)
+      ),
+      bumps: obj.bumps,
+    })
+  }
+
+  static toEncodable(fields: UnwrapMetadataFields) {
+    return {
+      wrappedAmount: fields.wrappedAmount,
+      decimals: fields.decimals,
+      traitHash: fields.traitHash,
+      name: fields.name,
+      arweave: fields.arweave,
+      edition: fields.edition,
+      leafIndex: fields.leafIndex,
+      cardIndex: fields.cardIndex,
+      royalty: fields.royalty,
+      creators: fields.creators.map((item) =>
+        types.ShortCreator.toEncodable(item)
+      ),
+      bumps: fields.bumps,
+    }
+  }
+
+  toJSON(): UnwrapMetadataJSON {
+    return {
+      wrappedAmount: this.wrappedAmount.toString(),
+      decimals: this.decimals,
+      traitHash: this.traitHash.toString(),
+      name: this.name,
+      arweave: this.arweave,
+      edition: this.edition,
+      leafIndex: this.leafIndex,
+      cardIndex: this.cardIndex,
+      royalty: this.royalty,
+      creators: this.creators.map((item) => item.toJSON()),
+      bumps: this.bumps,
+    }
+  }
+
+  static fromJSON(obj: UnwrapMetadataJSON): UnwrapMetadata {
+    return new UnwrapMetadata({
+      wrappedAmount: new BN(obj.wrappedAmount),
+      decimals: obj.decimals,
+      traitHash: new BN(obj.traitHash),
+      name: obj.name,
+      arweave: obj.arweave,
+      edition: obj.edition,
+      leafIndex: obj.leafIndex,
+      cardIndex: obj.cardIndex,
+      royalty: obj.royalty,
+      creators: obj.creators.map((item) => types.ShortCreator.fromJSON(item)),
+      bumps: obj.bumps,
+    })
+  }
+
+  toEncodable() {
+    return UnwrapMetadata.toEncodable(this)
+  }
+}