3land_sdk 1.0.0

package/src/types/accounts/CreatorRegistry.ts

@@ -0,0 +1,153 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId"
+
+export interface CreatorRegistryFields {
+  class: types.AccountClassKind
+  storeHash: BN
+  currency: PublicKey
+  creator: PublicKey
+  donations: BN
+  date: types.IndexDateFields
+  filters: Array<number>
+  track: types.SaleTrackFields
+  lut: PublicKey
+}
+
+export interface CreatorRegistryJSON {
+  class: types.AccountClassJSON
+  storeHash: string
+  currency: string
+  creator: string
+  donations: string
+  date: types.IndexDateJSON
+  filters: Array<number>
+  track: types.SaleTrackJSON
+  lut: string
+}
+
+export class CreatorRegistry {
+  readonly class: types.AccountClassKind
+  readonly storeHash: BN
+  readonly currency: PublicKey
+  readonly creator: PublicKey
+  readonly donations: BN
+  readonly date: types.IndexDate
+  readonly filters: Array<number>
+  readonly track: types.SaleTrack
+  readonly lut: PublicKey
+
+  static readonly discriminator = Buffer.from([
+    14, 189, 133, 111, 190, 233, 2, 236,
+  ])
+
+  static readonly layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    borsh.u64("storeHash"),
+    borsh.publicKey("currency"),
+    borsh.publicKey("creator"),
+    borsh.u64("donations"),
+    types.IndexDate.layout("date"),
+    borsh.array(borsh.u8(), 8, "filters"),
+    types.SaleTrack.layout("track"),
+    borsh.publicKey("lut"),
+  ])
+
+  constructor(fields: CreatorRegistryFields) {
+    this.class = fields.class
+    this.storeHash = fields.storeHash
+    this.currency = fields.currency
+    this.creator = fields.creator
+    this.donations = fields.donations
+    this.date = new types.IndexDate({ ...fields.date })
+    this.filters = fields.filters
+    this.track = new types.SaleTrack({ ...fields.track })
+    this.lut = fields.lut
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<CreatorRegistry | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Array<CreatorRegistry | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): CreatorRegistry {
+    if (!data.slice(0, 8).equals(CreatorRegistry.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = CreatorRegistry.layout.decode(data.slice(8))
+
+    return new CreatorRegistry({
+      class: types.AccountClass.fromDecoded(dec.class),
+      storeHash: dec.storeHash,
+      currency: dec.currency,
+      creator: dec.creator,
+      donations: dec.donations,
+      date: types.IndexDate.fromDecoded(dec.date),
+      filters: dec.filters,
+      track: types.SaleTrack.fromDecoded(dec.track),
+      lut: dec.lut,
+    })
+  }
+
+  toJSON(): CreatorRegistryJSON {
+    return {
+      class: this.class.toJSON(),
+      storeHash: this.storeHash.toString(),
+      currency: this.currency.toString(),
+      creator: this.creator.toString(),
+      donations: this.donations.toString(),
+      date: this.date.toJSON(),
+      filters: this.filters,
+      track: this.track.toJSON(),
+      lut: this.lut.toString(),
+    }
+  }
+
+  static fromJSON(obj: CreatorRegistryJSON): CreatorRegistry {
+    return new CreatorRegistry({
+      class: types.AccountClass.fromJSON(obj.class),
+      storeHash: new BN(obj.storeHash),
+      currency: new PublicKey(obj.currency),
+      creator: new PublicKey(obj.creator),
+      donations: new BN(obj.donations),
+      date: types.IndexDate.fromJSON(obj.date),
+      filters: obj.filters,
+      track: types.SaleTrack.fromJSON(obj.track),
+      lut: new PublicKey(obj.lut),
+    })
+  }
+}

package/src/types/accounts/CurrencyArtistProof.ts

@@ -0,0 +1,113 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId"
+
+export interface CurrencyArtistProofFields {
+  proofHash: BN
+  amount: BN
+  currencyVerifier: number
+  artistVerifier: number
+}
+
+export interface CurrencyArtistProofJSON {
+  proofHash: string
+  amount: string
+  currencyVerifier: number
+  artistVerifier: number
+}
+
+export class CurrencyArtistProof {
+  readonly proofHash: BN
+  readonly amount: BN
+  readonly currencyVerifier: number
+  readonly artistVerifier: number
+
+  static readonly discriminator = Buffer.from([
+    11, 32, 176, 50, 245, 55, 208, 119,
+  ])
+
+  static readonly layout = borsh.struct([
+    borsh.u64("proofHash"),
+    borsh.u64("amount"),
+    borsh.u32("currencyVerifier"),
+    borsh.u32("artistVerifier"),
+  ])
+
+  constructor(fields: CurrencyArtistProofFields) {
+    this.proofHash = fields.proofHash
+    this.amount = fields.amount
+    this.currencyVerifier = fields.currencyVerifier
+    this.artistVerifier = fields.artistVerifier
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<CurrencyArtistProof | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Array<CurrencyArtistProof | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): CurrencyArtistProof {
+    if (!data.slice(0, 8).equals(CurrencyArtistProof.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = CurrencyArtistProof.layout.decode(data.slice(8))
+
+    return new CurrencyArtistProof({
+      proofHash: dec.proofHash,
+      amount: dec.amount,
+      currencyVerifier: dec.currencyVerifier,
+      artistVerifier: dec.artistVerifier,
+    })
+  }
+
+  toJSON(): CurrencyArtistProofJSON {
+    return {
+      proofHash: this.proofHash.toString(),
+      amount: this.amount.toString(),
+      currencyVerifier: this.currencyVerifier,
+      artistVerifier: this.artistVerifier,
+    }
+  }
+
+  static fromJSON(obj: CurrencyArtistProofJSON): CurrencyArtistProof {
+    return new CurrencyArtistProof({
+      proofHash: new BN(obj.proofHash),
+      amount: new BN(obj.amount),
+      currencyVerifier: obj.currencyVerifier,
+      artistVerifier: obj.artistVerifier,
+    })
+  }
+}

package/src/types/accounts/GenericUser.ts

@@ -0,0 +1,185 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId"
+
+export interface GenericUserFields {
+  class: types.AccountClassKind
+  subApp: BN
+  holderHash: BN
+  category: BN
+  creator: PublicKey
+  lutAccount: PublicKey
+  subWallets: Array<PublicKey>
+  extended: number
+  flags: Array<number>
+  username: string
+  genericStore: Array<types.GenericStoreFields>
+  extra: Array<number>
+}
+
+export interface GenericUserJSON {
+  class: types.AccountClassJSON
+  subApp: string
+  holderHash: string
+  category: string
+  creator: string
+  lutAccount: string
+  subWallets: Array<string>
+  extended: number
+  flags: Array<number>
+  username: string
+  genericStore: Array<types.GenericStoreJSON>
+  extra: Array<number>
+}
+
+export class GenericUser {
+  readonly class: types.AccountClassKind
+  readonly subApp: BN
+  readonly holderHash: BN
+  readonly category: BN
+  readonly creator: PublicKey
+  readonly lutAccount: PublicKey
+  readonly subWallets: Array<PublicKey>
+  readonly extended: number
+  readonly flags: Array<number>
+  readonly username: string
+  readonly genericStore: Array<types.GenericStore>
+  readonly extra: Array<number>
+
+  static readonly discriminator = Buffer.from([
+    222, 233, 191, 5, 55, 3, 237, 241,
+  ])
+
+  static readonly layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    borsh.u64("subApp"),
+    borsh.u64("holderHash"),
+    borsh.u64("category"),
+    borsh.publicKey("creator"),
+    borsh.publicKey("lutAccount"),
+    borsh.vec(borsh.publicKey(), "subWallets"),
+    borsh.u8("extended"),
+    borsh.array(borsh.u8(), 8, "flags"),
+    borsh.str("username"),
+    borsh.vec(types.GenericStore.layout(), "genericStore"),
+    borsh.array(borsh.u8(), 32, "extra"),
+  ])
+
+  constructor(fields: GenericUserFields) {
+    this.class = fields.class
+    this.subApp = fields.subApp
+    this.holderHash = fields.holderHash
+    this.category = fields.category
+    this.creator = fields.creator
+    this.lutAccount = fields.lutAccount
+    this.subWallets = fields.subWallets
+    this.extended = fields.extended
+    this.flags = fields.flags
+    this.username = fields.username
+    this.genericStore = fields.genericStore.map(
+      (item) => new types.GenericStore({ ...item })
+    )
+    this.extra = fields.extra
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<GenericUser | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Array<GenericUser | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): GenericUser {
+    if (!data.slice(0, 8).equals(GenericUser.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = GenericUser.layout.decode(data.slice(8))
+
+    return new GenericUser({
+      class: types.AccountClass.fromDecoded(dec.class),
+      subApp: dec.subApp,
+      holderHash: dec.holderHash,
+      category: dec.category,
+      creator: dec.creator,
+      lutAccount: dec.lutAccount,
+      subWallets: dec.subWallets,
+      extended: dec.extended,
+      flags: dec.flags,
+      username: dec.username,
+      genericStore: dec.genericStore.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.GenericStore.fromDecoded(item)
+      ),
+      extra: dec.extra,
+    })
+  }
+
+  toJSON(): GenericUserJSON {
+    return {
+      class: this.class.toJSON(),
+      subApp: this.subApp.toString(),
+      holderHash: this.holderHash.toString(),
+      category: this.category.toString(),
+      creator: this.creator.toString(),
+      lutAccount: this.lutAccount.toString(),
+      subWallets: this.subWallets.map((item) => item.toString()),
+      extended: this.extended,
+      flags: this.flags,
+      username: this.username,
+      genericStore: this.genericStore.map((item) => item.toJSON()),
+      extra: this.extra,
+    }
+  }
+
+  static fromJSON(obj: GenericUserJSON): GenericUser {
+    return new GenericUser({
+      class: types.AccountClass.fromJSON(obj.class),
+      subApp: new BN(obj.subApp),
+      holderHash: new BN(obj.holderHash),
+      category: new BN(obj.category),
+      creator: new PublicKey(obj.creator),
+      lutAccount: new PublicKey(obj.lutAccount),
+      subWallets: obj.subWallets.map((item) => new PublicKey(item)),
+      extended: obj.extended,
+      flags: obj.flags,
+      username: obj.username,
+      genericStore: obj.genericStore.map((item) =>
+        types.GenericStore.fromJSON(item)
+      ),
+      extra: obj.extra,
+    })
+  }
+}

package/src/types/accounts/ItemArchive.ts

@@ -0,0 +1,223 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId"
+
+export interface ItemArchiveFields {
+  class: types.AccountClassKind
+  globalState: types.GlobalStateKind
+  holder: PublicKey
+  creator: PublicKey
+  dates: types.IndexDatesFields
+  category: types.CategoryFields
+  superCategory: types.SuperCategoryFields
+  eventCategory: number
+  trackType: types.TrackRegistryKind
+  mainCurrencyHash: BN
+  state: types.ItemStateKind
+  collection: PublicKey
+  cnft: PublicKey
+  identifier: BN
+  hash: BN
+  supply: BN
+  volume: Array<types.FakeVolumeTrackFields>
+}
+
+export interface ItemArchiveJSON {
+  class: types.AccountClassJSON
+  globalState: types.GlobalStateJSON
+  holder: string
+  creator: string
+  dates: types.IndexDatesJSON
+  category: types.CategoryJSON
+  superCategory: types.SuperCategoryJSON
+  eventCategory: number
+  trackType: types.TrackRegistryJSON
+  mainCurrencyHash: string
+  state: types.ItemStateJSON
+  collection: string
+  cnft: string
+  identifier: string
+  hash: string
+  supply: string
+  volume: Array<types.FakeVolumeTrackJSON>
+}
+
+export class ItemArchive {
+  readonly class: types.AccountClassKind
+  readonly globalState: types.GlobalStateKind
+  readonly holder: PublicKey
+  readonly creator: PublicKey
+  readonly dates: types.IndexDates
+  readonly category: types.Category
+  readonly superCategory: types.SuperCategory
+  readonly eventCategory: number
+  readonly trackType: types.TrackRegistryKind
+  readonly mainCurrencyHash: BN
+  readonly state: types.ItemStateKind
+  readonly collection: PublicKey
+  readonly cnft: PublicKey
+  readonly identifier: BN
+  readonly hash: BN
+  readonly supply: BN
+  readonly volume: Array<types.FakeVolumeTrack>
+
+  static readonly discriminator = Buffer.from([
+    11, 87, 59, 106, 157, 209, 221, 195,
+  ])
+
+  static readonly layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    types.GlobalState.layout("globalState"),
+    borsh.publicKey("holder"),
+    borsh.publicKey("creator"),
+    types.IndexDates.layout("dates"),
+    types.Category.layout("category"),
+    types.SuperCategory.layout("superCategory"),
+    borsh.u16("eventCategory"),
+    types.TrackRegistry.layout("trackType"),
+    borsh.u64("mainCurrencyHash"),
+    types.ItemState.layout("state"),
+    borsh.publicKey("collection"),
+    borsh.publicKey("cnft"),
+    borsh.u64("identifier"),
+    borsh.u64("hash"),
+    borsh.u64("supply"),
+    borsh.vec(types.FakeVolumeTrack.layout(), "volume"),
+  ])
+
+  constructor(fields: ItemArchiveFields) {
+    this.class = fields.class
+    this.globalState = fields.globalState
+    this.holder = fields.holder
+    this.creator = fields.creator
+    this.dates = new types.IndexDates({ ...fields.dates })
+    this.category = new types.Category({ ...fields.category })
+    this.superCategory = new types.SuperCategory({ ...fields.superCategory })
+    this.eventCategory = fields.eventCategory
+    this.trackType = fields.trackType
+    this.mainCurrencyHash = fields.mainCurrencyHash
+    this.state = fields.state
+    this.collection = fields.collection
+    this.cnft = fields.cnft
+    this.identifier = fields.identifier
+    this.hash = fields.hash
+    this.supply = fields.supply
+    this.volume = fields.volume.map(
+      (item) => new types.FakeVolumeTrack({ ...item })
+    )
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<ItemArchive | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Array<ItemArchive | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): ItemArchive {
+    if (!data.slice(0, 8).equals(ItemArchive.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = ItemArchive.layout.decode(data.slice(8))
+
+    return new ItemArchive({
+      class: types.AccountClass.fromDecoded(dec.class),
+      globalState: types.GlobalState.fromDecoded(dec.globalState),
+      holder: dec.holder,
+      creator: dec.creator,
+      dates: types.IndexDates.fromDecoded(dec.dates),
+      category: types.Category.fromDecoded(dec.category),
+      superCategory: types.SuperCategory.fromDecoded(dec.superCategory),
+      eventCategory: dec.eventCategory,
+      trackType: types.TrackRegistry.fromDecoded(dec.trackType),
+      mainCurrencyHash: dec.mainCurrencyHash,
+      state: types.ItemState.fromDecoded(dec.state),
+      collection: dec.collection,
+      cnft: dec.cnft,
+      identifier: dec.identifier,
+      hash: dec.hash,
+      supply: dec.supply,
+      volume: dec.volume.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.FakeVolumeTrack.fromDecoded(item)
+      ),
+    })
+  }
+
+  toJSON(): ItemArchiveJSON {
+    return {
+      class: this.class.toJSON(),
+      globalState: this.globalState.toJSON(),
+      holder: this.holder.toString(),
+      creator: this.creator.toString(),
+      dates: this.dates.toJSON(),
+      category: this.category.toJSON(),
+      superCategory: this.superCategory.toJSON(),
+      eventCategory: this.eventCategory,
+      trackType: this.trackType.toJSON(),
+      mainCurrencyHash: this.mainCurrencyHash.toString(),
+      state: this.state.toJSON(),
+      collection: this.collection.toString(),
+      cnft: this.cnft.toString(),
+      identifier: this.identifier.toString(),
+      hash: this.hash.toString(),
+      supply: this.supply.toString(),
+      volume: this.volume.map((item) => item.toJSON()),
+    }
+  }
+
+  static fromJSON(obj: ItemArchiveJSON): ItemArchive {
+    return new ItemArchive({
+      class: types.AccountClass.fromJSON(obj.class),
+      globalState: types.GlobalState.fromJSON(obj.globalState),
+      holder: new PublicKey(obj.holder),
+      creator: new PublicKey(obj.creator),
+      dates: types.IndexDates.fromJSON(obj.dates),
+      category: types.Category.fromJSON(obj.category),
+      superCategory: types.SuperCategory.fromJSON(obj.superCategory),
+      eventCategory: obj.eventCategory,
+      trackType: types.TrackRegistry.fromJSON(obj.trackType),
+      mainCurrencyHash: new BN(obj.mainCurrencyHash),
+      state: types.ItemState.fromJSON(obj.state),
+      collection: new PublicKey(obj.collection),
+      cnft: new PublicKey(obj.cnft),
+      identifier: new BN(obj.identifier),
+      hash: new BN(obj.hash),
+      supply: new BN(obj.supply),
+      volume: obj.volume.map((item) => types.FakeVolumeTrack.fromJSON(item)),
+    })
+  }
+}