3land_sdk 1.0.1 → 1.0.2

package/dist/types/types/PackState.js

@@ -0,0 +1,95 @@
+import * as borsh from "@coral-xyz/borsh";
+export class Closed {
+    constructor() {
+        this.discriminator = 0;
+        this.kind = "Closed";
+    }
+    toJSON() {
+        return {
+            kind: "Closed",
+        };
+    }
+    toEncodable() {
+        return {
+            Closed: {},
+        };
+    }
+}
+Closed.discriminator = 0;
+Closed.kind = "Closed";
+export class Opened {
+    constructor() {
+        this.discriminator = 1;
+        this.kind = "Opened";
+    }
+    toJSON() {
+        return {
+            kind: "Opened",
+        };
+    }
+    toEncodable() {
+        return {
+            Opened: {},
+        };
+    }
+}
+Opened.discriminator = 1;
+Opened.kind = "Opened";
+export class Unassigned {
+    constructor() {
+        this.discriminator = 2;
+        this.kind = "Unassigned";
+    }
+    toJSON() {
+        return {
+            kind: "Unassigned",
+        };
+    }
+    toEncodable() {
+        return {
+            Unassigned: {},
+        };
+    }
+}
+Unassigned.discriminator = 2;
+Unassigned.kind = "Unassigned";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj) {
+    if (typeof obj !== "object") {
+        throw new Error("Invalid enum object");
+    }
+    if ("Closed" in obj) {
+        return new Closed();
+    }
+    if ("Opened" in obj) {
+        return new Opened();
+    }
+    if ("Unassigned" in obj) {
+        return new Unassigned();
+    }
+    throw new Error("Invalid enum object");
+}
+export function fromJSON(obj) {
+    switch (obj.kind) {
+        case "Closed": {
+            return new Closed();
+        }
+        case "Opened": {
+            return new Opened();
+        }
+        case "Unassigned": {
+            return new Unassigned();
+        }
+    }
+}
+export function layout(property) {
+    const ret = borsh.rustEnum([
+        borsh.struct([], "Closed"),
+        borsh.struct([], "Opened"),
+        borsh.struct([], "Unassigned"),
+    ]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

package/dist/types/types/PackType.d.ts

@@ -0,0 +1,43 @@
+import * as types from "../types";
+export interface RandomDirectJSON {
+    kind: "RandomDirect";
+}
+export declare class RandomDirect {
+    static readonly discriminator = 0;
+    static readonly kind = "RandomDirect";
+    readonly discriminator = 0;
+    readonly kind = "RandomDirect";
+    toJSON(): RandomDirectJSON;
+    toEncodable(): {
+        RandomDirect: {};
+    };
+}
+export interface RandomPackJSON {
+    kind: "RandomPack";
+}
+export declare class RandomPack {
+    static readonly discriminator = 1;
+    static readonly kind = "RandomPack";
+    readonly discriminator = 1;
+    readonly kind = "RandomPack";
+    toJSON(): RandomPackJSON;
+    toEncodable(): {
+        RandomPack: {};
+    };
+}
+export interface BundleJSON {
+    kind: "Bundle";
+}
+export declare class Bundle {
+    static readonly discriminator = 2;
+    static readonly kind = "Bundle";
+    readonly discriminator = 2;
+    readonly kind = "Bundle";
+    toJSON(): BundleJSON;
+    toEncodable(): {
+        Bundle: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.PackTypeKind;
+export declare function fromJSON(obj: types.PackTypeJSON): types.PackTypeKind;
+export declare function layout(property?: string): any;

package/dist/types/types/PackType.js

@@ -0,0 +1,95 @@
+import * as borsh from "@coral-xyz/borsh";
+export class RandomDirect {
+    constructor() {
+        this.discriminator = 0;
+        this.kind = "RandomDirect";
+    }
+    toJSON() {
+        return {
+            kind: "RandomDirect",
+        };
+    }
+    toEncodable() {
+        return {
+            RandomDirect: {},
+        };
+    }
+}
+RandomDirect.discriminator = 0;
+RandomDirect.kind = "RandomDirect";
+export class RandomPack {
+    constructor() {
+        this.discriminator = 1;
+        this.kind = "RandomPack";
+    }
+    toJSON() {
+        return {
+            kind: "RandomPack",
+        };
+    }
+    toEncodable() {
+        return {
+            RandomPack: {},
+        };
+    }
+}
+RandomPack.discriminator = 1;
+RandomPack.kind = "RandomPack";
+export class Bundle {
+    constructor() {
+        this.discriminator = 2;
+        this.kind = "Bundle";
+    }
+    toJSON() {
+        return {
+            kind: "Bundle",
+        };
+    }
+    toEncodable() {
+        return {
+            Bundle: {},
+        };
+    }
+}
+Bundle.discriminator = 2;
+Bundle.kind = "Bundle";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj) {
+    if (typeof obj !== "object") {
+        throw new Error("Invalid enum object");
+    }
+    if ("RandomDirect" in obj) {
+        return new RandomDirect();
+    }
+    if ("RandomPack" in obj) {
+        return new RandomPack();
+    }
+    if ("Bundle" in obj) {
+        return new Bundle();
+    }
+    throw new Error("Invalid enum object");
+}
+export function fromJSON(obj) {
+    switch (obj.kind) {
+        case "RandomDirect": {
+            return new RandomDirect();
+        }
+        case "RandomPack": {
+            return new RandomPack();
+        }
+        case "Bundle": {
+            return new Bundle();
+        }
+    }
+}
+export function layout(property) {
+    const ret = borsh.rustEnum([
+        borsh.struct([], "RandomDirect"),
+        borsh.struct([], "RandomPack"),
+        borsh.struct([], "Bundle"),
+    ]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

package/dist/types/types/PaymentClass.d.ts

@@ -0,0 +1,43 @@
+import * as types from "../types";
+export interface PaymentV1JSON {
+    kind: "PaymentV1";
+}
+export declare class PaymentV1 {
+    static readonly discriminator = 0;
+    static readonly kind = "PaymentV1";
+    readonly discriminator = 0;
+    readonly kind = "PaymentV1";
+    toJSON(): PaymentV1JSON;
+    toEncodable(): {
+        PaymentV1: {};
+    };
+}
+export interface BurnPaymentV1JSON {
+    kind: "BurnPaymentV1";
+}
+export declare class BurnPaymentV1 {
+    static readonly discriminator = 1;
+    static readonly kind = "BurnPaymentV1";
+    readonly discriminator = 1;
+    readonly kind = "BurnPaymentV1";
+    toJSON(): BurnPaymentV1JSON;
+    toEncodable(): {
+        BurnPaymentV1: {};
+    };
+}
+export interface GatePaymentV1JSON {
+    kind: "GatePaymentV1";
+}
+export declare class GatePaymentV1 {
+    static readonly discriminator = 2;
+    static readonly kind = "GatePaymentV1";
+    readonly discriminator = 2;
+    readonly kind = "GatePaymentV1";
+    toJSON(): GatePaymentV1JSON;
+    toEncodable(): {
+        GatePaymentV1: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.PaymentClassKind;
+export declare function fromJSON(obj: types.PaymentClassJSON): types.PaymentClassKind;
+export declare function layout(property?: string): any;

package/dist/types/types/PaymentClass.js

@@ -0,0 +1,95 @@
+import * as borsh from "@coral-xyz/borsh";
+export class PaymentV1 {
+    constructor() {
+        this.discriminator = 0;
+        this.kind = "PaymentV1";
+    }
+    toJSON() {
+        return {
+            kind: "PaymentV1",
+        };
+    }
+    toEncodable() {
+        return {
+            PaymentV1: {},
+        };
+    }
+}
+PaymentV1.discriminator = 0;
+PaymentV1.kind = "PaymentV1";
+export class BurnPaymentV1 {
+    constructor() {
+        this.discriminator = 1;
+        this.kind = "BurnPaymentV1";
+    }
+    toJSON() {
+        return {
+            kind: "BurnPaymentV1",
+        };
+    }
+    toEncodable() {
+        return {
+            BurnPaymentV1: {},
+        };
+    }
+}
+BurnPaymentV1.discriminator = 1;
+BurnPaymentV1.kind = "BurnPaymentV1";
+export class GatePaymentV1 {
+    constructor() {
+        this.discriminator = 2;
+        this.kind = "GatePaymentV1";
+    }
+    toJSON() {
+        return {
+            kind: "GatePaymentV1",
+        };
+    }
+    toEncodable() {
+        return {
+            GatePaymentV1: {},
+        };
+    }
+}
+GatePaymentV1.discriminator = 2;
+GatePaymentV1.kind = "GatePaymentV1";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj) {
+    if (typeof obj !== "object") {
+        throw new Error("Invalid enum object");
+    }
+    if ("PaymentV1" in obj) {
+        return new PaymentV1();
+    }
+    if ("BurnPaymentV1" in obj) {
+        return new BurnPaymentV1();
+    }
+    if ("GatePaymentV1" in obj) {
+        return new GatePaymentV1();
+    }
+    throw new Error("Invalid enum object");
+}
+export function fromJSON(obj) {
+    switch (obj.kind) {
+        case "PaymentV1": {
+            return new PaymentV1();
+        }
+        case "BurnPaymentV1": {
+            return new BurnPaymentV1();
+        }
+        case "GatePaymentV1": {
+            return new GatePaymentV1();
+        }
+    }
+}
+export function layout(property) {
+    const ret = borsh.rustEnum([
+        borsh.struct([], "PaymentV1"),
+        borsh.struct([], "BurnPaymentV1"),
+        borsh.struct([], "GatePaymentV1"),
+    ]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

package/dist/types/types/PoolAccess.d.ts

@@ -0,0 +1,30 @@
+import * as types from "../types";
+export interface CpiJSON {
+    kind: "Cpi";
+}
+export declare class Cpi {
+    static readonly discriminator = 0;
+    static readonly kind = "Cpi";
+    readonly discriminator = 0;
+    readonly kind = "Cpi";
+    toJSON(): CpiJSON;
+    toEncodable(): {
+        Cpi: {};
+    };
+}
+export interface PublicJSON {
+    kind: "Public";
+}
+export declare class Public {
+    static readonly discriminator = 1;
+    static readonly kind = "Public";
+    readonly discriminator = 1;
+    readonly kind = "Public";
+    toJSON(): PublicJSON;
+    toEncodable(): {
+        Public: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.PoolAccessKind;
+export declare function fromJSON(obj: types.PoolAccessJSON): types.PoolAccessKind;
+export declare function layout(property?: string): any;

package/dist/types/types/PoolAccess.js

@@ -0,0 +1,70 @@
+import * as borsh from "@coral-xyz/borsh";
+export class Cpi {
+    constructor() {
+        this.discriminator = 0;
+        this.kind = "Cpi";
+    }
+    toJSON() {
+        return {
+            kind: "Cpi",
+        };
+    }
+    toEncodable() {
+        return {
+            Cpi: {},
+        };
+    }
+}
+Cpi.discriminator = 0;
+Cpi.kind = "Cpi";
+export class Public {
+    constructor() {
+        this.discriminator = 1;
+        this.kind = "Public";
+    }
+    toJSON() {
+        return {
+            kind: "Public",
+        };
+    }
+    toEncodable() {
+        return {
+            Public: {},
+        };
+    }
+}
+Public.discriminator = 1;
+Public.kind = "Public";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj) {
+    if (typeof obj !== "object") {
+        throw new Error("Invalid enum object");
+    }
+    if ("Cpi" in obj) {
+        return new Cpi();
+    }
+    if ("Public" in obj) {
+        return new Public();
+    }
+    throw new Error("Invalid enum object");
+}
+export function fromJSON(obj) {
+    switch (obj.kind) {
+        case "Cpi": {
+            return new Cpi();
+        }
+        case "Public": {
+            return new Public();
+        }
+    }
+}
+export function layout(property) {
+    const ret = borsh.rustEnum([
+        borsh.struct([], "Cpi"),
+        borsh.struct([], "Public"),
+    ]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

package/dist/types/types/PoolState.d.ts

@@ -0,0 +1,30 @@
+import * as types from "../types";
+export interface AvailableJSON {
+    kind: "Available";
+}
+export declare class Available {
+    static readonly discriminator = 0;
+    static readonly kind = "Available";
+    readonly discriminator = 0;
+    readonly kind = "Available";
+    toJSON(): AvailableJSON;
+    toEncodable(): {
+        Available: {};
+    };
+}
+export interface ClosedJSON {
+    kind: "Closed";
+}
+export declare class Closed {
+    static readonly discriminator = 1;
+    static readonly kind = "Closed";
+    readonly discriminator = 1;
+    readonly kind = "Closed";
+    toJSON(): ClosedJSON;
+    toEncodable(): {
+        Closed: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.PoolStateKind;
+export declare function fromJSON(obj: types.PoolStateJSON): types.PoolStateKind;
+export declare function layout(property?: string): any;

package/dist/types/types/PoolState.js

@@ -0,0 +1,70 @@
+import * as borsh from "@coral-xyz/borsh";
+export class Available {
+    constructor() {
+        this.discriminator = 0;
+        this.kind = "Available";
+    }
+    toJSON() {
+        return {
+            kind: "Available",
+        };
+    }
+    toEncodable() {
+        return {
+            Available: {},
+        };
+    }
+}
+Available.discriminator = 0;
+Available.kind = "Available";
+export class Closed {
+    constructor() {
+        this.discriminator = 1;
+        this.kind = "Closed";
+    }
+    toJSON() {
+        return {
+            kind: "Closed",
+        };
+    }
+    toEncodable() {
+        return {
+            Closed: {},
+        };
+    }
+}
+Closed.discriminator = 1;
+Closed.kind = "Closed";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj) {
+    if (typeof obj !== "object") {
+        throw new Error("Invalid enum object");
+    }
+    if ("Available" in obj) {
+        return new Available();
+    }
+    if ("Closed" in obj) {
+        return new Closed();
+    }
+    throw new Error("Invalid enum object");
+}
+export function fromJSON(obj) {
+    switch (obj.kind) {
+        case "Available": {
+            return new Available();
+        }
+        case "Closed": {
+            return new Closed();
+        }
+    }
+}
+export function layout(property) {
+    const ret = borsh.rustEnum([
+        borsh.struct([], "Available"),
+        borsh.struct([], "Closed"),
+    ]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

package/dist/types/types/PoolType.d.ts

@@ -0,0 +1,30 @@
+import * as types from "../types";
+export interface NoneJSON {
+    kind: "None";
+}
+export declare class None {
+    static readonly discriminator = 0;
+    static readonly kind = "None";
+    readonly discriminator = 0;
+    readonly kind = "None";
+    toJSON(): NoneJSON;
+    toEncodable(): {
+        None: {};
+    };
+}
+export interface TokenJSON {
+    kind: "Token";
+}
+export declare class Token {
+    static readonly discriminator = 1;
+    static readonly kind = "Token";
+    readonly discriminator = 1;
+    readonly kind = "Token";
+    toJSON(): TokenJSON;
+    toEncodable(): {
+        Token: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.PoolTypeKind;
+export declare function fromJSON(obj: types.PoolTypeJSON): types.PoolTypeKind;
+export declare function layout(property?: string): any;

package/dist/types/types/PoolType.js

@@ -0,0 +1,70 @@
+import * as borsh from "@coral-xyz/borsh";
+export class None {
+    constructor() {
+        this.discriminator = 0;
+        this.kind = "None";
+    }
+    toJSON() {
+        return {
+            kind: "None",
+        };
+    }
+    toEncodable() {
+        return {
+            None: {},
+        };
+    }
+}
+None.discriminator = 0;
+None.kind = "None";
+export class Token {
+    constructor() {
+        this.discriminator = 1;
+        this.kind = "Token";
+    }
+    toJSON() {
+        return {
+            kind: "Token",
+        };
+    }
+    toEncodable() {
+        return {
+            Token: {},
+        };
+    }
+}
+Token.discriminator = 1;
+Token.kind = "Token";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj) {
+    if (typeof obj !== "object") {
+        throw new Error("Invalid enum object");
+    }
+    if ("None" in obj) {
+        return new None();
+    }
+    if ("Token" in obj) {
+        return new Token();
+    }
+    throw new Error("Invalid enum object");
+}
+export function fromJSON(obj) {
+    switch (obj.kind) {
+        case "None": {
+            return new None();
+        }
+        case "Token": {
+            return new Token();
+        }
+    }
+}
+export function layout(property) {
+    const ret = borsh.rustEnum([
+        borsh.struct([], "None"),
+        borsh.struct([], "Token"),
+    ]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

package/dist/types/types/Popularity.d.ts

@@ -0,0 +1,32 @@
+import BN from "bn.js";
+import * as types from "../types";
+export interface PopularityFields {
+    lastReset: number;
+    count: BN;
+    state: types.PopularityStateKind;
+}
+export interface PopularityJSON {
+    lastReset: number;
+    count: string;
+    state: types.PopularityStateJSON;
+}
+export declare class Popularity {
+    readonly lastReset: number;
+    readonly count: BN;
+    readonly state: types.PopularityStateKind;
+    constructor(fields: PopularityFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): Popularity;
+    static toEncodable(fields: PopularityFields): {
+        lastReset: number;
+        count: BN;
+        state: any;
+    };
+    toJSON(): PopularityJSON;
+    static fromJSON(obj: PopularityJSON): Popularity;
+    toEncodable(): {
+        lastReset: number;
+        count: BN;
+        state: any;
+    };
+}