3land_sdk 1.0.0 → 1.0.2

package/dist/cjs/types/types/TraitValue.d.ts

@@ -0,0 +1,32 @@
+import BN from "bn.js";
+import * as types from "../types";
+export interface TraitValueFields {
+    hash: BN;
+    count: number;
+    supply: BN;
+}
+export interface TraitValueJSON {
+    hash: string;
+    count: number;
+    supply: string;
+}
+export declare class TraitValue {
+    readonly hash: BN;
+    readonly count: number;
+    readonly supply: BN;
+    constructor(fields: TraitValueFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): types.TraitValue;
+    static toEncodable(fields: TraitValueFields): {
+        hash: BN;
+        count: number;
+        supply: BN;
+    };
+    toJSON(): TraitValueJSON;
+    static fromJSON(obj: TraitValueJSON): TraitValue;
+    toEncodable(): {
+        hash: BN;
+        count: number;
+        supply: BN;
+    };
+}

package/dist/cjs/types/types/TraitValue.js

@@ -0,0 +1,74 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraitValue = void 0;
+const bn_js_1 = __importDefault(require("bn.js")); // eslint-disable-line @typescript-eslint/no-unused-vars
+const borsh = __importStar(require("@coral-xyz/borsh"));
+class TraitValue {
+    constructor(fields) {
+        this.hash = fields.hash;
+        this.count = fields.count;
+        this.supply = fields.supply;
+    }
+    static layout(property) {
+        return borsh.struct([borsh.u64("hash"), borsh.u32("count"), borsh.u64("supply")], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new TraitValue({
+            hash: obj.hash,
+            count: obj.count,
+            supply: obj.supply,
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            hash: fields.hash,
+            count: fields.count,
+            supply: fields.supply,
+        };
+    }
+    toJSON() {
+        return {
+            hash: this.hash.toString(),
+            count: this.count,
+            supply: this.supply.toString(),
+        };
+    }
+    static fromJSON(obj) {
+        return new TraitValue({
+            hash: new bn_js_1.default(obj.hash),
+            count: obj.count,
+            supply: new bn_js_1.default(obj.supply),
+        });
+    }
+    toEncodable() {
+        return TraitValue.toEncodable(this);
+    }
+}
+exports.TraitValue = TraitValue;

package/dist/cjs/types/types/UnlocksAfter.d.ts

@@ -0,0 +1,70 @@
+import * as types from "../types";
+import * as borsh from "@coral-xyz/borsh";
+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 declare function fromDecoded(obj: any): types.UnlocksAfterKind;
+export declare function fromJSON(obj: types.UnlocksAfterJSON): types.UnlocksAfterKind;
+export declare function layout(property?: string): borsh.EnumLayout<unknown>;

package/dist/cjs/types/types/UnlocksAfter.js

@@ -0,0 +1,153 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hours = exports.Supply = exports.MintingOut = void 0;
+exports.fromDecoded = fromDecoded;
+exports.fromJSON = fromJSON;
+exports.layout = layout;
+const borsh = __importStar(require("@coral-xyz/borsh"));
+class MintingOut {
+    constructor() {
+        this.discriminator = 0;
+        this.kind = "MintingOut";
+    }
+    toJSON() {
+        return {
+            kind: "MintingOut",
+        };
+    }
+    toEncodable() {
+        return {
+            MintingOut: {},
+        };
+    }
+}
+exports.MintingOut = MintingOut;
+MintingOut.discriminator = 0;
+MintingOut.kind = "MintingOut";
+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,
+            },
+        };
+    }
+}
+exports.Supply = Supply;
+Supply.discriminator = 1;
+Supply.kind = "Supply";
+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,
+            },
+        };
+    }
+}
+exports.Hours = Hours;
+Hours.discriminator = 2;
+Hours.kind = "Hours";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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"],
+        });
+    }
+    throw new Error("Invalid enum object");
+}
+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,
+            });
+        }
+    }
+}
+function layout(property) {
+    const ret = borsh.rustEnum([
+        borsh.struct([], "MintingOut"),
+        borsh.struct([borsh.u32("limit")], "Supply"),
+        borsh.struct([borsh.u16("hours")], "Hours"),
+    ]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

package/dist/cjs/types/types/UnwrapMetadata.d.ts

@@ -0,0 +1,79 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import * as types from "../types";
+export interface UnwrapMetadataFields {
+    wrappedAmount: BN;
+    decimals: number;
+    traitHash: BN;
+    name: string;
+    arweave: string;
+    edition: number;
+    leafIndex: number;
+    cardIndex: number | null;
+    royalty: number;
+    creators: Array<types.ShortCreatorFields>;
+    bumps: Array<number>;
+}
+export interface UnwrapMetadataJSON {
+    wrappedAmount: string;
+    decimals: number;
+    traitHash: string;
+    name: string;
+    arweave: string;
+    edition: number;
+    leafIndex: number;
+    cardIndex: number | null;
+    royalty: number;
+    creators: Array<types.ShortCreatorJSON>;
+    bumps: Array<number>;
+}
+export declare class UnwrapMetadata {
+    readonly wrappedAmount: BN;
+    readonly decimals: number;
+    readonly traitHash: BN;
+    readonly name: string;
+    readonly arweave: string;
+    readonly edition: number;
+    readonly leafIndex: number;
+    readonly cardIndex: number | null;
+    readonly royalty: number;
+    readonly creators: Array<types.ShortCreator>;
+    readonly bumps: Array<number>;
+    constructor(fields: UnwrapMetadataFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): types.UnwrapMetadata;
+    static toEncodable(fields: UnwrapMetadataFields): {
+        wrappedAmount: BN;
+        decimals: number;
+        traitHash: BN;
+        name: string;
+        arweave: string;
+        edition: number;
+        leafIndex: number;
+        cardIndex: number | null;
+        royalty: number;
+        creators: {
+            address: PublicKey;
+            share: number;
+        }[];
+        bumps: number[];
+    };
+    toJSON(): UnwrapMetadataJSON;
+    static fromJSON(obj: UnwrapMetadataJSON): UnwrapMetadata;
+    toEncodable(): {
+        wrappedAmount: BN;
+        decimals: number;
+        traitHash: BN;
+        name: string;
+        arweave: string;
+        edition: number;
+        leafIndex: number;
+        cardIndex: number | null;
+        royalty: number;
+        creators: {
+            address: PublicKey;
+            share: number;
+        }[];
+        bumps: number[];
+    };
+}

package/dist/cjs/types/types/UnwrapMetadata.js

@@ -0,0 +1,127 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnwrapMetadata = void 0;
+const bn_js_1 = __importDefault(require("bn.js")); // eslint-disable-line @typescript-eslint/no-unused-vars
+const types = __importStar(require("../types")); // eslint-disable-line @typescript-eslint/no-unused-vars
+const borsh = __importStar(require("@coral-xyz/borsh"));
+class UnwrapMetadata {
+    constructor(fields) {
+        this.wrappedAmount = fields.wrappedAmount;
+        this.decimals = fields.decimals;
+        this.traitHash = fields.traitHash;
+        this.name = fields.name;
+        this.arweave = fields.arweave;
+        this.edition = fields.edition;
+        this.leafIndex = fields.leafIndex;
+        this.cardIndex = fields.cardIndex;
+        this.royalty = fields.royalty;
+        this.creators = fields.creators.map((item) => new types.ShortCreator(Object.assign({}, item)));
+        this.bumps = fields.bumps;
+    }
+    static layout(property) {
+        return borsh.struct([
+            borsh.u64("wrappedAmount"),
+            borsh.u8("decimals"),
+            borsh.u64("traitHash"),
+            borsh.str("name"),
+            borsh.str("arweave"),
+            borsh.u32("edition"),
+            borsh.u32("leafIndex"),
+            borsh.option(borsh.u32(), "cardIndex"),
+            borsh.u16("royalty"),
+            borsh.vec(types.ShortCreator.layout(), "creators"),
+            borsh.array(borsh.u8(), 2, "bumps"),
+        ], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new UnwrapMetadata({
+            wrappedAmount: obj.wrappedAmount,
+            decimals: obj.decimals,
+            traitHash: obj.traitHash,
+            name: obj.name,
+            arweave: obj.arweave,
+            edition: obj.edition,
+            leafIndex: obj.leafIndex,
+            cardIndex: obj.cardIndex,
+            royalty: obj.royalty,
+            creators: obj.creators.map((item /* eslint-disable-line @typescript-eslint/no-explicit-any */) => types.ShortCreator.fromDecoded(item)),
+            bumps: obj.bumps,
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            wrappedAmount: fields.wrappedAmount,
+            decimals: fields.decimals,
+            traitHash: fields.traitHash,
+            name: fields.name,
+            arweave: fields.arweave,
+            edition: fields.edition,
+            leafIndex: fields.leafIndex,
+            cardIndex: fields.cardIndex,
+            royalty: fields.royalty,
+            creators: fields.creators.map((item) => types.ShortCreator.toEncodable(item)),
+            bumps: fields.bumps,
+        };
+    }
+    toJSON() {
+        return {
+            wrappedAmount: this.wrappedAmount.toString(),
+            decimals: this.decimals,
+            traitHash: this.traitHash.toString(),
+            name: this.name,
+            arweave: this.arweave,
+            edition: this.edition,
+            leafIndex: this.leafIndex,
+            cardIndex: this.cardIndex,
+            royalty: this.royalty,
+            creators: this.creators.map((item) => item.toJSON()),
+            bumps: this.bumps,
+        };
+    }
+    static fromJSON(obj) {
+        return new UnwrapMetadata({
+            wrappedAmount: new bn_js_1.default(obj.wrappedAmount),
+            decimals: obj.decimals,
+            traitHash: new bn_js_1.default(obj.traitHash),
+            name: obj.name,
+            arweave: obj.arweave,
+            edition: obj.edition,
+            leafIndex: obj.leafIndex,
+            cardIndex: obj.cardIndex,
+            royalty: obj.royalty,
+            creators: obj.creators.map((item) => types.ShortCreator.fromJSON(item)),
+            bumps: obj.bumps,
+        });
+    }
+    toEncodable() {
+        return UnwrapMetadata.toEncodable(this);
+    }
+}
+exports.UnwrapMetadata = UnwrapMetadata;

package/dist/cjs/types/types/UseMethod.d.ts

@@ -0,0 +1,44 @@
+import * as types from "../types";
+import * as borsh from "@coral-xyz/borsh";
+export interface BurnJSON {
+    kind: "Burn";
+}
+export declare class Burn {
+    static readonly discriminator = 0;
+    static readonly kind = "Burn";
+    readonly discriminator = 0;
+    readonly kind = "Burn";
+    toJSON(): BurnJSON;
+    toEncodable(): {
+        Burn: {};
+    };
+}
+export interface MultipleJSON {
+    kind: "Multiple";
+}
+export declare class Multiple {
+    static readonly discriminator = 1;
+    static readonly kind = "Multiple";
+    readonly discriminator = 1;
+    readonly kind = "Multiple";
+    toJSON(): MultipleJSON;
+    toEncodable(): {
+        Multiple: {};
+    };
+}
+export interface SingleJSON {
+    kind: "Single";
+}
+export declare class Single {
+    static readonly discriminator = 2;
+    static readonly kind = "Single";
+    readonly discriminator = 2;
+    readonly kind = "Single";
+    toJSON(): SingleJSON;
+    toEncodable(): {
+        Single: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.UseMethodKind;
+export declare function fromJSON(obj: types.UseMethodJSON): types.UseMethodKind;
+export declare function layout(property?: string): borsh.EnumLayout<unknown>;

package/dist/cjs/types/types/UseMethod.js

@@ -0,0 +1,127 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Single = exports.Multiple = exports.Burn = void 0;
+exports.fromDecoded = fromDecoded;
+exports.fromJSON = fromJSON;
+exports.layout = layout;
+const borsh = __importStar(require("@coral-xyz/borsh"));
+class Burn {
+    constructor() {
+        this.discriminator = 0;
+        this.kind = "Burn";
+    }
+    toJSON() {
+        return {
+            kind: "Burn",
+        };
+    }
+    toEncodable() {
+        return {
+            Burn: {},
+        };
+    }
+}
+exports.Burn = Burn;
+Burn.discriminator = 0;
+Burn.kind = "Burn";
+class Multiple {
+    constructor() {
+        this.discriminator = 1;
+        this.kind = "Multiple";
+    }
+    toJSON() {
+        return {
+            kind: "Multiple",
+        };
+    }
+    toEncodable() {
+        return {
+            Multiple: {},
+        };
+    }
+}
+exports.Multiple = Multiple;
+Multiple.discriminator = 1;
+Multiple.kind = "Multiple";
+class Single {
+    constructor() {
+        this.discriminator = 2;
+        this.kind = "Single";
+    }
+    toJSON() {
+        return {
+            kind: "Single",
+        };
+    }
+    toEncodable() {
+        return {
+            Single: {},
+        };
+    }
+}
+exports.Single = Single;
+Single.discriminator = 2;
+Single.kind = "Single";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function fromDecoded(obj) {
+    if (typeof obj !== "object") {
+        throw new Error("Invalid enum object");
+    }
+    if ("Burn" in obj) {
+        return new Burn();
+    }
+    if ("Multiple" in obj) {
+        return new Multiple();
+    }
+    if ("Single" in obj) {
+        return new Single();
+    }
+    throw new Error("Invalid enum object");
+}
+function fromJSON(obj) {
+    switch (obj.kind) {
+        case "Burn": {
+            return new Burn();
+        }
+        case "Multiple": {
+            return new Multiple();
+        }
+        case "Single": {
+            return new Single();
+        }
+    }
+}
+function layout(property) {
+    const ret = borsh.rustEnum([
+        borsh.struct([], "Burn"),
+        borsh.struct([], "Multiple"),
+        borsh.struct([], "Single"),
+    ]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}