3land_sdk 1.0.0 → 1.0.2

package/dist/cjs/types/types/Rule.js

@@ -0,0 +1,167 @@
+"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.WrappedSource = exports.UnwrapsAfter = exports.UnlocksAfter = void 0;
+exports.fromDecoded = fromDecoded;
+exports.fromJSON = fromJSON;
+exports.layout = layout;
+const types = __importStar(require("../types")); // eslint-disable-line @typescript-eslint/no-unused-vars
+const borsh = __importStar(require("@coral-xyz/borsh"));
+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(),
+            },
+        };
+    }
+}
+exports.UnlocksAfter = UnlocksAfter;
+UnlocksAfter.discriminator = 0;
+UnlocksAfter.kind = "UnlocksAfter";
+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(),
+            },
+        };
+    }
+}
+exports.UnwrapsAfter = UnwrapsAfter;
+UnwrapsAfter.discriminator = 1;
+UnwrapsAfter.kind = "UnwrapsAfter";
+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),
+            },
+        };
+    }
+}
+exports.WrappedSource = WrappedSource;
+WrappedSource.discriminator = 2;
+WrappedSource.kind = "WrappedSource";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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");
+}
+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),
+            });
+        }
+    }
+}
+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/cjs/types/types/SaleConfig.d.ts

@@ -0,0 +1,207 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+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): types.SaleConfig;
+    static toEncodable(fields: SaleConfigFields): {
+        prices: {
+            amount: BN;
+            priceType: {
+                Native: {};
+            } | {
+                Spl: {
+                    id: PublicKey;
+                };
+            } | {
+                Collection: {
+                    id: PublicKey;
+                };
+            } | {
+                Creator: {
+                    id: PublicKey;
+                };
+            } | {
+                None: {};
+            };
+        }[];
+        priceType: {
+            None: {};
+        } | {
+            And: {};
+        } | {
+            Or: {};
+        } | {
+            BondingLinear: {
+                initial: BN;
+                rate: BN;
+                index: number;
+                max: number;
+                min: number;
+            };
+        };
+        rules: ({
+            UnlocksAfter: {
+                rule: {
+                    MintingOut: {};
+                } | {
+                    Supply: {
+                        limit: number;
+                    };
+                } | {
+                    Hours: {
+                        hours: number;
+                    };
+                } | {
+                    SellingOut: {};
+                };
+            };
+        } | {
+            UnwrapsAfter: {
+                rule: {
+                    MintingOut: {};
+                } | {
+                    Supply: {
+                        limit: number;
+                    };
+                } | {
+                    Hours: {
+                        hours: number;
+                    };
+                } | {
+                    SellingOut: {};
+                };
+            };
+        } | {
+            WrappedSource: {
+                rule: {
+                    pool: PublicKey;
+                    amount: BN;
+                    distribution: number;
+                    track: number;
+                };
+            };
+        })[];
+        sendToVault: number;
+        saleType: {
+            Normal: {};
+        } | {
+            NoMarketFee: {};
+        } | {
+            Partnership: {};
+        } | {
+            LocksInVault: {};
+        };
+    };
+    toJSON(): SaleConfigJSON;
+    static fromJSON(obj: SaleConfigJSON): SaleConfig;
+    toEncodable(): {
+        prices: {
+            amount: BN;
+            priceType: {
+                Native: {};
+            } | {
+                Spl: {
+                    id: PublicKey;
+                };
+            } | {
+                Collection: {
+                    id: PublicKey;
+                };
+            } | {
+                Creator: {
+                    id: PublicKey;
+                };
+            } | {
+                None: {};
+            };
+        }[];
+        priceType: {
+            None: {};
+        } | {
+            And: {};
+        } | {
+            Or: {};
+        } | {
+            BondingLinear: {
+                initial: BN;
+                rate: BN;
+                index: number;
+                max: number;
+                min: number;
+            };
+        };
+        rules: ({
+            UnlocksAfter: {
+                rule: {
+                    MintingOut: {};
+                } | {
+                    Supply: {
+                        limit: number;
+                    };
+                } | {
+                    Hours: {
+                        hours: number;
+                    };
+                } | {
+                    SellingOut: {};
+                };
+            };
+        } | {
+            UnwrapsAfter: {
+                rule: {
+                    MintingOut: {};
+                } | {
+                    Supply: {
+                        limit: number;
+                    };
+                } | {
+                    Hours: {
+                        hours: number;
+                    };
+                } | {
+                    SellingOut: {};
+                };
+            };
+        } | {
+            WrappedSource: {
+                rule: {
+                    pool: PublicKey;
+                    amount: BN;
+                    distribution: number;
+                    track: number;
+                };
+            };
+        })[];
+        sendToVault: number;
+        saleType: {
+            Normal: {};
+        } | {
+            NoMarketFee: {};
+        } | {
+            Partnership: {};
+        } | {
+            LocksInVault: {};
+        };
+    };
+}

package/dist/cjs/types/types/SaleConfig.js

@@ -0,0 +1,87 @@
+"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.SaleConfig = void 0;
+const types = __importStar(require("../types")); // eslint-disable-line @typescript-eslint/no-unused-vars
+const borsh = __importStar(require("@coral-xyz/borsh"));
+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);
+    }
+}
+exports.SaleConfig = SaleConfig;

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

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

package/dist/cjs/types/types/SaleTrack.js

@@ -0,0 +1,84 @@
+"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.SaleTrack = 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 SaleTrack {
+    constructor(fields) {
+        this.created = fields.created;
+        this.sold = fields.sold;
+        this.earned = fields.earned;
+        this.collectors = fields.collectors;
+    }
+    static layout(property) {
+        return borsh.struct([
+            borsh.u64("created"),
+            borsh.u64("sold"),
+            borsh.u64("earned"),
+            borsh.u64("collectors"),
+        ], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new SaleTrack({
+            created: obj.created,
+            sold: obj.sold,
+            earned: obj.earned,
+            collectors: obj.collectors,
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            created: fields.created,
+            sold: fields.sold,
+            earned: fields.earned,
+            collectors: fields.collectors,
+        };
+    }
+    toJSON() {
+        return {
+            created: this.created.toString(),
+            sold: this.sold.toString(),
+            earned: this.earned.toString(),
+            collectors: this.collectors.toString(),
+        };
+    }
+    static fromJSON(obj) {
+        return new SaleTrack({
+            created: new bn_js_1.default(obj.created),
+            sold: new bn_js_1.default(obj.sold),
+            earned: new bn_js_1.default(obj.earned),
+            collectors: new bn_js_1.default(obj.collectors),
+        });
+    }
+    toEncodable() {
+        return SaleTrack.toEncodable(this);
+    }
+}
+exports.SaleTrack = SaleTrack;

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

@@ -0,0 +1,57 @@
+import * as types from "../types";
+import * as borsh from "@coral-xyz/borsh";
+export interface NormalJSON {
+    kind: "Normal";
+}
+export declare class Normal {
+    static readonly discriminator = 0;
+    static readonly kind = "Normal";
+    readonly discriminator = 0;
+    readonly kind = "Normal";
+    toJSON(): NormalJSON;
+    toEncodable(): {
+        Normal: {};
+    };
+}
+export interface NoMarketFeeJSON {
+    kind: "NoMarketFee";
+}
+export declare class NoMarketFee {
+    static readonly discriminator = 1;
+    static readonly kind = "NoMarketFee";
+    readonly discriminator = 1;
+    readonly kind = "NoMarketFee";
+    toJSON(): NoMarketFeeJSON;
+    toEncodable(): {
+        NoMarketFee: {};
+    };
+}
+export interface PartnershipJSON {
+    kind: "Partnership";
+}
+export declare class Partnership {
+    static readonly discriminator = 2;
+    static readonly kind = "Partnership";
+    readonly discriminator = 2;
+    readonly kind = "Partnership";
+    toJSON(): PartnershipJSON;
+    toEncodable(): {
+        Partnership: {};
+    };
+}
+export interface LocksInVaultJSON {
+    kind: "LocksInVault";
+}
+export declare class LocksInVault {
+    static readonly discriminator = 3;
+    static readonly kind = "LocksInVault";
+    readonly discriminator = 3;
+    readonly kind = "LocksInVault";
+    toJSON(): LocksInVaultJSON;
+    toEncodable(): {
+        LocksInVault: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.SaleTypeKind;
+export declare function fromJSON(obj: types.SaleTypeJSON): types.SaleTypeKind;
+export declare function layout(property?: string): borsh.EnumLayout<unknown>;