3land_sdk 1.0.0

package/src/types/accounts/PoolVault.ts

@@ -0,0 +1,177 @@
+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 PoolVaultFields {
+  class: types.AccountClassKind
+  state: types.PoolStateKind
+  storeHash: BN
+  currency: PublicKey
+  creator: PublicKey
+  poolType: types.PoolTypeKind
+  access: types.PoolAccessKind
+  deposit: BN
+  secured: BN
+  decimals: number
+  managers: Array<PublicKey>
+  name: string
+}
+
+export interface PoolVaultJSON {
+  class: types.AccountClassJSON
+  state: types.PoolStateJSON
+  storeHash: string
+  currency: string
+  creator: string
+  poolType: types.PoolTypeJSON
+  access: types.PoolAccessJSON
+  deposit: string
+  secured: string
+  decimals: number
+  managers: Array<string>
+  name: string
+}
+
+export class PoolVault {
+  readonly class: types.AccountClassKind
+  readonly state: types.PoolStateKind
+  readonly storeHash: BN
+  readonly currency: PublicKey
+  readonly creator: PublicKey
+  readonly poolType: types.PoolTypeKind
+  readonly access: types.PoolAccessKind
+  readonly deposit: BN
+  readonly secured: BN
+  readonly decimals: number
+  readonly managers: Array<PublicKey>
+  readonly name: string
+
+  static readonly discriminator = Buffer.from([
+    9, 184, 204, 69, 231, 82, 252, 154,
+  ])
+
+  static readonly layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    types.PoolState.layout("state"),
+    borsh.u64("storeHash"),
+    borsh.publicKey("currency"),
+    borsh.publicKey("creator"),
+    types.PoolType.layout("poolType"),
+    types.PoolAccess.layout("access"),
+    borsh.u64("deposit"),
+    borsh.u64("secured"),
+    borsh.u8("decimals"),
+    borsh.vec(borsh.publicKey(), "managers"),
+    borsh.str("name"),
+  ])
+
+  constructor(fields: PoolVaultFields) {
+    this.class = fields.class
+    this.state = fields.state
+    this.storeHash = fields.storeHash
+    this.currency = fields.currency
+    this.creator = fields.creator
+    this.poolType = fields.poolType
+    this.access = fields.access
+    this.deposit = fields.deposit
+    this.secured = fields.secured
+    this.decimals = fields.decimals
+    this.managers = fields.managers
+    this.name = fields.name
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<PoolVault | 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<PoolVault | 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): PoolVault {
+    if (!data.slice(0, 8).equals(PoolVault.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = PoolVault.layout.decode(data.slice(8))
+
+    return new PoolVault({
+      class: types.AccountClass.fromDecoded(dec.class),
+      state: types.PoolState.fromDecoded(dec.state),
+      storeHash: dec.storeHash,
+      currency: dec.currency,
+      creator: dec.creator,
+      poolType: types.PoolType.fromDecoded(dec.poolType),
+      access: types.PoolAccess.fromDecoded(dec.access),
+      deposit: dec.deposit,
+      secured: dec.secured,
+      decimals: dec.decimals,
+      managers: dec.managers,
+      name: dec.name,
+    })
+  }
+
+  toJSON(): PoolVaultJSON {
+    return {
+      class: this.class.toJSON(),
+      state: this.state.toJSON(),
+      storeHash: this.storeHash.toString(),
+      currency: this.currency.toString(),
+      creator: this.creator.toString(),
+      poolType: this.poolType.toJSON(),
+      access: this.access.toJSON(),
+      deposit: this.deposit.toString(),
+      secured: this.secured.toString(),
+      decimals: this.decimals,
+      managers: this.managers.map((item) => item.toString()),
+      name: this.name,
+    }
+  }
+
+  static fromJSON(obj: PoolVaultJSON): PoolVault {
+    return new PoolVault({
+      class: types.AccountClass.fromJSON(obj.class),
+      state: types.PoolState.fromJSON(obj.state),
+      storeHash: new BN(obj.storeHash),
+      currency: new PublicKey(obj.currency),
+      creator: new PublicKey(obj.creator),
+      poolType: types.PoolType.fromJSON(obj.poolType),
+      access: types.PoolAccess.fromJSON(obj.access),
+      deposit: new BN(obj.deposit),
+      secured: new BN(obj.secured),
+      decimals: obj.decimals,
+      managers: obj.managers.map((item) => new PublicKey(item)),
+      name: obj.name,
+    })
+  }
+}

package/src/types/accounts/RevealForMe.ts

@@ -0,0 +1,139 @@
+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 RevealForMeFields {
+  class: types.AccountClassKind
+  storeHalfHash: Array<number>
+  state: number
+  creator: PublicKey
+  nft: PublicKey
+  random: number
+  data: Uint8Array
+}
+
+export interface RevealForMeJSON {
+  class: types.AccountClassJSON
+  storeHalfHash: Array<number>
+  state: number
+  creator: string
+  nft: string
+  random: number
+  data: Array<number>
+}
+
+export class RevealForMe {
+  readonly class: types.AccountClassKind
+  readonly storeHalfHash: Array<number>
+  readonly state: number
+  readonly creator: PublicKey
+  readonly nft: PublicKey
+  readonly random: number
+  readonly data: Uint8Array
+
+  static readonly discriminator = Buffer.from([5, 57, 21, 62, 5, 138, 252, 237])
+
+  static readonly layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    borsh.array(borsh.u8(), 4, "storeHalfHash"),
+    borsh.u8("state"),
+    borsh.publicKey("creator"),
+    borsh.publicKey("nft"),
+    borsh.u16("random"),
+    borsh.vecU8("data"),
+  ])
+
+  constructor(fields: RevealForMeFields) {
+    this.class = fields.class
+    this.storeHalfHash = fields.storeHalfHash
+    this.state = fields.state
+    this.creator = fields.creator
+    this.nft = fields.nft
+    this.random = fields.random
+    this.data = fields.data
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<RevealForMe | 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<RevealForMe | 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): RevealForMe {
+    if (!data.slice(0, 8).equals(RevealForMe.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = RevealForMe.layout.decode(data.slice(8))
+
+    return new RevealForMe({
+      class: types.AccountClass.fromDecoded(dec.class),
+      storeHalfHash: dec.storeHalfHash,
+      state: dec.state,
+      creator: dec.creator,
+      nft: dec.nft,
+      random: dec.random,
+      data: new Uint8Array(
+        dec.data.buffer,
+        dec.data.byteOffset,
+        dec.data.length
+      ),
+    })
+  }
+
+  toJSON(): RevealForMeJSON {
+    return {
+      class: this.class.toJSON(),
+      storeHalfHash: this.storeHalfHash,
+      state: this.state,
+      creator: this.creator.toString(),
+      nft: this.nft.toString(),
+      random: this.random,
+      data: Array.from(this.data.values()),
+    }
+  }
+
+  static fromJSON(obj: RevealForMeJSON): RevealForMe {
+    return new RevealForMe({
+      class: types.AccountClass.fromJSON(obj.class),
+      storeHalfHash: obj.storeHalfHash,
+      state: obj.state,
+      creator: new PublicKey(obj.creator),
+      nft: new PublicKey(obj.nft),
+      random: obj.random,
+      data: Uint8Array.from(obj.data),
+    })
+  }
+}

package/src/types/accounts/SecureHolder.ts

@@ -0,0 +1,97 @@
+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 SecureHolderFields {
+  class: types.AccountClassKind
+  payload: types.EncryptedPayloadFields
+}
+
+export interface SecureHolderJSON {
+  class: types.AccountClassJSON
+  payload: types.EncryptedPayloadJSON
+}
+
+export class SecureHolder {
+  readonly class: types.AccountClassKind
+  readonly payload: types.EncryptedPayload
+
+  static readonly discriminator = Buffer.from([
+    103, 104, 14, 27, 41, 183, 120, 21,
+  ])
+
+  static readonly layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    types.EncryptedPayload.layout("payload"),
+  ])
+
+  constructor(fields: SecureHolderFields) {
+    this.class = fields.class
+    this.payload = new types.EncryptedPayload({ ...fields.payload })
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<SecureHolder | 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<SecureHolder | 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): SecureHolder {
+    if (!data.slice(0, 8).equals(SecureHolder.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = SecureHolder.layout.decode(data.slice(8))
+
+    return new SecureHolder({
+      class: types.AccountClass.fromDecoded(dec.class),
+      payload: types.EncryptedPayload.fromDecoded(dec.payload),
+    })
+  }
+
+  toJSON(): SecureHolderJSON {
+    return {
+      class: this.class.toJSON(),
+      payload: this.payload.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: SecureHolderJSON): SecureHolder {
+    return new SecureHolder({
+      class: types.AccountClass.fromJSON(obj.class),
+      payload: types.EncryptedPayload.fromJSON(obj.payload),
+    })
+  }
+}

package/src/types/accounts/Single.ts

@@ -0,0 +1,301 @@
+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 SingleFields {
+  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
+  track: types.ItemTrackFields
+  popularity: types.PopularityFields
+  filtering: types.FilterFields
+  page: BN
+  manager: PublicKey
+  isServerless: number
+  availableOption: number
+  hasWrappedTokens: number
+  burntPieces: number
+  flag: Array<number>
+  item: types.ItemFields
+  saleConfig: types.SaleConfigFields
+  identifier: BN
+  hash: BN
+  hashTraits: BN
+  volume: Array<types.FakeVolumeTrackFields>
+  extra: Array<number>
+}
+
+export interface SingleJSON {
+  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
+  track: types.ItemTrackJSON
+  popularity: types.PopularityJSON
+  filtering: types.FilterJSON
+  page: string
+  manager: string
+  isServerless: number
+  availableOption: number
+  hasWrappedTokens: number
+  burntPieces: number
+  flag: Array<number>
+  item: types.ItemJSON
+  saleConfig: types.SaleConfigJSON
+  identifier: string
+  hash: string
+  hashTraits: string
+  volume: Array<types.FakeVolumeTrackJSON>
+  extra: Array<number>
+}
+
+export class Single {
+  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 track: types.ItemTrack
+  readonly popularity: types.Popularity
+  readonly filtering: types.Filter
+  readonly page: BN
+  readonly manager: PublicKey
+  readonly isServerless: number
+  readonly availableOption: number
+  readonly hasWrappedTokens: number
+  readonly burntPieces: number
+  readonly flag: Array<number>
+  readonly item: types.Item
+  readonly saleConfig: types.SaleConfig
+  readonly identifier: BN
+  readonly hash: BN
+  readonly hashTraits: BN
+  readonly volume: Array<types.FakeVolumeTrack>
+  readonly extra: Array<number>
+
+  static readonly discriminator = Buffer.from([23, 154, 0, 26, 73, 227, 49, 70])
+
+  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.ItemTrack.layout("track"),
+    types.Popularity.layout("popularity"),
+    types.Filter.layout("filtering"),
+    borsh.u64("page"),
+    borsh.publicKey("manager"),
+    borsh.u8("isServerless"),
+    borsh.u8("availableOption"),
+    borsh.u8("hasWrappedTokens"),
+    borsh.u32("burntPieces"),
+    borsh.array(borsh.u8(), 1, "flag"),
+    types.Item.layout("item"),
+    types.SaleConfig.layout("saleConfig"),
+    borsh.u64("identifier"),
+    borsh.u64("hash"),
+    borsh.u64("hashTraits"),
+    borsh.vec(types.FakeVolumeTrack.layout(), "volume"),
+    borsh.array(borsh.u8(), 4, "extra"),
+  ])
+
+  constructor(fields: SingleFields) {
+    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.track = new types.ItemTrack({ ...fields.track })
+    this.popularity = new types.Popularity({ ...fields.popularity })
+    this.filtering = new types.Filter({ ...fields.filtering })
+    this.page = fields.page
+    this.manager = fields.manager
+    this.isServerless = fields.isServerless
+    this.availableOption = fields.availableOption
+    this.hasWrappedTokens = fields.hasWrappedTokens
+    this.burntPieces = fields.burntPieces
+    this.flag = fields.flag
+    this.item = new types.Item({ ...fields.item })
+    this.saleConfig = new types.SaleConfig({ ...fields.saleConfig })
+    this.identifier = fields.identifier
+    this.hash = fields.hash
+    this.hashTraits = fields.hashTraits
+    this.volume = fields.volume.map(
+      (item) => new types.FakeVolumeTrack({ ...item })
+    )
+    this.extra = fields.extra
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Single | 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<Single | 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): Single {
+    if (!data.slice(0, 8).equals(Single.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = Single.layout.decode(data.slice(8))
+
+    return new Single({
+      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,
+      track: types.ItemTrack.fromDecoded(dec.track),
+      popularity: types.Popularity.fromDecoded(dec.popularity),
+      filtering: types.Filter.fromDecoded(dec.filtering),
+      page: dec.page,
+      manager: dec.manager,
+      isServerless: dec.isServerless,
+      availableOption: dec.availableOption,
+      hasWrappedTokens: dec.hasWrappedTokens,
+      burntPieces: dec.burntPieces,
+      flag: dec.flag,
+      item: types.Item.fromDecoded(dec.item),
+      saleConfig: types.SaleConfig.fromDecoded(dec.saleConfig),
+      identifier: dec.identifier,
+      hash: dec.hash,
+      hashTraits: dec.hashTraits,
+      volume: dec.volume.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.FakeVolumeTrack.fromDecoded(item)
+      ),
+      extra: dec.extra,
+    })
+  }
+
+  toJSON(): SingleJSON {
+    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(),
+      track: this.track.toJSON(),
+      popularity: this.popularity.toJSON(),
+      filtering: this.filtering.toJSON(),
+      page: this.page.toString(),
+      manager: this.manager.toString(),
+      isServerless: this.isServerless,
+      availableOption: this.availableOption,
+      hasWrappedTokens: this.hasWrappedTokens,
+      burntPieces: this.burntPieces,
+      flag: this.flag,
+      item: this.item.toJSON(),
+      saleConfig: this.saleConfig.toJSON(),
+      identifier: this.identifier.toString(),
+      hash: this.hash.toString(),
+      hashTraits: this.hashTraits.toString(),
+      volume: this.volume.map((item) => item.toJSON()),
+      extra: this.extra,
+    }
+  }
+
+  static fromJSON(obj: SingleJSON): Single {
+    return new Single({
+      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),
+      track: types.ItemTrack.fromJSON(obj.track),
+      popularity: types.Popularity.fromJSON(obj.popularity),
+      filtering: types.Filter.fromJSON(obj.filtering),
+      page: new BN(obj.page),
+      manager: new PublicKey(obj.manager),
+      isServerless: obj.isServerless,
+      availableOption: obj.availableOption,
+      hasWrappedTokens: obj.hasWrappedTokens,
+      burntPieces: obj.burntPieces,
+      flag: obj.flag,
+      item: types.Item.fromJSON(obj.item),
+      saleConfig: types.SaleConfig.fromJSON(obj.saleConfig),
+      identifier: new BN(obj.identifier),
+      hash: new BN(obj.hash),
+      hashTraits: new BN(obj.hashTraits),
+      volume: obj.volume.map((item) => types.FakeVolumeTrack.fromJSON(item)),
+      extra: obj.extra,
+    })
+  }
+}