3land_sdk 1.0.0

package/src/types/accounts/ZeroCard.ts

@@ -0,0 +1,73 @@
+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 ZeroCardFields {}
+
+export interface ZeroCardJSON {}
+
+export class ZeroCard {
+  static readonly discriminator = Buffer.from([
+    31, 109, 105, 105, 213, 228, 142, 232,
+  ])
+
+  static readonly layout = borsh.struct([])
+
+  constructor(fields: ZeroCardFields) {}
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<ZeroCard | 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<ZeroCard | 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): ZeroCard {
+    if (!data.slice(0, 8).equals(ZeroCard.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = ZeroCard.layout.decode(data.slice(8))
+
+    return new ZeroCard({})
+  }
+
+  toJSON(): ZeroCardJSON {
+    return {}
+  }
+
+  static fromJSON(obj: ZeroCardJSON): ZeroCard {
+    return new ZeroCard({})
+  }
+}

package/src/types/accounts/ZeroContent.ts

@@ -0,0 +1,89 @@
+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 ZeroContentFields {
+  cards: Array<number>
+}
+
+export interface ZeroContentJSON {
+  cards: Array<number>
+}
+
+export class ZeroContent {
+  readonly cards: Array<number>
+
+  static readonly discriminator = Buffer.from([
+    60, 71, 181, 209, 154, 77, 4, 225,
+  ])
+
+  static readonly layout = borsh.struct([
+    borsh.array(borsh.u8(), 10000000, "cards"),
+  ])
+
+  constructor(fields: ZeroContentFields) {
+    this.cards = fields.cards
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<ZeroContent | 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<ZeroContent | 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): ZeroContent {
+    if (!data.slice(0, 8).equals(ZeroContent.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = ZeroContent.layout.decode(data.slice(8))
+
+    return new ZeroContent({
+      cards: dec.cards,
+    })
+  }
+
+  toJSON(): ZeroContentJSON {
+    return {
+      cards: this.cards,
+    }
+  }
+
+  static fromJSON(obj: ZeroContentJSON): ZeroContent {
+    return new ZeroContent({
+      cards: obj.cards,
+    })
+  }
+}

package/src/types/accounts/ZeroOpenHolder.ts

@@ -0,0 +1,183 @@
+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 ZeroOpenHolderFields {
+  class: types.AccountClassKind
+  storeHalfHash: Array<number>
+  state: types.PackOpenHolderStateKind
+  paidFee: number
+  pack: PublicKey
+  creator: PublicKey
+  claimer: PublicKey
+  randomBase: BN
+  packType: types.PackTypeKind
+  sendToVault: types.MemeVaultProofFields | null
+  items: Array<types.SelectedZeroCardFields>
+}
+
+export interface ZeroOpenHolderJSON {
+  class: types.AccountClassJSON
+  storeHalfHash: Array<number>
+  state: types.PackOpenHolderStateJSON
+  paidFee: number
+  pack: string
+  creator: string
+  claimer: string
+  randomBase: string
+  packType: types.PackTypeJSON
+  sendToVault: types.MemeVaultProofJSON | null
+  items: Array<types.SelectedZeroCardJSON>
+}
+
+export class ZeroOpenHolder {
+  readonly class: types.AccountClassKind
+  readonly storeHalfHash: Array<number>
+  readonly state: types.PackOpenHolderStateKind
+  readonly paidFee: number
+  readonly pack: PublicKey
+  readonly creator: PublicKey
+  readonly claimer: PublicKey
+  readonly randomBase: BN
+  readonly packType: types.PackTypeKind
+  readonly sendToVault: types.MemeVaultProof | null
+  readonly items: Array<types.SelectedZeroCard>
+
+  static readonly discriminator = Buffer.from([
+    106, 194, 12, 193, 165, 210, 56, 2,
+  ])
+
+  static readonly layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    borsh.array(borsh.u8(), 4, "storeHalfHash"),
+    types.PackOpenHolderState.layout("state"),
+    borsh.u8("paidFee"),
+    borsh.publicKey("pack"),
+    borsh.publicKey("creator"),
+    borsh.publicKey("claimer"),
+    borsh.u64("randomBase"),
+    types.PackType.layout("packType"),
+    borsh.option(types.MemeVaultProof.layout(), "sendToVault"),
+    borsh.vec(types.SelectedZeroCard.layout(), "items"),
+  ])
+
+  constructor(fields: ZeroOpenHolderFields) {
+    this.class = fields.class
+    this.storeHalfHash = fields.storeHalfHash
+    this.state = fields.state
+    this.paidFee = fields.paidFee
+    this.pack = fields.pack
+    this.creator = fields.creator
+    this.claimer = fields.claimer
+    this.randomBase = fields.randomBase
+    this.packType = fields.packType
+    this.sendToVault =
+      (fields.sendToVault &&
+        new types.MemeVaultProof({ ...fields.sendToVault })) ||
+      null
+    this.items = fields.items.map(
+      (item) => new types.SelectedZeroCard({ ...item })
+    )
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<ZeroOpenHolder | 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<ZeroOpenHolder | 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): ZeroOpenHolder {
+    if (!data.slice(0, 8).equals(ZeroOpenHolder.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = ZeroOpenHolder.layout.decode(data.slice(8))
+
+    return new ZeroOpenHolder({
+      class: types.AccountClass.fromDecoded(dec.class),
+      storeHalfHash: dec.storeHalfHash,
+      state: types.PackOpenHolderState.fromDecoded(dec.state),
+      paidFee: dec.paidFee,
+      pack: dec.pack,
+      creator: dec.creator,
+      claimer: dec.claimer,
+      randomBase: dec.randomBase,
+      packType: types.PackType.fromDecoded(dec.packType),
+      sendToVault:
+        (dec.sendToVault &&
+          types.MemeVaultProof.fromDecoded(dec.sendToVault)) ||
+        null,
+      items: dec.items.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.SelectedZeroCard.fromDecoded(item)
+      ),
+    })
+  }
+
+  toJSON(): ZeroOpenHolderJSON {
+    return {
+      class: this.class.toJSON(),
+      storeHalfHash: this.storeHalfHash,
+      state: this.state.toJSON(),
+      paidFee: this.paidFee,
+      pack: this.pack.toString(),
+      creator: this.creator.toString(),
+      claimer: this.claimer.toString(),
+      randomBase: this.randomBase.toString(),
+      packType: this.packType.toJSON(),
+      sendToVault: (this.sendToVault && this.sendToVault.toJSON()) || null,
+      items: this.items.map((item) => item.toJSON()),
+    }
+  }
+
+  static fromJSON(obj: ZeroOpenHolderJSON): ZeroOpenHolder {
+    return new ZeroOpenHolder({
+      class: types.AccountClass.fromJSON(obj.class),
+      storeHalfHash: obj.storeHalfHash,
+      state: types.PackOpenHolderState.fromJSON(obj.state),
+      paidFee: obj.paidFee,
+      pack: new PublicKey(obj.pack),
+      creator: new PublicKey(obj.creator),
+      claimer: new PublicKey(obj.claimer),
+      randomBase: new BN(obj.randomBase),
+      packType: types.PackType.fromJSON(obj.packType),
+      sendToVault:
+        (obj.sendToVault && types.MemeVaultProof.fromJSON(obj.sendToVault)) ||
+        null,
+      items: obj.items.map((item) => types.SelectedZeroCard.fromJSON(item)),
+    })
+  }
+}

package/src/types/accounts/index.ts

@@ -0,0 +1,84 @@
+export { BuyTrack } from "./BuyTrack"
+export type { BuyTrackFields, BuyTrackJSON } from "./BuyTrack"
+export { BuyHistory } from "./BuyHistory"
+export type { BuyHistoryFields, BuyHistoryJSON } from "./BuyHistory"
+export { ZeroOpenHolder } from "./ZeroOpenHolder"
+export type { ZeroOpenHolderFields, ZeroOpenHolderJSON } from "./ZeroOpenHolder"
+export { PackOpenHolder } from "./PackOpenHolder"
+export type { PackOpenHolderFields, PackOpenHolderJSON } from "./PackOpenHolder"
+export { ArchiveDeposit } from "./ArchiveDeposit"
+export type { ArchiveDepositFields, ArchiveDepositJSON } from "./ArchiveDeposit"
+export { CollectorRegistry } from "./CollectorRegistry"
+export type {
+  CollectorRegistryFields,
+  CollectorRegistryJSON,
+} from "./CollectorRegistry"
+export { LutVault } from "./LutVault"
+export type { LutVaultFields, LutVaultJSON } from "./LutVault"
+export { TokenManager } from "./TokenManager"
+export type { TokenManagerFields, TokenManagerJSON } from "./TokenManager"
+export { CreatorRegistry } from "./CreatorRegistry"
+export type {
+  CreatorRegistryFields,
+  CreatorRegistryJSON,
+} from "./CreatorRegistry"
+export { CollectionRegistry } from "./CollectionRegistry"
+export type {
+  CollectionRegistryFields,
+  CollectionRegistryJSON,
+} from "./CollectionRegistry"
+export { PoolVault } from "./PoolVault"
+export type { PoolVaultFields, PoolVaultJSON } from "./PoolVault"
+export { Store } from "./Store"
+export type { StoreFields, StoreJSON } from "./Store"
+export { CurrencyArtistProof } from "./CurrencyArtistProof"
+export type {
+  CurrencyArtistProofFields,
+  CurrencyArtistProofJSON,
+} from "./CurrencyArtistProof"
+export { Payment } from "./Payment"
+export type { PaymentFields, PaymentJSON } from "./Payment"
+export { RevealForMe } from "./RevealForMe"
+export type { RevealForMeFields, RevealForMeJSON } from "./RevealForMe"
+export { BurnDeposit } from "./BurnDeposit"
+export type { BurnDepositFields, BurnDepositJSON } from "./BurnDeposit"
+export { BurnProgress } from "./BurnProgress"
+export type { BurnProgressFields, BurnProgressJSON } from "./BurnProgress"
+export { ItemReserveList } from "./ItemReserveList"
+export type {
+  ItemReserveListFields,
+  ItemReserveListJSON,
+} from "./ItemReserveList"
+export { ItemReserveList2 } from "./ItemReserveList2"
+export type {
+  ItemReserveList2Fields,
+  ItemReserveList2JSON,
+} from "./ItemReserveList2"
+export { PackTraits } from "./PackTraits"
+export type { PackTraitsFields, PackTraitsJSON } from "./PackTraits"
+export { PackReceipt } from "./PackReceipt"
+export type { PackReceiptFields, PackReceiptJSON } from "./PackReceipt"
+export { ZeroContent } from "./ZeroContent"
+export type { ZeroContentFields, ZeroContentJSON } from "./ZeroContent"
+export { PackContent } from "./PackContent"
+export type { PackContentFields, PackContentJSON } from "./PackContent"
+export { ZeroCard } from "./ZeroCard"
+export type { ZeroCardFields, ZeroCardJSON } from "./ZeroCard"
+export { Authority } from "./Authority"
+export type { AuthorityFields, AuthorityJSON } from "./Authority"
+export { Card } from "./Card"
+export type { CardFields, CardJSON } from "./Card"
+export { ItemArchive } from "./ItemArchive"
+export type { ItemArchiveFields, ItemArchiveJSON } from "./ItemArchive"
+export { SecureHolder } from "./SecureHolder"
+export type { SecureHolderFields, SecureHolderJSON } from "./SecureHolder"
+export { Single } from "./Single"
+export type { SingleFields, SingleJSON } from "./Single"
+export { Pack } from "./Pack"
+export type { PackFields, PackJSON } from "./Pack"
+export { GenericUser } from "./GenericUser"
+export type { GenericUserFields, GenericUserJSON } from "./GenericUser"
+export { ThreeId } from "./ThreeId"
+export type { ThreeIdFields, ThreeIdJSON } from "./ThreeId"
+export { StoresHolder } from "./StoresHolder"
+export type { StoresHolderFields, StoresHolderJSON } from "./StoresHolder"