3land_sdk 1.0.2 → 1.0.4

package/dist/types/types/PriceRule.d.ts

@@ -1,86 +0,0 @@
-import BN from "bn.js";
-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 AndJSON {
-    kind: "And";
-}
-export declare class And {
-    static readonly discriminator = 1;
-    static readonly kind = "And";
-    readonly discriminator = 1;
-    readonly kind = "And";
-    toJSON(): AndJSON;
-    toEncodable(): {
-        And: {};
-    };
-}
-export interface OrJSON {
-    kind: "Or";
-}
-export declare class Or {
-    static readonly discriminator = 2;
-    static readonly kind = "Or";
-    readonly discriminator = 2;
-    readonly kind = "Or";
-    toJSON(): OrJSON;
-    toEncodable(): {
-        Or: {};
-    };
-}
-export type BondingLinearFields = {
-    initial: BN;
-    rate: BN;
-    index: number;
-    max: number;
-    min: number;
-};
-export type BondingLinearValue = {
-    initial: BN;
-    rate: BN;
-    index: number;
-    max: number;
-    min: number;
-};
-export interface BondingLinearJSON {
-    kind: "BondingLinear";
-    value: {
-        initial: string;
-        rate: string;
-        index: number;
-        max: number;
-        min: number;
-    };
-}
-export declare class BondingLinear {
-    static readonly discriminator = 3;
-    static readonly kind = "BondingLinear";
-    readonly discriminator = 3;
-    readonly kind = "BondingLinear";
-    readonly value: BondingLinearValue;
-    constructor(value: BondingLinearFields);
-    toJSON(): BondingLinearJSON;
-    toEncodable(): {
-        BondingLinear: {
-            initial: BN;
-            rate: BN;
-            index: number;
-            max: number;
-            min: number;
-        };
-    };
-}
-export declare function fromDecoded(obj: any): types.PriceRuleKind;
-export declare function fromJSON(obj: types.PriceRuleJSON): types.PriceRuleKind;
-export declare function layout(property?: string): any;

package/dist/types/types/PriceRule.js

@@ -1,160 +0,0 @@
-import BN from "bn.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
-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 And {
-    constructor() {
-        this.discriminator = 1;
-        this.kind = "And";
-    }
-    toJSON() {
-        return {
-            kind: "And",
-        };
-    }
-    toEncodable() {
-        return {
-            And: {},
-        };
-    }
-}
-And.discriminator = 1;
-And.kind = "And";
-export class Or {
-    constructor() {
-        this.discriminator = 2;
-        this.kind = "Or";
-    }
-    toJSON() {
-        return {
-            kind: "Or",
-        };
-    }
-    toEncodable() {
-        return {
-            Or: {},
-        };
-    }
-}
-Or.discriminator = 2;
-Or.kind = "Or";
-export class BondingLinear {
-    constructor(value) {
-        this.discriminator = 3;
-        this.kind = "BondingLinear";
-        this.value = {
-            initial: value.initial,
-            rate: value.rate,
-            index: value.index,
-            max: value.max,
-            min: value.min,
-        };
-    }
-    toJSON() {
-        return {
-            kind: "BondingLinear",
-            value: {
-                initial: this.value.initial.toString(),
-                rate: this.value.rate.toString(),
-                index: this.value.index,
-                max: this.value.max,
-                min: this.value.min,
-            },
-        };
-    }
-    toEncodable() {
-        return {
-            BondingLinear: {
-                initial: this.value.initial,
-                rate: this.value.rate,
-                index: this.value.index,
-                max: this.value.max,
-                min: this.value.min,
-            },
-        };
-    }
-}
-BondingLinear.discriminator = 3;
-BondingLinear.kind = "BondingLinear";
-// 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 ("And" in obj) {
-        return new And();
-    }
-    if ("Or" in obj) {
-        return new Or();
-    }
-    if ("BondingLinear" in obj) {
-        const val = obj["BondingLinear"];
-        return new BondingLinear({
-            initial: val["initial"],
-            rate: val["rate"],
-            index: val["index"],
-            max: val["max"],
-            min: val["min"],
-        });
-    }
-    throw new Error("Invalid enum object");
-}
-export function fromJSON(obj) {
-    switch (obj.kind) {
-        case "None": {
-            return new None();
-        }
-        case "And": {
-            return new And();
-        }
-        case "Or": {
-            return new Or();
-        }
-        case "BondingLinear": {
-            return new BondingLinear({
-                initial: new BN(obj.value.initial),
-                rate: new BN(obj.value.rate),
-                index: obj.value.index,
-                max: obj.value.max,
-                min: obj.value.min,
-            });
-        }
-    }
-}
-export function layout(property) {
-    const ret = borsh.rustEnum([
-        borsh.struct([], "None"),
-        borsh.struct([], "And"),
-        borsh.struct([], "Or"),
-        borsh.struct([
-            borsh.u64("initial"),
-            borsh.u64("rate"),
-            borsh.u8("index"),
-            borsh.u32("max"),
-            borsh.u16("min"),
-        ], "BondingLinear"),
-    ]);
-    if (property !== undefined) {
-        return ret.replicate(property);
-    }
-    return ret;
-}

package/dist/types/types/RecoverDeposit.d.ts

@@ -1,21 +0,0 @@
-import * as types from "../types";
-export interface RecoverDepositFields {
-    cnft: types.CnftDataFields | null;
-}
-export interface RecoverDepositJSON {
-    cnft: types.CnftDataJSON | null;
-}
-export declare class RecoverDeposit {
-    readonly cnft: types.CnftData | null;
-    constructor(fields: RecoverDepositFields);
-    static layout(property?: string): any;
-    static fromDecoded(obj: any): RecoverDeposit;
-    static toEncodable(fields: RecoverDepositFields): {
-        cnft: any;
-    };
-    toJSON(): RecoverDepositJSON;
-    static fromJSON(obj: RecoverDepositJSON): RecoverDeposit;
-    toEncodable(): {
-        cnft: any;
-    };
-}

package/dist/types/types/RecoverDeposit.js

@@ -1,34 +0,0 @@
-import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
-import * as borsh from "@coral-xyz/borsh";
-export class RecoverDeposit {
-    constructor(fields) {
-        this.cnft = (fields.cnft && new types.CnftData(Object.assign({}, fields.cnft))) || null;
-    }
-    static layout(property) {
-        return borsh.struct([borsh.option(types.CnftData.layout(), "cnft")], property);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static fromDecoded(obj) {
-        return new RecoverDeposit({
-            cnft: (obj.cnft && types.CnftData.fromDecoded(obj.cnft)) || null,
-        });
-    }
-    static toEncodable(fields) {
-        return {
-            cnft: (fields.cnft && types.CnftData.toEncodable(fields.cnft)) || null,
-        };
-    }
-    toJSON() {
-        return {
-            cnft: (this.cnft && this.cnft.toJSON()) || null,
-        };
-    }
-    static fromJSON(obj) {
-        return new RecoverDeposit({
-            cnft: (obj.cnft && types.CnftData.fromJSON(obj.cnft)) || null,
-        });
-    }
-    toEncodable() {
-        return RecoverDeposit.toEncodable(this);
-    }
-}

package/dist/types/types/Rule.d.ts

@@ -1,82 +0,0 @@
-import * as types from "../types";
-export type UnlocksAfterFields = {
-    rule: types.ActionAfterKind;
-};
-export type UnlocksAfterValue = {
-    rule: types.ActionAfterKind;
-};
-export interface UnlocksAfterJSON {
-    kind: "UnlocksAfter";
-    value: {
-        rule: types.ActionAfterJSON;
-    };
-}
-export declare class UnlocksAfter {
-    static readonly discriminator = 0;
-    static readonly kind = "UnlocksAfter";
-    readonly discriminator = 0;
-    readonly kind = "UnlocksAfter";
-    readonly value: UnlocksAfterValue;
-    constructor(value: UnlocksAfterFields);
-    toJSON(): UnlocksAfterJSON;
-    toEncodable(): {
-        UnlocksAfter: {
-            rule: any;
-        };
-    };
-}
-export type UnwrapsAfterFields = {
-    rule: types.ActionAfterKind;
-};
-export type UnwrapsAfterValue = {
-    rule: types.ActionAfterKind;
-};
-export interface UnwrapsAfterJSON {
-    kind: "UnwrapsAfter";
-    value: {
-        rule: types.ActionAfterJSON;
-    };
-}
-export declare class UnwrapsAfter {
-    static readonly discriminator = 1;
-    static readonly kind = "UnwrapsAfter";
-    readonly discriminator = 1;
-    readonly kind = "UnwrapsAfter";
-    readonly value: UnwrapsAfterValue;
-    constructor(value: UnwrapsAfterFields);
-    toJSON(): UnwrapsAfterJSON;
-    toEncodable(): {
-        UnwrapsAfter: {
-            rule: any;
-        };
-    };
-}
-export type WrappedSourceFields = {
-    rule: types.WrappedSourceFields;
-};
-export type WrappedSourceValue = {
-    rule: types.WrappedSource;
-};
-export interface WrappedSourceJSON {
-    kind: "WrappedSource";
-    value: {
-        rule: types.WrappedSourceJSON;
-    };
-}
-export declare class WrappedSource {
-    static readonly discriminator = 2;
-    static readonly kind = "WrappedSource";
-    readonly discriminator = 2;
-    readonly kind = "WrappedSource";
-    readonly value: WrappedSourceValue;
-    constructor(value: WrappedSourceFields);
-    toJSON(): WrappedSourceJSON;
-    toEncodable(): {
-        WrappedSource: {
-            rule: any;
-        };
-    };
-}
-export declare function fromDecoded(obj: any): types.RuleKind;
-export declare function fromJSON(obj: types.RuleJSON): types.RuleKind;
-export declare function layout(property?: string): any;

package/dist/types/types/Rule.js

@@ -1,135 +0,0 @@
-import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
-import * as borsh from "@coral-xyz/borsh";
-export class UnlocksAfter {
-    constructor(value) {
-        this.discriminator = 0;
-        this.kind = "UnlocksAfter";
-        this.value = {
-            rule: value.rule,
-        };
-    }
-    toJSON() {
-        return {
-            kind: "UnlocksAfter",
-            value: {
-                rule: this.value.rule.toJSON(),
-            },
-        };
-    }
-    toEncodable() {
-        return {
-            UnlocksAfter: {
-                rule: this.value.rule.toEncodable(),
-            },
-        };
-    }
-}
-UnlocksAfter.discriminator = 0;
-UnlocksAfter.kind = "UnlocksAfter";
-export class UnwrapsAfter {
-    constructor(value) {
-        this.discriminator = 1;
-        this.kind = "UnwrapsAfter";
-        this.value = {
-            rule: value.rule,
-        };
-    }
-    toJSON() {
-        return {
-            kind: "UnwrapsAfter",
-            value: {
-                rule: this.value.rule.toJSON(),
-            },
-        };
-    }
-    toEncodable() {
-        return {
-            UnwrapsAfter: {
-                rule: this.value.rule.toEncodable(),
-            },
-        };
-    }
-}
-UnwrapsAfter.discriminator = 1;
-UnwrapsAfter.kind = "UnwrapsAfter";
-export class WrappedSource {
-    constructor(value) {
-        this.discriminator = 2;
-        this.kind = "WrappedSource";
-        this.value = {
-            rule: new types.WrappedSource(Object.assign({}, value.rule)),
-        };
-    }
-    toJSON() {
-        return {
-            kind: "WrappedSource",
-            value: {
-                rule: this.value.rule.toJSON(),
-            },
-        };
-    }
-    toEncodable() {
-        return {
-            WrappedSource: {
-                rule: types.WrappedSource.toEncodable(this.value.rule),
-            },
-        };
-    }
-}
-WrappedSource.discriminator = 2;
-WrappedSource.kind = "WrappedSource";
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function fromDecoded(obj) {
-    if (typeof obj !== "object") {
-        throw new Error("Invalid enum object");
-    }
-    if ("UnlocksAfter" in obj) {
-        const val = obj["UnlocksAfter"];
-        return new UnlocksAfter({
-            rule: types.ActionAfter.fromDecoded(val["rule"]),
-        });
-    }
-    if ("UnwrapsAfter" in obj) {
-        const val = obj["UnwrapsAfter"];
-        return new UnwrapsAfter({
-            rule: types.ActionAfter.fromDecoded(val["rule"]),
-        });
-    }
-    if ("WrappedSource" in obj) {
-        const val = obj["WrappedSource"];
-        return new WrappedSource({
-            rule: types.WrappedSource.fromDecoded(val["rule"]),
-        });
-    }
-    throw new Error("Invalid enum object");
-}
-export function fromJSON(obj) {
-    switch (obj.kind) {
-        case "UnlocksAfter": {
-            return new UnlocksAfter({
-                rule: types.ActionAfter.fromJSON(obj.value.rule),
-            });
-        }
-        case "UnwrapsAfter": {
-            return new UnwrapsAfter({
-                rule: types.ActionAfter.fromJSON(obj.value.rule),
-            });
-        }
-        case "WrappedSource": {
-            return new WrappedSource({
-                rule: types.WrappedSource.fromJSON(obj.value.rule),
-            });
-        }
-    }
-}
-export function layout(property) {
-    const ret = borsh.rustEnum([
-        borsh.struct([types.ActionAfter.layout("rule")], "UnlocksAfter"),
-        borsh.struct([types.ActionAfter.layout("rule")], "UnwrapsAfter"),
-        borsh.struct([types.WrappedSource.layout("rule")], "WrappedSource"),
-    ]);
-    if (property !== undefined) {
-        return ret.replicate(property);
-    }
-    return ret;
-}

package/dist/types/types/SaleConfig.d.ts

@@ -1,41 +0,0 @@
-import * as types from "../types";
-export interface SaleConfigFields {
-    prices: Array<types.PriceFields>;
-    priceType: types.PriceRuleKind;
-    rules: Array<types.RuleKind>;
-    sendToVault: number;
-    saleType: types.SaleTypeKind;
-}
-export interface SaleConfigJSON {
-    prices: Array<types.PriceJSON>;
-    priceType: types.PriceRuleJSON;
-    rules: Array<types.RuleJSON>;
-    sendToVault: number;
-    saleType: types.SaleTypeJSON;
-}
-export declare class SaleConfig {
-    readonly prices: Array<types.Price>;
-    readonly priceType: types.PriceRuleKind;
-    readonly rules: Array<types.RuleKind>;
-    readonly sendToVault: number;
-    readonly saleType: types.SaleTypeKind;
-    constructor(fields: SaleConfigFields);
-    static layout(property?: string): any;
-    static fromDecoded(obj: any): SaleConfig;
-    static toEncodable(fields: SaleConfigFields): {
-        prices: any[];
-        priceType: any;
-        rules: any[];
-        sendToVault: number;
-        saleType: any;
-    };
-    toJSON(): SaleConfigJSON;
-    static fromJSON(obj: SaleConfigJSON): SaleConfig;
-    toEncodable(): {
-        prices: any[];
-        priceType: any;
-        rules: any[];
-        sendToVault: number;
-        saleType: any;
-    };
-}

package/dist/types/types/SaleConfig.js

@@ -1,60 +0,0 @@
-import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
-import * as borsh from "@coral-xyz/borsh";
-export class SaleConfig {
-    constructor(fields) {
-        this.prices = fields.prices.map((item) => new types.Price(Object.assign({}, item)));
-        this.priceType = fields.priceType;
-        this.rules = fields.rules;
-        this.sendToVault = fields.sendToVault;
-        this.saleType = fields.saleType;
-    }
-    static layout(property) {
-        return borsh.struct([
-            borsh.vec(types.Price.layout(), "prices"),
-            types.PriceRule.layout("priceType"),
-            borsh.vec(types.Rule.layout(), "rules"),
-            borsh.u8("sendToVault"),
-            types.SaleType.layout("saleType"),
-        ], property);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static fromDecoded(obj) {
-        return new SaleConfig({
-            prices: obj.prices.map((item /* eslint-disable-line @typescript-eslint/no-explicit-any */) => types.Price.fromDecoded(item)),
-            priceType: types.PriceRule.fromDecoded(obj.priceType),
-            rules: obj.rules.map((item /* eslint-disable-line @typescript-eslint/no-explicit-any */) => types.Rule.fromDecoded(item)),
-            sendToVault: obj.sendToVault,
-            saleType: types.SaleType.fromDecoded(obj.saleType),
-        });
-    }
-    static toEncodable(fields) {
-        return {
-            prices: fields.prices.map((item) => types.Price.toEncodable(item)),
-            priceType: fields.priceType.toEncodable(),
-            rules: fields.rules.map((item) => item.toEncodable()),
-            sendToVault: fields.sendToVault,
-            saleType: fields.saleType.toEncodable(),
-        };
-    }
-    toJSON() {
-        return {
-            prices: this.prices.map((item) => item.toJSON()),
-            priceType: this.priceType.toJSON(),
-            rules: this.rules.map((item) => item.toJSON()),
-            sendToVault: this.sendToVault,
-            saleType: this.saleType.toJSON(),
-        };
-    }
-    static fromJSON(obj) {
-        return new SaleConfig({
-            prices: obj.prices.map((item) => types.Price.fromJSON(item)),
-            priceType: types.PriceRule.fromJSON(obj.priceType),
-            rules: obj.rules.map((item) => types.Rule.fromJSON(item)),
-            sendToVault: obj.sendToVault,
-            saleType: types.SaleType.fromJSON(obj.saleType),
-        });
-    }
-    toEncodable() {
-        return SaleConfig.toEncodable(this);
-    }
-}

package/dist/types/types/SaleTrack.d.ts

@@ -1,36 +0,0 @@
-import BN from "bn.js";
-export interface SaleTrackFields {
-    created: BN;
-    sold: BN;
-    earned: BN;
-    collectors: BN;
-}
-export interface SaleTrackJSON {
-    created: string;
-    sold: string;
-    earned: string;
-    collectors: string;
-}
-export declare class SaleTrack {
-    readonly created: BN;
-    readonly sold: BN;
-    readonly earned: BN;
-    readonly collectors: BN;
-    constructor(fields: SaleTrackFields);
-    static layout(property?: string): any;
-    static fromDecoded(obj: any): SaleTrack;
-    static toEncodable(fields: SaleTrackFields): {
-        created: BN;
-        sold: BN;
-        earned: BN;
-        collectors: BN;
-    };
-    toJSON(): SaleTrackJSON;
-    static fromJSON(obj: SaleTrackJSON): SaleTrack;
-    toEncodable(): {
-        created: BN;
-        sold: BN;
-        earned: BN;
-        collectors: BN;
-    };
-}