3land_sdk 1.0.1 → 1.0.2

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

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

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

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

@@ -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 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

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

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

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

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

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