3land_sdk 1.0.0

package/src/types/types/TokenMetadata.ts

@@ -0,0 +1,72 @@
+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 TokenMetadataFields {
+  name: string;
+  symbol: string;
+  arweave: string;
+}
+
+export interface TokenMetadataJSON {
+  name: string;
+  symbol: string;
+  arweave: string;
+}
+
+export class TokenMetadata {
+  readonly name: string;
+  readonly symbol: string;
+  readonly arweave: string;
+
+  constructor(fields: TokenMetadataFields) {
+    this.name = fields.name;
+    this.symbol = fields.symbol;
+    this.arweave = fields.arweave;
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [borsh.str("name"), borsh.str("symbol"), borsh.str("arweave")],
+      property
+    );
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new TokenMetadata({
+      name: obj.name,
+      symbol: obj.symbol,
+      arweave: obj.arweave,
+    });
+  }
+
+  static toEncodable(fields: TokenMetadataFields) {
+    return {
+      name: fields.name,
+      symbol: fields.symbol,
+      arweave: fields.arweave,
+    };
+  }
+
+  toJSON(): TokenMetadataJSON {
+    return {
+      name: this.name,
+      symbol: this.symbol,
+      arweave: this.arweave,
+    };
+  }
+
+  static fromJSON(obj: TokenMetadataJSON): TokenMetadata {
+    return new TokenMetadata({
+      name: obj.name,
+      symbol: obj.symbol,
+      arweave: obj.arweave,
+    });
+  }
+
+  toEncodable() {
+    return TokenMetadata.toEncodable(this);
+  }
+}

package/src/types/types/TokenProgramVersion.ts

@@ -0,0 +1,90 @@
+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 OriginalJSON {
+  kind: "Original"
+}
+
+export class Original {
+  static readonly discriminator = 0
+  static readonly kind = "Original"
+  readonly discriminator = 0
+  readonly kind = "Original"
+
+  toJSON(): OriginalJSON {
+    return {
+      kind: "Original",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Original: {},
+    }
+  }
+}
+
+export interface Token2022JSON {
+  kind: "Token2022"
+}
+
+export class Token2022 {
+  static readonly discriminator = 1
+  static readonly kind = "Token2022"
+  readonly discriminator = 1
+  readonly kind = "Token2022"
+
+  toJSON(): Token2022JSON {
+    return {
+      kind: "Token2022",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Token2022: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.TokenProgramVersionKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("Original" in obj) {
+    return new Original()
+  }
+  if ("Token2022" in obj) {
+    return new Token2022()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(
+  obj: types.TokenProgramVersionJSON
+): types.TokenProgramVersionKind {
+  switch (obj.kind) {
+    case "Original": {
+      return new Original()
+    }
+    case "Token2022": {
+      return new Token2022()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "Original"),
+    borsh.struct([], "Token2022"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/TokenStandard.ts

@@ -0,0 +1,150 @@
+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 NonFungibleJSON {
+  kind: "NonFungible"
+}
+
+export class NonFungible {
+  static readonly discriminator = 0
+  static readonly kind = "NonFungible"
+  readonly discriminator = 0
+  readonly kind = "NonFungible"
+
+  toJSON(): NonFungibleJSON {
+    return {
+      kind: "NonFungible",
+    }
+  }
+
+  toEncodable() {
+    return {
+      NonFungible: {},
+    }
+  }
+}
+
+export interface FungibleAssetJSON {
+  kind: "FungibleAsset"
+}
+
+export class FungibleAsset {
+  static readonly discriminator = 1
+  static readonly kind = "FungibleAsset"
+  readonly discriminator = 1
+  readonly kind = "FungibleAsset"
+
+  toJSON(): FungibleAssetJSON {
+    return {
+      kind: "FungibleAsset",
+    }
+  }
+
+  toEncodable() {
+    return {
+      FungibleAsset: {},
+    }
+  }
+}
+
+export interface FungibleJSON {
+  kind: "Fungible"
+}
+
+export class Fungible {
+  static readonly discriminator = 2
+  static readonly kind = "Fungible"
+  readonly discriminator = 2
+  readonly kind = "Fungible"
+
+  toJSON(): FungibleJSON {
+    return {
+      kind: "Fungible",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Fungible: {},
+    }
+  }
+}
+
+export interface NonFungibleEditionJSON {
+  kind: "NonFungibleEdition"
+}
+
+export class NonFungibleEdition {
+  static readonly discriminator = 3
+  static readonly kind = "NonFungibleEdition"
+  readonly discriminator = 3
+  readonly kind = "NonFungibleEdition"
+
+  toJSON(): NonFungibleEditionJSON {
+    return {
+      kind: "NonFungibleEdition",
+    }
+  }
+
+  toEncodable() {
+    return {
+      NonFungibleEdition: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.TokenStandardKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("NonFungible" in obj) {
+    return new NonFungible()
+  }
+  if ("FungibleAsset" in obj) {
+    return new FungibleAsset()
+  }
+  if ("Fungible" in obj) {
+    return new Fungible()
+  }
+  if ("NonFungibleEdition" in obj) {
+    return new NonFungibleEdition()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(
+  obj: types.TokenStandardJSON
+): types.TokenStandardKind {
+  switch (obj.kind) {
+    case "NonFungible": {
+      return new NonFungible()
+    }
+    case "FungibleAsset": {
+      return new FungibleAsset()
+    }
+    case "Fungible": {
+      return new Fungible()
+    }
+    case "NonFungibleEdition": {
+      return new NonFungibleEdition()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "NonFungible"),
+    borsh.struct([], "FungibleAsset"),
+    borsh.struct([], "Fungible"),
+    borsh.struct([], "NonFungibleEdition"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/TokenState.ts

@@ -0,0 +1,88 @@
+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 NewJSON {
+  kind: "New"
+}
+
+export class New {
+  static readonly discriminator = 0
+  static readonly kind = "New"
+  readonly discriminator = 0
+  readonly kind = "New"
+
+  toJSON(): NewJSON {
+    return {
+      kind: "New",
+    }
+  }
+
+  toEncodable() {
+    return {
+      New: {},
+    }
+  }
+}
+
+export interface ActiveJSON {
+  kind: "Active"
+}
+
+export class Active {
+  static readonly discriminator = 1
+  static readonly kind = "Active"
+  readonly discriminator = 1
+  readonly kind = "Active"
+
+  toJSON(): ActiveJSON {
+    return {
+      kind: "Active",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Active: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.TokenStateKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("New" in obj) {
+    return new New()
+  }
+  if ("Active" in obj) {
+    return new Active()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.TokenStateJSON): types.TokenStateKind {
+  switch (obj.kind) {
+    case "New": {
+      return new New()
+    }
+    case "Active": {
+      return new Active()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "New"),
+    borsh.struct([], "Active"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/TokenType.ts

@@ -0,0 +1,88 @@
+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 BasicJSON {
+  kind: "Basic"
+}
+
+export class Basic {
+  static readonly discriminator = 0
+  static readonly kind = "Basic"
+  readonly discriminator = 0
+  readonly kind = "Basic"
+
+  toJSON(): BasicJSON {
+    return {
+      kind: "Basic",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Basic: {},
+    }
+  }
+}
+
+export interface OnlyUpJSON {
+  kind: "OnlyUp"
+}
+
+export class OnlyUp {
+  static readonly discriminator = 1
+  static readonly kind = "OnlyUp"
+  readonly discriminator = 1
+  readonly kind = "OnlyUp"
+
+  toJSON(): OnlyUpJSON {
+    return {
+      kind: "OnlyUp",
+    }
+  }
+
+  toEncodable() {
+    return {
+      OnlyUp: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.TokenTypeKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("Basic" in obj) {
+    return new Basic()
+  }
+  if ("OnlyUp" in obj) {
+    return new OnlyUp()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.TokenTypeJSON): types.TokenTypeKind {
+  switch (obj.kind) {
+    case "Basic": {
+      return new Basic()
+    }
+    case "OnlyUp": {
+      return new OnlyUp()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "Basic"),
+    borsh.struct([], "OnlyUp"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/types/types/TotalPerTimeArgs.ts

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

package/src/types/types/TotalPerTimeWalletArgs.ts

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