3land_sdk 1.0.0 → 1.0.2

package/dist/types/types/TraitPassType.js

@@ -0,0 +1,150 @@
+import BN from "bn.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh";
+export class SemiFungible {
+    constructor(value) {
+        this.discriminator = 0;
+        this.kind = "SemiFungible";
+        this.value = {
+            typeId: value.typeId,
+            amount: value.amount,
+        };
+    }
+    toJSON() {
+        return {
+            kind: "SemiFungible",
+            value: {
+                typeId: this.value.typeId,
+                amount: this.value.amount.toString(),
+            },
+        };
+    }
+    toEncodable() {
+        return {
+            SemiFungible: {
+                typeId: this.value.typeId,
+                amount: this.value.amount,
+            },
+        };
+    }
+}
+SemiFungible.discriminator = 0;
+SemiFungible.kind = "SemiFungible";
+export class Date {
+    constructor(value) {
+        this.discriminator = 1;
+        this.kind = "Date";
+        this.value = {
+            typeId: value.typeId,
+            date: value.date,
+        };
+    }
+    toJSON() {
+        return {
+            kind: "Date",
+            value: {
+                typeId: this.value.typeId,
+                date: this.value.date,
+            },
+        };
+    }
+    toEncodable() {
+        return {
+            Date: {
+                typeId: this.value.typeId,
+                date: this.value.date,
+            },
+        };
+    }
+}
+Date.discriminator = 1;
+Date.kind = "Date";
+export class NonFungible {
+    constructor(value) {
+        this.discriminator = 2;
+        this.kind = "NonFungible";
+        this.value = {
+            typeId: value.typeId,
+            valueId: value.valueId,
+        };
+    }
+    toJSON() {
+        return {
+            kind: "NonFungible",
+            value: {
+                typeId: this.value.typeId,
+                valueId: this.value.valueId,
+            },
+        };
+    }
+    toEncodable() {
+        return {
+            NonFungible: {
+                typeId: this.value.typeId,
+                valueId: this.value.valueId,
+            },
+        };
+    }
+}
+NonFungible.discriminator = 2;
+NonFungible.kind = "NonFungible";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj) {
+    if (typeof obj !== "object") {
+        throw new Error("Invalid enum object");
+    }
+    if ("SemiFungible" in obj) {
+        const val = obj["SemiFungible"];
+        return new SemiFungible({
+            typeId: val["typeId"],
+            amount: val["amount"],
+        });
+    }
+    if ("Date" in obj) {
+        const val = obj["Date"];
+        return new Date({
+            typeId: val["typeId"],
+            date: val["date"],
+        });
+    }
+    if ("NonFungible" in obj) {
+        const val = obj["NonFungible"];
+        return new NonFungible({
+            typeId: val["typeId"],
+            valueId: val["valueId"],
+        });
+    }
+    throw new Error("Invalid enum object");
+}
+export function fromJSON(obj) {
+    switch (obj.kind) {
+        case "SemiFungible": {
+            return new SemiFungible({
+                typeId: obj.value.typeId,
+                amount: new BN(obj.value.amount),
+            });
+        }
+        case "Date": {
+            return new Date({
+                typeId: obj.value.typeId,
+                date: obj.value.date,
+            });
+        }
+        case "NonFungible": {
+            return new NonFungible({
+                typeId: obj.value.typeId,
+                valueId: obj.value.valueId,
+            });
+        }
+    }
+}
+export function layout(property) {
+    const ret = borsh.rustEnum([
+        borsh.struct([borsh.u16("typeId"), borsh.u64("amount")], "SemiFungible"),
+        borsh.struct([borsh.u16("typeId"), borsh.u32("date")], "Date"),
+        borsh.struct([borsh.u16("typeId"), borsh.u16("valueId")], "NonFungible"),
+    ]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

package/dist/types/types/TraitType.d.ts

@@ -0,0 +1,107 @@
+import BN from "bn.js";
+import * as types from "../types";
+export type SemiFungibleFields = {
+    hash: BN;
+    count: number;
+    supply: BN;
+    total: BN;
+};
+export type SemiFungibleValue = {
+    hash: BN;
+    count: number;
+    supply: BN;
+    total: BN;
+};
+export interface SemiFungibleJSON {
+    kind: "SemiFungible";
+    value: {
+        hash: string;
+        count: number;
+        supply: string;
+        total: string;
+    };
+}
+export declare class SemiFungible {
+    static readonly discriminator = 0;
+    static readonly kind = "SemiFungible";
+    readonly discriminator = 0;
+    readonly kind = "SemiFungible";
+    readonly value: SemiFungibleValue;
+    constructor(value: SemiFungibleFields);
+    toJSON(): SemiFungibleJSON;
+    toEncodable(): {
+        SemiFungible: {
+            hash: BN;
+            count: number;
+            supply: BN;
+            total: BN;
+        };
+    };
+}
+export type DateFields = {
+    hash: BN;
+    count: number;
+    supply: BN;
+};
+export type DateValue = {
+    hash: BN;
+    count: number;
+    supply: BN;
+};
+export interface DateJSON {
+    kind: "Date";
+    value: {
+        hash: string;
+        count: number;
+        supply: string;
+    };
+}
+export declare class Date {
+    static readonly discriminator = 1;
+    static readonly kind = "Date";
+    readonly discriminator = 1;
+    readonly kind = "Date";
+    readonly value: DateValue;
+    constructor(value: DateFields);
+    toJSON(): DateJSON;
+    toEncodable(): {
+        Date: {
+            hash: BN;
+            count: number;
+            supply: BN;
+        };
+    };
+}
+export type NonFungibleFields = {
+    hash: BN;
+    values: Array<types.TraitValueFields>;
+};
+export type NonFungibleValue = {
+    hash: BN;
+    values: Array<types.TraitValue>;
+};
+export interface NonFungibleJSON {
+    kind: "NonFungible";
+    value: {
+        hash: string;
+        values: Array<types.TraitValueJSON>;
+    };
+}
+export declare class NonFungible {
+    static readonly discriminator = 2;
+    static readonly kind = "NonFungible";
+    readonly discriminator = 2;
+    readonly kind = "NonFungible";
+    readonly value: NonFungibleValue;
+    constructor(value: NonFungibleFields);
+    toJSON(): NonFungibleJSON;
+    toEncodable(): {
+        NonFungible: {
+            hash: BN;
+            values: any[];
+        };
+    };
+}
+export declare function fromDecoded(obj: any): types.TraitTypeKind;
+export declare function fromJSON(obj: types.TraitTypeJSON): types.TraitTypeKind;
+export declare function layout(property?: string): any;

package/dist/types/types/TraitType.js

@@ -0,0 +1,171 @@
+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 class SemiFungible {
+    constructor(value) {
+        this.discriminator = 0;
+        this.kind = "SemiFungible";
+        this.value = {
+            hash: value.hash,
+            count: value.count,
+            supply: value.supply,
+            total: value.total,
+        };
+    }
+    toJSON() {
+        return {
+            kind: "SemiFungible",
+            value: {
+                hash: this.value.hash.toString(),
+                count: this.value.count,
+                supply: this.value.supply.toString(),
+                total: this.value.total.toString(),
+            },
+        };
+    }
+    toEncodable() {
+        return {
+            SemiFungible: {
+                hash: this.value.hash,
+                count: this.value.count,
+                supply: this.value.supply,
+                total: this.value.total,
+            },
+        };
+    }
+}
+SemiFungible.discriminator = 0;
+SemiFungible.kind = "SemiFungible";
+export class Date {
+    constructor(value) {
+        this.discriminator = 1;
+        this.kind = "Date";
+        this.value = {
+            hash: value.hash,
+            count: value.count,
+            supply: value.supply,
+        };
+    }
+    toJSON() {
+        return {
+            kind: "Date",
+            value: {
+                hash: this.value.hash.toString(),
+                count: this.value.count,
+                supply: this.value.supply.toString(),
+            },
+        };
+    }
+    toEncodable() {
+        return {
+            Date: {
+                hash: this.value.hash,
+                count: this.value.count,
+                supply: this.value.supply,
+            },
+        };
+    }
+}
+Date.discriminator = 1;
+Date.kind = "Date";
+export class NonFungible {
+    constructor(value) {
+        this.discriminator = 2;
+        this.kind = "NonFungible";
+        this.value = {
+            hash: value.hash,
+            values: value.values.map((item) => new types.TraitValue(Object.assign({}, item))),
+        };
+    }
+    toJSON() {
+        return {
+            kind: "NonFungible",
+            value: {
+                hash: this.value.hash.toString(),
+                values: this.value.values.map((item) => item.toJSON()),
+            },
+        };
+    }
+    toEncodable() {
+        return {
+            NonFungible: {
+                hash: this.value.hash,
+                values: this.value.values.map((item) => types.TraitValue.toEncodable(item)),
+            },
+        };
+    }
+}
+NonFungible.discriminator = 2;
+NonFungible.kind = "NonFungible";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj) {
+    if (typeof obj !== "object") {
+        throw new Error("Invalid enum object");
+    }
+    if ("SemiFungible" in obj) {
+        const val = obj["SemiFungible"];
+        return new SemiFungible({
+            hash: val["hash"],
+            count: val["count"],
+            supply: val["supply"],
+            total: val["total"],
+        });
+    }
+    if ("Date" in obj) {
+        const val = obj["Date"];
+        return new Date({
+            hash: val["hash"],
+            count: val["count"],
+            supply: val["supply"],
+        });
+    }
+    if ("NonFungible" in obj) {
+        const val = obj["NonFungible"];
+        return new NonFungible({
+            hash: val["hash"],
+            values: val["values"].map((item /* eslint-disable-line @typescript-eslint/no-explicit-any */) => types.TraitValue.fromDecoded(item)),
+        });
+    }
+    throw new Error("Invalid enum object");
+}
+export function fromJSON(obj) {
+    switch (obj.kind) {
+        case "SemiFungible": {
+            return new SemiFungible({
+                hash: new BN(obj.value.hash),
+                count: obj.value.count,
+                supply: new BN(obj.value.supply),
+                total: new BN(obj.value.total),
+            });
+        }
+        case "Date": {
+            return new Date({
+                hash: new BN(obj.value.hash),
+                count: obj.value.count,
+                supply: new BN(obj.value.supply),
+            });
+        }
+        case "NonFungible": {
+            return new NonFungible({
+                hash: new BN(obj.value.hash),
+                values: obj.value.values.map((item) => types.TraitValue.fromJSON(item)),
+            });
+        }
+    }
+}
+export function layout(property) {
+    const ret = borsh.rustEnum([
+        borsh.struct([
+            borsh.u64("hash"),
+            borsh.u32("count"),
+            borsh.u64("supply"),
+            borsh.u64("total"),
+        ], "SemiFungible"),
+        borsh.struct([borsh.u64("hash"), borsh.u32("count"), borsh.u64("supply")], "Date"),
+        borsh.struct([borsh.u64("hash"), borsh.vec(types.TraitValue.layout(), "values")], "NonFungible"),
+    ]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

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

@@ -0,0 +1,31 @@
+import BN from "bn.js";
+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): 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/types/types/TraitValue.js

@@ -0,0 +1,44 @@
+import BN from "bn.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh";
+export 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(obj.hash),
+            count: obj.count,
+            supply: new BN(obj.supply),
+        });
+    }
+    toEncodable() {
+        return TraitValue.toEncodable(this);
+    }
+}

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

@@ -0,0 +1,69 @@
+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 declare function fromDecoded(obj: any): types.UnlocksAfterKind;
+export declare function fromJSON(obj: types.UnlocksAfterJSON): types.UnlocksAfterKind;
+export declare function layout(property?: string): any;

package/dist/types/types/UnlocksAfter.js

@@ -0,0 +1,121 @@
+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";
+// 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"],
+        });
+    }
+    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,
+            });
+        }
+    }
+}
+export 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;
+}