3land_sdk 1.0.2 → 1.0.4

package/dist/types/types/TraitPassType.js

@@ -1,150 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,171 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,121 +0,0 @@
-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;
-}