3land_sdk 1.0.0 → 1.0.2

package/dist/types/types/AccountHasher.d.ts

@@ -0,0 +1,37 @@
+import { PublicKey } from "@solana/web3.js";
+import * as types from "../types";
+export interface AccountHasherFields {
+    seeds: Array<types.SeedFields>;
+    insertAt: number;
+    program: PublicKey;
+    bump: number;
+}
+export interface AccountHasherJSON {
+    seeds: Array<types.SeedJSON>;
+    insertAt: number;
+    program: string;
+    bump: number;
+}
+export declare class AccountHasher {
+    readonly seeds: Array<types.Seed>;
+    readonly insertAt: number;
+    readonly program: PublicKey;
+    readonly bump: number;
+    constructor(fields: AccountHasherFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): AccountHasher;
+    static toEncodable(fields: AccountHasherFields): {
+        seeds: any[];
+        insertAt: number;
+        program: PublicKey;
+        bump: number;
+    };
+    toJSON(): AccountHasherJSON;
+    static fromJSON(obj: AccountHasherJSON): AccountHasher;
+    toEncodable(): {
+        seeds: any[];
+        insertAt: number;
+        program: PublicKey;
+        bump: number;
+    };
+}

package/dist/types/types/AccountHasher.js

@@ -0,0 +1,55 @@
+import { PublicKey } from "@solana/web3.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 class AccountHasher {
+    constructor(fields) {
+        this.seeds = fields.seeds.map((item) => new types.Seed(Object.assign({}, item)));
+        this.insertAt = fields.insertAt;
+        this.program = fields.program;
+        this.bump = fields.bump;
+    }
+    static layout(property) {
+        return borsh.struct([
+            borsh.vec(types.Seed.layout(), "seeds"),
+            borsh.u8("insertAt"),
+            borsh.publicKey("program"),
+            borsh.u8("bump"),
+        ], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new AccountHasher({
+            seeds: obj.seeds.map((item /* eslint-disable-line @typescript-eslint/no-explicit-any */) => types.Seed.fromDecoded(item)),
+            insertAt: obj.insertAt,
+            program: obj.program,
+            bump: obj.bump,
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            seeds: fields.seeds.map((item) => types.Seed.toEncodable(item)),
+            insertAt: fields.insertAt,
+            program: fields.program,
+            bump: fields.bump,
+        };
+    }
+    toJSON() {
+        return {
+            seeds: this.seeds.map((item) => item.toJSON()),
+            insertAt: this.insertAt,
+            program: this.program.toString(),
+            bump: this.bump,
+        };
+    }
+    static fromJSON(obj) {
+        return new AccountHasher({
+            seeds: obj.seeds.map((item) => types.Seed.fromJSON(item)),
+            insertAt: obj.insertAt,
+            program: new PublicKey(obj.program),
+            bump: obj.bump,
+        });
+    }
+    toEncodable() {
+        return AccountHasher.toEncodable(this);
+    }
+}

package/dist/types/types/ActionAfter.d.ts

@@ -0,0 +1,82 @@
+import * as types from "../types";
+export interface MintingOutJSON {
+    kind: "MintingOut";
+}
+export declare class MintingOut {
+    static readonly discriminator = 0;
+    static readonly kind = "MintingOut";
+    readonly discriminator = 0;
+    readonly kind = "MintingOut";
+    toJSON(): MintingOutJSON;
+    toEncodable(): {
+        MintingOut: {};
+    };
+}
+export type SupplyFields = {
+    limit: number;
+};
+export type SupplyValue = {
+    limit: number;
+};
+export interface SupplyJSON {
+    kind: "Supply";
+    value: {
+        limit: number;
+    };
+}
+export declare class Supply {
+    static readonly discriminator = 1;
+    static readonly kind = "Supply";
+    readonly discriminator = 1;
+    readonly kind = "Supply";
+    readonly value: SupplyValue;
+    constructor(value: SupplyFields);
+    toJSON(): SupplyJSON;
+    toEncodable(): {
+        Supply: {
+            limit: number;
+        };
+    };
+}
+export type HoursFields = {
+    hours: number;
+};
+export type HoursValue = {
+    hours: number;
+};
+export interface HoursJSON {
+    kind: "Hours";
+    value: {
+        hours: number;
+    };
+}
+export declare class Hours {
+    static readonly discriminator = 2;
+    static readonly kind = "Hours";
+    readonly discriminator = 2;
+    readonly kind = "Hours";
+    readonly value: HoursValue;
+    constructor(value: HoursFields);
+    toJSON(): HoursJSON;
+    toEncodable(): {
+        Hours: {
+            hours: number;
+        };
+    };
+}
+export interface SellingOutJSON {
+    kind: "SellingOut";
+}
+export declare class SellingOut {
+    static readonly discriminator = 3;
+    static readonly kind = "SellingOut";
+    readonly discriminator = 3;
+    readonly kind = "SellingOut";
+    toJSON(): SellingOutJSON;
+    toEncodable(): {
+        SellingOut: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.ActionAfterKind;
+export declare function fromJSON(obj: types.ActionAfterJSON): types.ActionAfterKind;
+export declare function layout(property?: string): any;

package/dist/types/types/ActionAfter.js

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

package/dist/types/types/AllowedCurrencyArgs.d.ts

@@ -0,0 +1,20 @@
+export interface AllowedCurrencyArgsFields {
+    id: number;
+}
+export interface AllowedCurrencyArgsJSON {
+    id: number;
+}
+export declare class AllowedCurrencyArgs {
+    readonly id: number;
+    constructor(fields: AllowedCurrencyArgsFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): AllowedCurrencyArgs;
+    static toEncodable(fields: AllowedCurrencyArgsFields): {
+        id: number;
+    };
+    toJSON(): AllowedCurrencyArgsJSON;
+    static fromJSON(obj: AllowedCurrencyArgsJSON): AllowedCurrencyArgs;
+    toEncodable(): {
+        id: number;
+    };
+}

package/dist/types/types/AllowedCurrencyArgs.js

@@ -0,0 +1,33 @@
+import * as borsh from "@coral-xyz/borsh";
+export class AllowedCurrencyArgs {
+    constructor(fields) {
+        this.id = fields.id;
+    }
+    static layout(property) {
+        return borsh.struct([borsh.u16("id")], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new AllowedCurrencyArgs({
+            id: obj.id,
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            id: fields.id,
+        };
+    }
+    toJSON() {
+        return {
+            id: this.id,
+        };
+    }
+    static fromJSON(obj) {
+        return new AllowedCurrencyArgs({
+            id: obj.id,
+        });
+    }
+    toEncodable() {
+        return AllowedCurrencyArgs.toEncodable(this);
+    }
+}

package/dist/types/types/AuthorityGateTypes.d.ts

@@ -0,0 +1,30 @@
+import * as types from "../types";
+export interface IPGateJSON {
+    kind: "IPGate";
+}
+export declare class IPGate {
+    static readonly discriminator = 0;
+    static readonly kind = "IPGate";
+    readonly discriminator = 0;
+    readonly kind = "IPGate";
+    toJSON(): IPGateJSON;
+    toEncodable(): {
+        IPGate: {};
+    };
+}
+export interface BiometricsGateJSON {
+    kind: "BiometricsGate";
+}
+export declare class BiometricsGate {
+    static readonly discriminator = 1;
+    static readonly kind = "BiometricsGate";
+    readonly discriminator = 1;
+    readonly kind = "BiometricsGate";
+    toJSON(): BiometricsGateJSON;
+    toEncodable(): {
+        BiometricsGate: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.AuthorityGateTypesKind;
+export declare function fromJSON(obj: types.AuthorityGateTypesJSON): types.AuthorityGateTypesKind;
+export declare function layout(property?: string): any;

package/dist/types/types/AuthorityGateTypes.js

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

package/dist/types/types/BurnCount.d.ts

@@ -0,0 +1,21 @@
+import * as types from "../types";
+export interface BurnCountFields {
+    list: Array<types.FakeBurnCountFields>;
+}
+export interface BurnCountJSON {
+    list: Array<types.FakeBurnCountJSON>;
+}
+export declare class BurnCount {
+    readonly list: Array<types.FakeBurnCount>;
+    constructor(fields: BurnCountFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): BurnCount;
+    static toEncodable(fields: BurnCountFields): {
+        list: any[];
+    };
+    toJSON(): BurnCountJSON;
+    static fromJSON(obj: BurnCountJSON): BurnCount;
+    toEncodable(): {
+        list: any[];
+    };
+}

package/dist/types/types/BurnCount.js

@@ -0,0 +1,34 @@
+import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh";
+export class BurnCount {
+    constructor(fields) {
+        this.list = fields.list.map((item) => new types.FakeBurnCount(Object.assign({}, item)));
+    }
+    static layout(property) {
+        return borsh.struct([borsh.vec(types.FakeBurnCount.layout(), "list")], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new BurnCount({
+            list: obj.list.map((item /* eslint-disable-line @typescript-eslint/no-explicit-any */) => types.FakeBurnCount.fromDecoded(item)),
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            list: fields.list.map((item) => types.FakeBurnCount.toEncodable(item)),
+        };
+    }
+    toJSON() {
+        return {
+            list: this.list.map((item) => item.toJSON()),
+        };
+    }
+    static fromJSON(obj) {
+        return new BurnCount({
+            list: obj.list.map((item) => types.FakeBurnCount.fromJSON(item)),
+        });
+    }
+    toEncodable() {
+        return BurnCount.toEncodable(this);
+    }
+}

package/dist/types/types/BurnState.d.ts

@@ -0,0 +1,30 @@
+import * as types from "../types";
+export interface NonPendingJSON {
+    kind: "NonPending";
+}
+export declare class NonPending {
+    static readonly discriminator = 0;
+    static readonly kind = "NonPending";
+    readonly discriminator = 0;
+    readonly kind = "NonPending";
+    toJSON(): NonPendingJSON;
+    toEncodable(): {
+        NonPending: {};
+    };
+}
+export interface PendingJSON {
+    kind: "Pending";
+}
+export declare class Pending {
+    static readonly discriminator = 1;
+    static readonly kind = "Pending";
+    readonly discriminator = 1;
+    readonly kind = "Pending";
+    toJSON(): PendingJSON;
+    toEncodable(): {
+        Pending: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.BurnStateKind;
+export declare function fromJSON(obj: types.BurnStateJSON): types.BurnStateKind;
+export declare function layout(property?: string): any;

package/dist/types/types/BurnState.js

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

package/dist/types/types/BurnTrack.d.ts

@@ -0,0 +1,26 @@
+import * as types from "../types";
+export interface BurnTrackFields {
+    amount: number;
+    burnType: types.BurnTypeBurnKind;
+}
+export interface BurnTrackJSON {
+    amount: number;
+    burnType: types.BurnTypeBurnJSON;
+}
+export declare class BurnTrack {
+    readonly amount: number;
+    readonly burnType: types.BurnTypeBurnKind;
+    constructor(fields: BurnTrackFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): BurnTrack;
+    static toEncodable(fields: BurnTrackFields): {
+        amount: number;
+        burnType: any;
+    };
+    toJSON(): BurnTrackJSON;
+    static fromJSON(obj: BurnTrackJSON): BurnTrack;
+    toEncodable(): {
+        amount: number;
+        burnType: any;
+    };
+}

package/dist/types/types/BurnTrack.js

@@ -0,0 +1,39 @@
+import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh";
+export class BurnTrack {
+    constructor(fields) {
+        this.amount = fields.amount;
+        this.burnType = fields.burnType;
+    }
+    static layout(property) {
+        return borsh.struct([borsh.u16("amount"), types.BurnTypeBurn.layout("burnType")], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new BurnTrack({
+            amount: obj.amount,
+            burnType: types.BurnTypeBurn.fromDecoded(obj.burnType),
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            amount: fields.amount,
+            burnType: fields.burnType.toEncodable(),
+        };
+    }
+    toJSON() {
+        return {
+            amount: this.amount,
+            burnType: this.burnType.toJSON(),
+        };
+    }
+    static fromJSON(obj) {
+        return new BurnTrack({
+            amount: obj.amount,
+            burnType: types.BurnTypeBurn.fromJSON(obj.burnType),
+        });
+    }
+    toEncodable() {
+        return BurnTrack.toEncodable(this);
+    }
+}