3land_sdk 1.0.0 → 1.0.2

package/dist/types/types/PopularityState.js

@@ -0,0 +1,520 @@
+import * as borsh from "@coral-xyz/borsh";
+export class New {
+    constructor() {
+        this.discriminator = 0;
+        this.kind = "New";
+    }
+    toJSON() {
+        return {
+            kind: "New",
+        };
+    }
+    toEncodable() {
+        return {
+            New: {},
+        };
+    }
+}
+New.discriminator = 0;
+New.kind = "New";
+export class None {
+    constructor() {
+        this.discriminator = 1;
+        this.kind = "None";
+    }
+    toJSON() {
+        return {
+            kind: "None",
+        };
+    }
+    toEncodable() {
+        return {
+            None: {},
+        };
+    }
+}
+None.discriminator = 1;
+None.kind = "None";
+export class First {
+    constructor() {
+        this.discriminator = 2;
+        this.kind = "First";
+    }
+    toJSON() {
+        return {
+            kind: "First",
+        };
+    }
+    toEncodable() {
+        return {
+            First: {},
+        };
+    }
+}
+First.discriminator = 2;
+First.kind = "First";
+export class Ten {
+    constructor() {
+        this.discriminator = 3;
+        this.kind = "Ten";
+    }
+    toJSON() {
+        return {
+            kind: "Ten",
+        };
+    }
+    toEncodable() {
+        return {
+            Ten: {},
+        };
+    }
+}
+Ten.discriminator = 3;
+Ten.kind = "Ten";
+export class TwentyFive {
+    constructor() {
+        this.discriminator = 4;
+        this.kind = "TwentyFive";
+    }
+    toJSON() {
+        return {
+            kind: "TwentyFive",
+        };
+    }
+    toEncodable() {
+        return {
+            TwentyFive: {},
+        };
+    }
+}
+TwentyFive.discriminator = 4;
+TwentyFive.kind = "TwentyFive";
+export class Hundred {
+    constructor() {
+        this.discriminator = 5;
+        this.kind = "Hundred";
+    }
+    toJSON() {
+        return {
+            kind: "Hundred",
+        };
+    }
+    toEncodable() {
+        return {
+            Hundred: {},
+        };
+    }
+}
+Hundred.discriminator = 5;
+Hundred.kind = "Hundred";
+export class Thousand {
+    constructor() {
+        this.discriminator = 6;
+        this.kind = "Thousand";
+    }
+    toJSON() {
+        return {
+            kind: "Thousand",
+        };
+    }
+    toEncodable() {
+        return {
+            Thousand: {},
+        };
+    }
+}
+Thousand.discriminator = 6;
+Thousand.kind = "Thousand";
+export class TenThousand {
+    constructor() {
+        this.discriminator = 7;
+        this.kind = "TenThousand";
+    }
+    toJSON() {
+        return {
+            kind: "TenThousand",
+        };
+    }
+    toEncodable() {
+        return {
+            TenThousand: {},
+        };
+    }
+}
+TenThousand.discriminator = 7;
+TenThousand.kind = "TenThousand";
+export class HundredThousand {
+    constructor() {
+        this.discriminator = 8;
+        this.kind = "HundredThousand";
+    }
+    toJSON() {
+        return {
+            kind: "HundredThousand",
+        };
+    }
+    toEncodable() {
+        return {
+            HundredThousand: {},
+        };
+    }
+}
+HundredThousand.discriminator = 8;
+HundredThousand.kind = "HundredThousand";
+export class Million {
+    constructor() {
+        this.discriminator = 9;
+        this.kind = "Million";
+    }
+    toJSON() {
+        return {
+            kind: "Million",
+        };
+    }
+    toEncodable() {
+        return {
+            Million: {},
+        };
+    }
+}
+Million.discriminator = 9;
+Million.kind = "Million";
+export class TenMillion {
+    constructor() {
+        this.discriminator = 10;
+        this.kind = "TenMillion";
+    }
+    toJSON() {
+        return {
+            kind: "TenMillion",
+        };
+    }
+    toEncodable() {
+        return {
+            TenMillion: {},
+        };
+    }
+}
+TenMillion.discriminator = 10;
+TenMillion.kind = "TenMillion";
+export class HundredMillion {
+    constructor() {
+        this.discriminator = 11;
+        this.kind = "HundredMillion";
+    }
+    toJSON() {
+        return {
+            kind: "HundredMillion",
+        };
+    }
+    toEncodable() {
+        return {
+            HundredMillion: {},
+        };
+    }
+}
+HundredMillion.discriminator = 11;
+HundredMillion.kind = "HundredMillion";
+export class Billion {
+    constructor() {
+        this.discriminator = 12;
+        this.kind = "Billion";
+    }
+    toJSON() {
+        return {
+            kind: "Billion",
+        };
+    }
+    toEncodable() {
+        return {
+            Billion: {},
+        };
+    }
+}
+Billion.discriminator = 12;
+Billion.kind = "Billion";
+export class TenBillion {
+    constructor() {
+        this.discriminator = 13;
+        this.kind = "TenBillion";
+    }
+    toJSON() {
+        return {
+            kind: "TenBillion",
+        };
+    }
+    toEncodable() {
+        return {
+            TenBillion: {},
+        };
+    }
+}
+TenBillion.discriminator = 13;
+TenBillion.kind = "TenBillion";
+export class HundrerBillion {
+    constructor() {
+        this.discriminator = 14;
+        this.kind = "HundrerBillion";
+    }
+    toJSON() {
+        return {
+            kind: "HundrerBillion",
+        };
+    }
+    toEncodable() {
+        return {
+            HundrerBillion: {},
+        };
+    }
+}
+HundrerBillion.discriminator = 14;
+HundrerBillion.kind = "HundrerBillion";
+export class Trillion {
+    constructor() {
+        this.discriminator = 15;
+        this.kind = "Trillion";
+    }
+    toJSON() {
+        return {
+            kind: "Trillion",
+        };
+    }
+    toEncodable() {
+        return {
+            Trillion: {},
+        };
+    }
+}
+Trillion.discriminator = 15;
+Trillion.kind = "Trillion";
+export class TenTrillion {
+    constructor() {
+        this.discriminator = 16;
+        this.kind = "TenTrillion";
+    }
+    toJSON() {
+        return {
+            kind: "TenTrillion",
+        };
+    }
+    toEncodable() {
+        return {
+            TenTrillion: {},
+        };
+    }
+}
+TenTrillion.discriminator = 16;
+TenTrillion.kind = "TenTrillion";
+export class HundredTrillion {
+    constructor() {
+        this.discriminator = 17;
+        this.kind = "HundredTrillion";
+    }
+    toJSON() {
+        return {
+            kind: "HundredTrillion",
+        };
+    }
+    toEncodable() {
+        return {
+            HundredTrillion: {},
+        };
+    }
+}
+HundredTrillion.discriminator = 17;
+HundredTrillion.kind = "HundredTrillion";
+export class Highest {
+    constructor() {
+        this.discriminator = 18;
+        this.kind = "Highest";
+    }
+    toJSON() {
+        return {
+            kind: "Highest",
+        };
+    }
+    toEncodable() {
+        return {
+            Highest: {},
+        };
+    }
+}
+Highest.discriminator = 18;
+Highest.kind = "Highest";
+export class Banned {
+    constructor() {
+        this.discriminator = 19;
+        this.kind = "Banned";
+    }
+    toJSON() {
+        return {
+            kind: "Banned",
+        };
+    }
+    toEncodable() {
+        return {
+            Banned: {},
+        };
+    }
+}
+Banned.discriminator = 19;
+Banned.kind = "Banned";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj) {
+    if (typeof obj !== "object") {
+        throw new Error("Invalid enum object");
+    }
+    if ("New" in obj) {
+        return new New();
+    }
+    if ("None" in obj) {
+        return new None();
+    }
+    if ("First" in obj) {
+        return new First();
+    }
+    if ("Ten" in obj) {
+        return new Ten();
+    }
+    if ("TwentyFive" in obj) {
+        return new TwentyFive();
+    }
+    if ("Hundred" in obj) {
+        return new Hundred();
+    }
+    if ("Thousand" in obj) {
+        return new Thousand();
+    }
+    if ("TenThousand" in obj) {
+        return new TenThousand();
+    }
+    if ("HundredThousand" in obj) {
+        return new HundredThousand();
+    }
+    if ("Million" in obj) {
+        return new Million();
+    }
+    if ("TenMillion" in obj) {
+        return new TenMillion();
+    }
+    if ("HundredMillion" in obj) {
+        return new HundredMillion();
+    }
+    if ("Billion" in obj) {
+        return new Billion();
+    }
+    if ("TenBillion" in obj) {
+        return new TenBillion();
+    }
+    if ("HundrerBillion" in obj) {
+        return new HundrerBillion();
+    }
+    if ("Trillion" in obj) {
+        return new Trillion();
+    }
+    if ("TenTrillion" in obj) {
+        return new TenTrillion();
+    }
+    if ("HundredTrillion" in obj) {
+        return new HundredTrillion();
+    }
+    if ("Highest" in obj) {
+        return new Highest();
+    }
+    if ("Banned" in obj) {
+        return new Banned();
+    }
+    throw new Error("Invalid enum object");
+}
+export function fromJSON(obj) {
+    switch (obj.kind) {
+        case "New": {
+            return new New();
+        }
+        case "None": {
+            return new None();
+        }
+        case "First": {
+            return new First();
+        }
+        case "Ten": {
+            return new Ten();
+        }
+        case "TwentyFive": {
+            return new TwentyFive();
+        }
+        case "Hundred": {
+            return new Hundred();
+        }
+        case "Thousand": {
+            return new Thousand();
+        }
+        case "TenThousand": {
+            return new TenThousand();
+        }
+        case "HundredThousand": {
+            return new HundredThousand();
+        }
+        case "Million": {
+            return new Million();
+        }
+        case "TenMillion": {
+            return new TenMillion();
+        }
+        case "HundredMillion": {
+            return new HundredMillion();
+        }
+        case "Billion": {
+            return new Billion();
+        }
+        case "TenBillion": {
+            return new TenBillion();
+        }
+        case "HundrerBillion": {
+            return new HundrerBillion();
+        }
+        case "Trillion": {
+            return new Trillion();
+        }
+        case "TenTrillion": {
+            return new TenTrillion();
+        }
+        case "HundredTrillion": {
+            return new HundredTrillion();
+        }
+        case "Highest": {
+            return new Highest();
+        }
+        case "Banned": {
+            return new Banned();
+        }
+    }
+}
+export function layout(property) {
+    const ret = borsh.rustEnum([
+        borsh.struct([], "New"),
+        borsh.struct([], "None"),
+        borsh.struct([], "First"),
+        borsh.struct([], "Ten"),
+        borsh.struct([], "TwentyFive"),
+        borsh.struct([], "Hundred"),
+        borsh.struct([], "Thousand"),
+        borsh.struct([], "TenThousand"),
+        borsh.struct([], "HundredThousand"),
+        borsh.struct([], "Million"),
+        borsh.struct([], "TenMillion"),
+        borsh.struct([], "HundredMillion"),
+        borsh.struct([], "Billion"),
+        borsh.struct([], "TenBillion"),
+        borsh.struct([], "HundrerBillion"),
+        borsh.struct([], "Trillion"),
+        borsh.struct([], "TenTrillion"),
+        borsh.struct([], "HundredTrillion"),
+        borsh.struct([], "Highest"),
+        borsh.struct([], "Banned"),
+    ]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

package/dist/types/types/PreviousDonationRecord.d.ts

@@ -0,0 +1,32 @@
+import BN from "bn.js";
+import * as types from "../types";
+export interface PreviousDonationRecordFields {
+    cnft: types.CnftDataFields;
+    amount: BN;
+    message: string;
+}
+export interface PreviousDonationRecordJSON {
+    cnft: types.CnftDataJSON;
+    amount: string;
+    message: string;
+}
+export declare class PreviousDonationRecord {
+    readonly cnft: types.CnftData;
+    readonly amount: BN;
+    readonly message: string;
+    constructor(fields: PreviousDonationRecordFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): PreviousDonationRecord;
+    static toEncodable(fields: PreviousDonationRecordFields): {
+        cnft: any;
+        amount: BN;
+        message: string;
+    };
+    toJSON(): PreviousDonationRecordJSON;
+    static fromJSON(obj: PreviousDonationRecordJSON): PreviousDonationRecord;
+    toEncodable(): {
+        cnft: any;
+        amount: BN;
+        message: string;
+    };
+}

package/dist/types/types/PreviousDonationRecord.js

@@ -0,0 +1,49 @@
+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 PreviousDonationRecord {
+    constructor(fields) {
+        this.cnft = new types.CnftData(Object.assign({}, fields.cnft));
+        this.amount = fields.amount;
+        this.message = fields.message;
+    }
+    static layout(property) {
+        return borsh.struct([
+            types.CnftData.layout("cnft"),
+            borsh.u64("amount"),
+            borsh.str("message"),
+        ], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new PreviousDonationRecord({
+            cnft: types.CnftData.fromDecoded(obj.cnft),
+            amount: obj.amount,
+            message: obj.message,
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            cnft: types.CnftData.toEncodable(fields.cnft),
+            amount: fields.amount,
+            message: fields.message,
+        };
+    }
+    toJSON() {
+        return {
+            cnft: this.cnft.toJSON(),
+            amount: this.amount.toString(),
+            message: this.message,
+        };
+    }
+    static fromJSON(obj) {
+        return new PreviousDonationRecord({
+            cnft: types.CnftData.fromJSON(obj.cnft),
+            amount: new BN(obj.amount),
+            message: obj.message,
+        });
+    }
+    toEncodable() {
+        return PreviousDonationRecord.toEncodable(this);
+    }
+}

package/dist/types/types/Price.d.ts

@@ -0,0 +1,27 @@
+import BN from "bn.js";
+import * as types from "../types";
+export interface PriceFields {
+    amount: BN;
+    priceType: types.CurrencyTypeKind;
+}
+export interface PriceJSON {
+    amount: string;
+    priceType: types.CurrencyTypeJSON;
+}
+export declare class Price {
+    readonly amount: BN;
+    readonly priceType: types.CurrencyTypeKind;
+    constructor(fields: PriceFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): Price;
+    static toEncodable(fields: PriceFields): {
+        amount: BN;
+        priceType: any;
+    };
+    toJSON(): PriceJSON;
+    static fromJSON(obj: PriceJSON): Price;
+    toEncodable(): {
+        amount: BN;
+        priceType: any;
+    };
+}

package/dist/types/types/Price.js

@@ -0,0 +1,40 @@
+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 Price {
+    constructor(fields) {
+        this.amount = fields.amount;
+        this.priceType = fields.priceType;
+    }
+    static layout(property) {
+        return borsh.struct([borsh.u64("amount"), types.CurrencyType.layout("priceType")], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new Price({
+            amount: obj.amount,
+            priceType: types.CurrencyType.fromDecoded(obj.priceType),
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            amount: fields.amount,
+            priceType: fields.priceType.toEncodable(),
+        };
+    }
+    toJSON() {
+        return {
+            amount: this.amount.toString(),
+            priceType: this.priceType.toJSON(),
+        };
+    }
+    static fromJSON(obj) {
+        return new Price({
+            amount: new BN(obj.amount),
+            priceType: types.CurrencyType.fromJSON(obj.priceType),
+        });
+    }
+    toEncodable() {
+        return Price.toEncodable(this);
+    }
+}