3land_sdk 1.0.0

package/src/types/types/ListingPerWalletArgs.ts

@@ -0,0 +1,53 @@
+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 ListingPerWalletArgsFields {
+  amount: number
+}
+
+export interface ListingPerWalletArgsJSON {
+  amount: number
+}
+
+export class ListingPerWalletArgs {
+  readonly amount: number
+
+  constructor(fields: ListingPerWalletArgsFields) {
+    this.amount = fields.amount
+  }
+
+  static layout(property?: string) {
+    return borsh.struct([borsh.u16("amount")], property)
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new ListingPerWalletArgs({
+      amount: obj.amount,
+    })
+  }
+
+  static toEncodable(fields: ListingPerWalletArgsFields) {
+    return {
+      amount: fields.amount,
+    }
+  }
+
+  toJSON(): ListingPerWalletArgsJSON {
+    return {
+      amount: this.amount,
+    }
+  }
+
+  static fromJSON(obj: ListingPerWalletArgsJSON): ListingPerWalletArgs {
+    return new ListingPerWalletArgs({
+      amount: obj.amount,
+    })
+  }
+
+  toEncodable() {
+    return ListingPerWalletArgs.toEncodable(this)
+  }
+}

package/src/types/types/MemeVaultProof.ts

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

package/src/types/types/MetadataArgs.ts

@@ -0,0 +1,207 @@
+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 MetadataArgsFields {
+  /** The name of the asset */
+  name: string
+  /** The symbol for the asset */
+  symbol: string
+  /** URI pointing to JSON representing the asset */
+  uri: string
+  /** Royalty basis points that goes to creators in secondary sales (0-10000) */
+  sellerFeeBasisPoints: number
+  primarySaleHappened: boolean
+  isMutable: boolean
+  /** nonce for easy calculation of editions, if present */
+  editionNonce: number | null
+  /** Since we cannot easily change Metadata, we add the new DataV2 fields here at the end. */
+  tokenStandard: types.TokenStandardKind | null
+  /** Collection */
+  collection: types.CollectionFields | null
+  /** Uses */
+  uses: types.UsesFields | null
+  tokenProgramVersion: types.TokenProgramVersionKind
+  creators: Array<types.CreatorFields>
+}
+
+export interface MetadataArgsJSON {
+  /** The name of the asset */
+  name: string
+  /** The symbol for the asset */
+  symbol: string
+  /** URI pointing to JSON representing the asset */
+  uri: string
+  /** Royalty basis points that goes to creators in secondary sales (0-10000) */
+  sellerFeeBasisPoints: number
+  primarySaleHappened: boolean
+  isMutable: boolean
+  /** nonce for easy calculation of editions, if present */
+  editionNonce: number | null
+  /** Since we cannot easily change Metadata, we add the new DataV2 fields here at the end. */
+  tokenStandard: types.TokenStandardJSON | null
+  /** Collection */
+  collection: types.CollectionJSON | null
+  /** Uses */
+  uses: types.UsesJSON | null
+  tokenProgramVersion: types.TokenProgramVersionJSON
+  creators: Array<types.CreatorJSON>
+}
+
+export class MetadataArgs {
+  /** The name of the asset */
+  readonly name: string
+  /** The symbol for the asset */
+  readonly symbol: string
+  /** URI pointing to JSON representing the asset */
+  readonly uri: string
+  /** Royalty basis points that goes to creators in secondary sales (0-10000) */
+  readonly sellerFeeBasisPoints: number
+  readonly primarySaleHappened: boolean
+  readonly isMutable: boolean
+  /** nonce for easy calculation of editions, if present */
+  readonly editionNonce: number | null
+  /** Since we cannot easily change Metadata, we add the new DataV2 fields here at the end. */
+  readonly tokenStandard: types.TokenStandardKind | null
+  /** Collection */
+  readonly collection: types.Collection | null
+  /** Uses */
+  readonly uses: types.Uses | null
+  readonly tokenProgramVersion: types.TokenProgramVersionKind
+  readonly creators: Array<types.Creator>
+
+  constructor(fields: MetadataArgsFields) {
+    this.name = fields.name
+    this.symbol = fields.symbol
+    this.uri = fields.uri
+    this.sellerFeeBasisPoints = fields.sellerFeeBasisPoints
+    this.primarySaleHappened = fields.primarySaleHappened
+    this.isMutable = fields.isMutable
+    this.editionNonce = fields.editionNonce
+    this.tokenStandard = fields.tokenStandard
+    this.collection =
+      (fields.collection && new types.Collection({ ...fields.collection })) ||
+      null
+    this.uses = (fields.uses && new types.Uses({ ...fields.uses })) || null
+    this.tokenProgramVersion = fields.tokenProgramVersion
+    this.creators = fields.creators.map(
+      (item) => new types.Creator({ ...item })
+    )
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.str("name"),
+        borsh.str("symbol"),
+        borsh.str("uri"),
+        borsh.u16("sellerFeeBasisPoints"),
+        borsh.bool("primarySaleHappened"),
+        borsh.bool("isMutable"),
+        borsh.option(borsh.u8(), "editionNonce"),
+        borsh.option(types.TokenStandard.layout(), "tokenStandard"),
+        borsh.option(types.Collection.layout(), "collection"),
+        borsh.option(types.Uses.layout(), "uses"),
+        types.TokenProgramVersion.layout("tokenProgramVersion"),
+        borsh.vec(types.Creator.layout(), "creators"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new MetadataArgs({
+      name: obj.name,
+      symbol: obj.symbol,
+      uri: obj.uri,
+      sellerFeeBasisPoints: obj.sellerFeeBasisPoints,
+      primarySaleHappened: obj.primarySaleHappened,
+      isMutable: obj.isMutable,
+      editionNonce: obj.editionNonce,
+      tokenStandard:
+        (obj.tokenStandard &&
+          types.TokenStandard.fromDecoded(obj.tokenStandard)) ||
+        null,
+      collection:
+        (obj.collection && types.Collection.fromDecoded(obj.collection)) ||
+        null,
+      uses: (obj.uses && types.Uses.fromDecoded(obj.uses)) || null,
+      tokenProgramVersion: types.TokenProgramVersion.fromDecoded(
+        obj.tokenProgramVersion
+      ),
+      creators: obj.creators.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.Creator.fromDecoded(item)
+      ),
+    })
+  }
+
+  static toEncodable(fields: MetadataArgsFields) {
+    return {
+      name: fields.name,
+      symbol: fields.symbol,
+      uri: fields.uri,
+      sellerFeeBasisPoints: fields.sellerFeeBasisPoints,
+      primarySaleHappened: fields.primarySaleHappened,
+      isMutable: fields.isMutable,
+      editionNonce: fields.editionNonce,
+      tokenStandard:
+        (fields.tokenStandard && fields.tokenStandard.toEncodable()) || null,
+      collection:
+        (fields.collection &&
+          types.Collection.toEncodable(fields.collection)) ||
+        null,
+      uses: (fields.uses && types.Uses.toEncodable(fields.uses)) || null,
+      tokenProgramVersion: fields.tokenProgramVersion.toEncodable(),
+      creators: fields.creators.map((item) => types.Creator.toEncodable(item)),
+    }
+  }
+
+  toJSON(): MetadataArgsJSON {
+    return {
+      name: this.name,
+      symbol: this.symbol,
+      uri: this.uri,
+      sellerFeeBasisPoints: this.sellerFeeBasisPoints,
+      primarySaleHappened: this.primarySaleHappened,
+      isMutable: this.isMutable,
+      editionNonce: this.editionNonce,
+      tokenStandard:
+        (this.tokenStandard && this.tokenStandard.toJSON()) || null,
+      collection: (this.collection && this.collection.toJSON()) || null,
+      uses: (this.uses && this.uses.toJSON()) || null,
+      tokenProgramVersion: this.tokenProgramVersion.toJSON(),
+      creators: this.creators.map((item) => item.toJSON()),
+    }
+  }
+
+  static fromJSON(obj: MetadataArgsJSON): MetadataArgs {
+    return new MetadataArgs({
+      name: obj.name,
+      symbol: obj.symbol,
+      uri: obj.uri,
+      sellerFeeBasisPoints: obj.sellerFeeBasisPoints,
+      primarySaleHappened: obj.primarySaleHappened,
+      isMutable: obj.isMutable,
+      editionNonce: obj.editionNonce,
+      tokenStandard:
+        (obj.tokenStandard &&
+          types.TokenStandard.fromJSON(obj.tokenStandard)) ||
+        null,
+      collection:
+        (obj.collection && types.Collection.fromJSON(obj.collection)) || null,
+      uses: (obj.uses && types.Uses.fromJSON(obj.uses)) || null,
+      tokenProgramVersion: types.TokenProgramVersion.fromJSON(
+        obj.tokenProgramVersion
+      ),
+      creators: obj.creators.map((item) => types.Creator.fromJSON(item)),
+    })
+  }
+
+  toEncodable() {
+    return MetadataArgs.toEncodable(this)
+  }
+}

package/src/types/types/NonFungibleTraitInit.ts

@@ -0,0 +1,64 @@
+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 NonFungibleTraitInitFields {
+  hash: BN
+  values: Array<BN>
+}
+
+export interface NonFungibleTraitInitJSON {
+  hash: string
+  values: Array<string>
+}
+
+export class NonFungibleTraitInit {
+  readonly hash: BN
+  readonly values: Array<BN>
+
+  constructor(fields: NonFungibleTraitInitFields) {
+    this.hash = fields.hash
+    this.values = fields.values
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [borsh.u64("hash"), borsh.vec(borsh.u64(), "values")],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new NonFungibleTraitInit({
+      hash: obj.hash,
+      values: obj.values,
+    })
+  }
+
+  static toEncodable(fields: NonFungibleTraitInitFields) {
+    return {
+      hash: fields.hash,
+      values: fields.values,
+    }
+  }
+
+  toJSON(): NonFungibleTraitInitJSON {
+    return {
+      hash: this.hash.toString(),
+      values: this.values.map((item) => item.toString()),
+    }
+  }
+
+  static fromJSON(obj: NonFungibleTraitInitJSON): NonFungibleTraitInit {
+    return new NonFungibleTraitInit({
+      hash: new BN(obj.hash),
+      values: obj.values.map((item) => new BN(item)),
+    })
+  }
+
+  toEncodable() {
+    return NonFungibleTraitInit.toEncodable(this)
+  }
+}

package/src/types/types/NonFungibleTraitInitMap.ts

@@ -0,0 +1,84 @@
+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 NonFungibleTraitInitMapFields {
+  hash: BN
+  values: Array<types.FakeTraitValueFields>
+  index: number
+}
+
+export interface NonFungibleTraitInitMapJSON {
+  hash: string
+  values: Array<types.FakeTraitValueJSON>
+  index: number
+}
+
+export class NonFungibleTraitInitMap {
+  readonly hash: BN
+  readonly values: Array<types.FakeTraitValue>
+  readonly index: number
+
+  constructor(fields: NonFungibleTraitInitMapFields) {
+    this.hash = fields.hash
+    this.values = fields.values.map(
+      (item) => new types.FakeTraitValue({ ...item })
+    )
+    this.index = fields.index
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.u64("hash"),
+        borsh.vec(types.FakeTraitValue.layout(), "values"),
+        borsh.u32("index"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new NonFungibleTraitInitMap({
+      hash: obj.hash,
+      values: obj.values.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.FakeTraitValue.fromDecoded(item)
+      ),
+      index: obj.index,
+    })
+  }
+
+  static toEncodable(fields: NonFungibleTraitInitMapFields) {
+    return {
+      hash: fields.hash,
+      values: fields.values.map((item) =>
+        types.FakeTraitValue.toEncodable(item)
+      ),
+      index: fields.index,
+    }
+  }
+
+  toJSON(): NonFungibleTraitInitMapJSON {
+    return {
+      hash: this.hash.toString(),
+      values: this.values.map((item) => item.toJSON()),
+      index: this.index,
+    }
+  }
+
+  static fromJSON(obj: NonFungibleTraitInitMapJSON): NonFungibleTraitInitMap {
+    return new NonFungibleTraitInitMap({
+      hash: new BN(obj.hash),
+      values: obj.values.map((item) => types.FakeTraitValue.fromJSON(item)),
+      index: obj.index,
+    })
+  }
+
+  toEncodable() {
+    return NonFungibleTraitInitMap.toEncodable(this)
+  }
+}

package/src/types/types/OnlyBetweenTimesArgs.ts

@@ -0,0 +1,76 @@
+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 OnlyBetweenTimesArgsFields {
+  start: number
+  end: number
+  rangeType: types.TimeRangeTypeKind
+}
+
+export interface OnlyBetweenTimesArgsJSON {
+  start: number
+  end: number
+  rangeType: types.TimeRangeTypeJSON
+}
+
+export class OnlyBetweenTimesArgs {
+  readonly start: number
+  readonly end: number
+  readonly rangeType: types.TimeRangeTypeKind
+
+  constructor(fields: OnlyBetweenTimesArgsFields) {
+    this.start = fields.start
+    this.end = fields.end
+    this.rangeType = fields.rangeType
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.u32("start"),
+        borsh.u32("end"),
+        types.TimeRangeType.layout("rangeType"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new OnlyBetweenTimesArgs({
+      start: obj.start,
+      end: obj.end,
+      rangeType: types.TimeRangeType.fromDecoded(obj.rangeType),
+    })
+  }
+
+  static toEncodable(fields: OnlyBetweenTimesArgsFields) {
+    return {
+      start: fields.start,
+      end: fields.end,
+      rangeType: fields.rangeType.toEncodable(),
+    }
+  }
+
+  toJSON(): OnlyBetweenTimesArgsJSON {
+    return {
+      start: this.start,
+      end: this.end,
+      rangeType: this.rangeType.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: OnlyBetweenTimesArgsJSON): OnlyBetweenTimesArgs {
+    return new OnlyBetweenTimesArgs({
+      start: obj.start,
+      end: obj.end,
+      rangeType: types.TimeRangeType.fromJSON(obj.rangeType),
+    })
+  }
+
+  toEncodable() {
+    return OnlyBetweenTimesArgs.toEncodable(this)
+  }
+}

package/src/types/types/OnlyTheseDOWArgs.ts

@@ -0,0 +1,53 @@
+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 OnlyTheseDOWArgsFields {
+  days: number
+}
+
+export interface OnlyTheseDOWArgsJSON {
+  days: number
+}
+
+export class OnlyTheseDOWArgs {
+  readonly days: number
+
+  constructor(fields: OnlyTheseDOWArgsFields) {
+    this.days = fields.days
+  }
+
+  static layout(property?: string) {
+    return borsh.struct([borsh.u8("days")], property)
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new OnlyTheseDOWArgs({
+      days: obj.days,
+    })
+  }
+
+  static toEncodable(fields: OnlyTheseDOWArgsFields) {
+    return {
+      days: fields.days,
+    }
+  }
+
+  toJSON(): OnlyTheseDOWArgsJSON {
+    return {
+      days: this.days,
+    }
+  }
+
+  static fromJSON(obj: OnlyTheseDOWArgsJSON): OnlyTheseDOWArgs {
+    return new OnlyTheseDOWArgs({
+      days: obj.days,
+    })
+  }
+
+  toEncodable() {
+    return OnlyTheseDOWArgs.toEncodable(this)
+  }
+}

package/src/types/types/PackConfig.ts

@@ -0,0 +1,98 @@
+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 PackConfigFields {
+  amountPerPack: number
+  chancesOfEmpty: number
+  openAuthority: PublicKey
+  packType: types.PackTypeKind
+  packRules: Array<types.PackRuleKind>
+}
+
+export interface PackConfigJSON {
+  amountPerPack: number
+  chancesOfEmpty: number
+  openAuthority: string
+  packType: types.PackTypeJSON
+  packRules: Array<types.PackRuleJSON>
+}
+
+export class PackConfig {
+  readonly amountPerPack: number
+  readonly chancesOfEmpty: number
+  readonly openAuthority: PublicKey
+  readonly packType: types.PackTypeKind
+  readonly packRules: Array<types.PackRuleKind>
+
+  constructor(fields: PackConfigFields) {
+    this.amountPerPack = fields.amountPerPack
+    this.chancesOfEmpty = fields.chancesOfEmpty
+    this.openAuthority = fields.openAuthority
+    this.packType = fields.packType
+    this.packRules = fields.packRules
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.u8("amountPerPack"),
+        borsh.u16("chancesOfEmpty"),
+        borsh.publicKey("openAuthority"),
+        types.PackType.layout("packType"),
+        borsh.vec(types.PackRule.layout(), "packRules"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new PackConfig({
+      amountPerPack: obj.amountPerPack,
+      chancesOfEmpty: obj.chancesOfEmpty,
+      openAuthority: obj.openAuthority,
+      packType: types.PackType.fromDecoded(obj.packType),
+      packRules: obj.packRules.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.PackRule.fromDecoded(item)
+      ),
+    })
+  }
+
+  static toEncodable(fields: PackConfigFields) {
+    return {
+      amountPerPack: fields.amountPerPack,
+      chancesOfEmpty: fields.chancesOfEmpty,
+      openAuthority: fields.openAuthority,
+      packType: fields.packType.toEncodable(),
+      packRules: fields.packRules.map((item) => item.toEncodable()),
+    }
+  }
+
+  toJSON(): PackConfigJSON {
+    return {
+      amountPerPack: this.amountPerPack,
+      chancesOfEmpty: this.chancesOfEmpty,
+      openAuthority: this.openAuthority.toString(),
+      packType: this.packType.toJSON(),
+      packRules: this.packRules.map((item) => item.toJSON()),
+    }
+  }
+
+  static fromJSON(obj: PackConfigJSON): PackConfig {
+    return new PackConfig({
+      amountPerPack: obj.amountPerPack,
+      chancesOfEmpty: obj.chancesOfEmpty,
+      openAuthority: new PublicKey(obj.openAuthority),
+      packType: types.PackType.fromJSON(obj.packType),
+      packRules: obj.packRules.map((item) => types.PackRule.fromJSON(item)),
+    })
+  }
+
+  toEncodable() {
+    return PackConfig.toEncodable(this)
+  }
+}