3land_sdk 1.0.0

package/src/types/accounts/Store.ts

@@ -0,0 +1,180 @@
+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 StoreFields {
+  class: types.AccountClassKind
+  holder: PublicKey
+  creator: PublicKey
+  page: BN
+  count: BN
+  live: BN
+  name: string
+  config: types.StoreConfigFields
+  storeId: number
+  globalFee: types.GlobalFeeFields | null
+  globalDeposit: BN
+  cacheHolder: Array<number>
+}
+
+export interface StoreJSON {
+  class: types.AccountClassJSON
+  holder: string
+  creator: string
+  page: string
+  count: string
+  live: string
+  name: string
+  config: types.StoreConfigJSON
+  storeId: number
+  globalFee: types.GlobalFeeJSON | null
+  globalDeposit: string
+  cacheHolder: Array<number>
+}
+
+export class Store {
+  readonly class: types.AccountClassKind
+  readonly holder: PublicKey
+  readonly creator: PublicKey
+  readonly page: BN
+  readonly count: BN
+  readonly live: BN
+  readonly name: string
+  readonly config: types.StoreConfig
+  readonly storeId: number
+  readonly globalFee: types.GlobalFee | null
+  readonly globalDeposit: BN
+  readonly cacheHolder: Array<number>
+
+  static readonly discriminator = Buffer.from([
+    130, 48, 247, 244, 182, 191, 30, 26,
+  ])
+
+  static readonly layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    borsh.publicKey("holder"),
+    borsh.publicKey("creator"),
+    borsh.u64("page"),
+    borsh.u64("count"),
+    borsh.u64("live"),
+    borsh.str("name"),
+    types.StoreConfig.layout("config"),
+    borsh.u16("storeId"),
+    borsh.option(types.GlobalFee.layout(), "globalFee"),
+    borsh.u64("globalDeposit"),
+    borsh.array(borsh.u8(), 128, "cacheHolder"),
+  ])
+
+  constructor(fields: StoreFields) {
+    this.class = fields.class
+    this.holder = fields.holder
+    this.creator = fields.creator
+    this.page = fields.page
+    this.count = fields.count
+    this.live = fields.live
+    this.name = fields.name
+    this.config = new types.StoreConfig({ ...fields.config })
+    this.storeId = fields.storeId
+    this.globalFee =
+      (fields.globalFee && new types.GlobalFee({ ...fields.globalFee })) || null
+    this.globalDeposit = fields.globalDeposit
+    this.cacheHolder = fields.cacheHolder
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Store | 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<Store | 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): Store {
+    if (!data.slice(0, 8).equals(Store.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = Store.layout.decode(data.slice(8))
+
+    return new Store({
+      class: types.AccountClass.fromDecoded(dec.class),
+      holder: dec.holder,
+      creator: dec.creator,
+      page: dec.page,
+      count: dec.count,
+      live: dec.live,
+      name: dec.name,
+      config: types.StoreConfig.fromDecoded(dec.config),
+      storeId: dec.storeId,
+      globalFee:
+        (dec.globalFee && types.GlobalFee.fromDecoded(dec.globalFee)) || null,
+      globalDeposit: dec.globalDeposit,
+      cacheHolder: dec.cacheHolder,
+    })
+  }
+
+  toJSON(): StoreJSON {
+    return {
+      class: this.class.toJSON(),
+      holder: this.holder.toString(),
+      creator: this.creator.toString(),
+      page: this.page.toString(),
+      count: this.count.toString(),
+      live: this.live.toString(),
+      name: this.name,
+      config: this.config.toJSON(),
+      storeId: this.storeId,
+      globalFee: (this.globalFee && this.globalFee.toJSON()) || null,
+      globalDeposit: this.globalDeposit.toString(),
+      cacheHolder: this.cacheHolder,
+    }
+  }
+
+  static fromJSON(obj: StoreJSON): Store {
+    return new Store({
+      class: types.AccountClass.fromJSON(obj.class),
+      holder: new PublicKey(obj.holder),
+      creator: new PublicKey(obj.creator),
+      page: new BN(obj.page),
+      count: new BN(obj.count),
+      live: new BN(obj.live),
+      name: obj.name,
+      config: types.StoreConfig.fromJSON(obj.config),
+      storeId: obj.storeId,
+      globalFee:
+        (obj.globalFee && types.GlobalFee.fromJSON(obj.globalFee)) || null,
+      globalDeposit: new BN(obj.globalDeposit),
+      cacheHolder: obj.cacheHolder,
+    })
+  }
+}

package/src/types/accounts/StoresHolder.ts

@@ -0,0 +1,131 @@
+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 StoresHolderFields {
+  class: types.AccountClassKind
+  slot: BN
+  creator: PublicKey
+  count: BN
+  defaultGlobalFee: types.GlobalFeeFields | null
+}
+
+export interface StoresHolderJSON {
+  class: types.AccountClassJSON
+  slot: string
+  creator: string
+  count: string
+  defaultGlobalFee: types.GlobalFeeJSON | null
+}
+
+export class StoresHolder {
+  readonly class: types.AccountClassKind
+  readonly slot: BN
+  readonly creator: PublicKey
+  readonly count: BN
+  readonly defaultGlobalFee: types.GlobalFee | null
+
+  static readonly discriminator = Buffer.from([
+    237, 16, 131, 248, 150, 182, 165, 234,
+  ])
+
+  static readonly layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    borsh.u64("slot"),
+    borsh.publicKey("creator"),
+    borsh.u64("count"),
+    borsh.option(types.GlobalFee.layout(), "defaultGlobalFee"),
+  ])
+
+  constructor(fields: StoresHolderFields) {
+    this.class = fields.class
+    this.slot = fields.slot
+    this.creator = fields.creator
+    this.count = fields.count
+    this.defaultGlobalFee =
+      (fields.defaultGlobalFee &&
+        new types.GlobalFee({ ...fields.defaultGlobalFee })) ||
+      null
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<StoresHolder | 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<StoresHolder | 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): StoresHolder {
+    if (!data.slice(0, 8).equals(StoresHolder.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = StoresHolder.layout.decode(data.slice(8))
+
+    return new StoresHolder({
+      class: types.AccountClass.fromDecoded(dec.class),
+      slot: dec.slot,
+      creator: dec.creator,
+      count: dec.count,
+      defaultGlobalFee:
+        (dec.defaultGlobalFee &&
+          types.GlobalFee.fromDecoded(dec.defaultGlobalFee)) ||
+        null,
+    })
+  }
+
+  toJSON(): StoresHolderJSON {
+    return {
+      class: this.class.toJSON(),
+      slot: this.slot.toString(),
+      creator: this.creator.toString(),
+      count: this.count.toString(),
+      defaultGlobalFee:
+        (this.defaultGlobalFee && this.defaultGlobalFee.toJSON()) || null,
+    }
+  }
+
+  static fromJSON(obj: StoresHolderJSON): StoresHolder {
+    return new StoresHolder({
+      class: types.AccountClass.fromJSON(obj.class),
+      slot: new BN(obj.slot),
+      creator: new PublicKey(obj.creator),
+      count: new BN(obj.count),
+      defaultGlobalFee:
+        (obj.defaultGlobalFee &&
+          types.GlobalFee.fromJSON(obj.defaultGlobalFee)) ||
+        null,
+    })
+  }
+}

package/src/types/accounts/ThreeId.ts

@@ -0,0 +1,189 @@
+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 ThreeIdFields {
+  class: types.AccountClassKind
+  holderHash: BN
+  creator: PublicKey
+  lutAccount: PublicKey
+  points1: BN
+  points2: BN
+  coin1: number
+  coin2: number
+  settings: Array<number>
+  subwallets: Array<PublicKey>
+  username: string
+  generalStore: Array<types.GeneralStoreKind>
+  extra: Array<number>
+}
+
+export interface ThreeIdJSON {
+  class: types.AccountClassJSON
+  holderHash: string
+  creator: string
+  lutAccount: string
+  points1: string
+  points2: string
+  coin1: number
+  coin2: number
+  settings: Array<number>
+  subwallets: Array<string>
+  username: string
+  generalStore: Array<types.GeneralStoreJSON>
+  extra: Array<number>
+}
+
+export class ThreeId {
+  readonly class: types.AccountClassKind
+  readonly holderHash: BN
+  readonly creator: PublicKey
+  readonly lutAccount: PublicKey
+  readonly points1: BN
+  readonly points2: BN
+  readonly coin1: number
+  readonly coin2: number
+  readonly settings: Array<number>
+  readonly subwallets: Array<PublicKey>
+  readonly username: string
+  readonly generalStore: Array<types.GeneralStoreKind>
+  readonly extra: Array<number>
+
+  static readonly discriminator = Buffer.from([123, 56, 150, 21, 8, 4, 144, 81])
+
+  static readonly layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    borsh.u64("holderHash"),
+    borsh.publicKey("creator"),
+    borsh.publicKey("lutAccount"),
+    borsh.u64("points1"),
+    borsh.u64("points2"),
+    borsh.u32("coin1"),
+    borsh.u32("coin2"),
+    borsh.array(borsh.u8(), 8, "settings"),
+    borsh.vec(borsh.publicKey(), "subwallets"),
+    borsh.str("username"),
+    borsh.vec(types.GeneralStore.layout(), "generalStore"),
+    borsh.array(borsh.u8(), 32, "extra"),
+  ])
+
+  constructor(fields: ThreeIdFields) {
+    this.class = fields.class
+    this.holderHash = fields.holderHash
+    this.creator = fields.creator
+    this.lutAccount = fields.lutAccount
+    this.points1 = fields.points1
+    this.points2 = fields.points2
+    this.coin1 = fields.coin1
+    this.coin2 = fields.coin2
+    this.settings = fields.settings
+    this.subwallets = fields.subwallets
+    this.username = fields.username
+    this.generalStore = fields.generalStore
+    this.extra = fields.extra
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<ThreeId | 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<ThreeId | 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): ThreeId {
+    if (!data.slice(0, 8).equals(ThreeId.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = ThreeId.layout.decode(data.slice(8))
+
+    return new ThreeId({
+      class: types.AccountClass.fromDecoded(dec.class),
+      holderHash: dec.holderHash,
+      creator: dec.creator,
+      lutAccount: dec.lutAccount,
+      points1: dec.points1,
+      points2: dec.points2,
+      coin1: dec.coin1,
+      coin2: dec.coin2,
+      settings: dec.settings,
+      subwallets: dec.subwallets,
+      username: dec.username,
+      generalStore: dec.generalStore.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.GeneralStore.fromDecoded(item)
+      ),
+      extra: dec.extra,
+    })
+  }
+
+  toJSON(): ThreeIdJSON {
+    return {
+      class: this.class.toJSON(),
+      holderHash: this.holderHash.toString(),
+      creator: this.creator.toString(),
+      lutAccount: this.lutAccount.toString(),
+      points1: this.points1.toString(),
+      points2: this.points2.toString(),
+      coin1: this.coin1,
+      coin2: this.coin2,
+      settings: this.settings,
+      subwallets: this.subwallets.map((item) => item.toString()),
+      username: this.username,
+      generalStore: this.generalStore.map((item) => item.toJSON()),
+      extra: this.extra,
+    }
+  }
+
+  static fromJSON(obj: ThreeIdJSON): ThreeId {
+    return new ThreeId({
+      class: types.AccountClass.fromJSON(obj.class),
+      holderHash: new BN(obj.holderHash),
+      creator: new PublicKey(obj.creator),
+      lutAccount: new PublicKey(obj.lutAccount),
+      points1: new BN(obj.points1),
+      points2: new BN(obj.points2),
+      coin1: obj.coin1,
+      coin2: obj.coin2,
+      settings: obj.settings,
+      subwallets: obj.subwallets.map((item) => new PublicKey(item)),
+      username: obj.username,
+      generalStore: obj.generalStore.map((item) =>
+        types.GeneralStore.fromJSON(item)
+      ),
+      extra: obj.extra,
+    })
+  }
+}

package/src/types/accounts/TokenManager.ts

@@ -0,0 +1,217 @@
+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 TokenManagerFields {
+  class: types.AccountClassKind
+  storeHash: BN
+  tokenType: types.TokenTypeKind
+  state: types.TokenStateKind
+  currency: PublicKey
+  creator: PublicKey
+  communityShare: number
+  name: string
+  base: BN
+  price: BN
+  supply: BN
+  created: BN
+  pool: BN
+  pending: BN
+  taxes: Array<number>
+  options: Array<number>
+  extra: Array<number>
+}
+
+export interface TokenManagerJSON {
+  class: types.AccountClassJSON
+  storeHash: string
+  tokenType: types.TokenTypeJSON
+  state: types.TokenStateJSON
+  currency: string
+  creator: string
+  communityShare: number
+  name: string
+  base: string
+  price: string
+  supply: string
+  created: string
+  pool: string
+  pending: string
+  taxes: Array<number>
+  options: Array<number>
+  extra: Array<number>
+}
+
+export class TokenManager {
+  readonly class: types.AccountClassKind
+  readonly storeHash: BN
+  readonly tokenType: types.TokenTypeKind
+  readonly state: types.TokenStateKind
+  readonly currency: PublicKey
+  readonly creator: PublicKey
+  readonly communityShare: number
+  readonly name: string
+  readonly base: BN
+  readonly price: BN
+  readonly supply: BN
+  readonly created: BN
+  readonly pool: BN
+  readonly pending: BN
+  readonly taxes: Array<number>
+  readonly options: Array<number>
+  readonly extra: Array<number>
+
+  static readonly discriminator = Buffer.from([
+    185, 97, 124, 231, 70, 75, 228, 47,
+  ])
+
+  static readonly layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    borsh.u64("storeHash"),
+    types.TokenType.layout("tokenType"),
+    types.TokenState.layout("state"),
+    borsh.publicKey("currency"),
+    borsh.publicKey("creator"),
+    borsh.u16("communityShare"),
+    borsh.str("name"),
+    borsh.u64("base"),
+    borsh.u64("price"),
+    borsh.u64("supply"),
+    borsh.u64("created"),
+    borsh.u64("pool"),
+    borsh.u64("pending"),
+    borsh.array(borsh.u16(), 4, "taxes"),
+    borsh.array(borsh.u8(), 8, "options"),
+    borsh.array(borsh.u8(), 64, "extra"),
+  ])
+
+  constructor(fields: TokenManagerFields) {
+    this.class = fields.class
+    this.storeHash = fields.storeHash
+    this.tokenType = fields.tokenType
+    this.state = fields.state
+    this.currency = fields.currency
+    this.creator = fields.creator
+    this.communityShare = fields.communityShare
+    this.name = fields.name
+    this.base = fields.base
+    this.price = fields.price
+    this.supply = fields.supply
+    this.created = fields.created
+    this.pool = fields.pool
+    this.pending = fields.pending
+    this.taxes = fields.taxes
+    this.options = fields.options
+    this.extra = fields.extra
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<TokenManager | 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<TokenManager | 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): TokenManager {
+    if (!data.slice(0, 8).equals(TokenManager.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = TokenManager.layout.decode(data.slice(8))
+
+    return new TokenManager({
+      class: types.AccountClass.fromDecoded(dec.class),
+      storeHash: dec.storeHash,
+      tokenType: types.TokenType.fromDecoded(dec.tokenType),
+      state: types.TokenState.fromDecoded(dec.state),
+      currency: dec.currency,
+      creator: dec.creator,
+      communityShare: dec.communityShare,
+      name: dec.name,
+      base: dec.base,
+      price: dec.price,
+      supply: dec.supply,
+      created: dec.created,
+      pool: dec.pool,
+      pending: dec.pending,
+      taxes: dec.taxes,
+      options: dec.options,
+      extra: dec.extra,
+    })
+  }
+
+  toJSON(): TokenManagerJSON {
+    return {
+      class: this.class.toJSON(),
+      storeHash: this.storeHash.toString(),
+      tokenType: this.tokenType.toJSON(),
+      state: this.state.toJSON(),
+      currency: this.currency.toString(),
+      creator: this.creator.toString(),
+      communityShare: this.communityShare,
+      name: this.name,
+      base: this.base.toString(),
+      price: this.price.toString(),
+      supply: this.supply.toString(),
+      created: this.created.toString(),
+      pool: this.pool.toString(),
+      pending: this.pending.toString(),
+      taxes: this.taxes,
+      options: this.options,
+      extra: this.extra,
+    }
+  }
+
+  static fromJSON(obj: TokenManagerJSON): TokenManager {
+    return new TokenManager({
+      class: types.AccountClass.fromJSON(obj.class),
+      storeHash: new BN(obj.storeHash),
+      tokenType: types.TokenType.fromJSON(obj.tokenType),
+      state: types.TokenState.fromJSON(obj.state),
+      currency: new PublicKey(obj.currency),
+      creator: new PublicKey(obj.creator),
+      communityShare: obj.communityShare,
+      name: obj.name,
+      base: new BN(obj.base),
+      price: new BN(obj.price),
+      supply: new BN(obj.supply),
+      created: new BN(obj.created),
+      pool: new BN(obj.pool),
+      pending: new BN(obj.pending),
+      taxes: obj.taxes,
+      options: obj.options,
+      extra: obj.extra,
+    })
+  }
+}