3land_sdk 1.0.0 → 1.0.2

package/dist/types/types/ShortMetadata.js

@@ -0,0 +1,90 @@
+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 ShortMetadata {
+    constructor(fields) {
+        this.index = fields.index;
+        this.supply = fields.supply;
+        this.traitHash = fields.traitHash;
+        this.name = fields.name;
+        this.arweave = fields.arweave;
+        this.traitPass =
+            (fields.traitPass && new types.TraitPass(Object.assign({}, fields.traitPass))) || null;
+        this.royalty = fields.royalty;
+        this.creators =
+            (fields.creators &&
+                fields.creators.map((item) => new types.ShortCreator(Object.assign({}, item)))) ||
+                null;
+    }
+    static layout(property) {
+        return borsh.struct([
+            borsh.u32("index"),
+            borsh.option(borsh.u64(), "supply"),
+            borsh.u64("traitHash"),
+            borsh.str("name"),
+            borsh.str("arweave"),
+            borsh.option(types.TraitPass.layout(), "traitPass"),
+            borsh.option(borsh.u16(), "royalty"),
+            borsh.option(borsh.vec(types.ShortCreator.layout()), "creators"),
+        ], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new ShortMetadata({
+            index: obj.index,
+            supply: obj.supply,
+            traitHash: obj.traitHash,
+            name: obj.name,
+            arweave: obj.arweave,
+            traitPass: (obj.traitPass && types.TraitPass.fromDecoded(obj.traitPass)) || null,
+            royalty: obj.royalty,
+            creators: (obj.creators &&
+                obj.creators.map((item /* eslint-disable-line @typescript-eslint/no-explicit-any */) => types.ShortCreator.fromDecoded(item))) ||
+                null,
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            index: fields.index,
+            supply: fields.supply,
+            traitHash: fields.traitHash,
+            name: fields.name,
+            arweave: fields.arweave,
+            traitPass: (fields.traitPass && types.TraitPass.toEncodable(fields.traitPass)) ||
+                null,
+            royalty: fields.royalty,
+            creators: (fields.creators &&
+                fields.creators.map((item) => types.ShortCreator.toEncodable(item))) ||
+                null,
+        };
+    }
+    toJSON() {
+        return {
+            index: this.index,
+            supply: (this.supply && this.supply.toString()) || null,
+            traitHash: this.traitHash.toString(),
+            name: this.name,
+            arweave: this.arweave,
+            traitPass: (this.traitPass && this.traitPass.toJSON()) || null,
+            royalty: this.royalty,
+            creators: (this.creators && this.creators.map((item) => item.toJSON())) || null,
+        };
+    }
+    static fromJSON(obj) {
+        return new ShortMetadata({
+            index: obj.index,
+            supply: (obj.supply && new BN(obj.supply)) || null,
+            traitHash: new BN(obj.traitHash),
+            name: obj.name,
+            arweave: obj.arweave,
+            traitPass: (obj.traitPass && types.TraitPass.fromJSON(obj.traitPass)) || null,
+            royalty: obj.royalty,
+            creators: (obj.creators &&
+                obj.creators.map((item) => types.ShortCreator.fromJSON(item))) ||
+                null,
+        });
+    }
+    toEncodable() {
+        return ShortMetadata.toEncodable(this);
+    }
+}

package/dist/types/types/ShortMetadataArgs.d.ts

@@ -0,0 +1,47 @@
+import { PublicKey } from "@solana/web3.js";
+import * as types from "../types";
+export interface ShortMetadataArgsFields {
+    name: string;
+    uri: string;
+    uriType: number;
+    sellerFeeBasisPoints: number;
+    collection: PublicKey;
+    creators: Array<types.ShortCreatorFields>;
+}
+export interface ShortMetadataArgsJSON {
+    name: string;
+    uri: string;
+    uriType: number;
+    sellerFeeBasisPoints: number;
+    collection: string;
+    creators: Array<types.ShortCreatorJSON>;
+}
+export declare class ShortMetadataArgs {
+    readonly name: string;
+    readonly uri: string;
+    readonly uriType: number;
+    readonly sellerFeeBasisPoints: number;
+    readonly collection: PublicKey;
+    readonly creators: Array<types.ShortCreator>;
+    constructor(fields: ShortMetadataArgsFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): ShortMetadataArgs;
+    static toEncodable(fields: ShortMetadataArgsFields): {
+        name: string;
+        uri: string;
+        uriType: number;
+        sellerFeeBasisPoints: number;
+        collection: PublicKey;
+        creators: any[];
+    };
+    toJSON(): ShortMetadataArgsJSON;
+    static fromJSON(obj: ShortMetadataArgsJSON): ShortMetadataArgs;
+    toEncodable(): {
+        name: string;
+        uri: string;
+        uriType: number;
+        sellerFeeBasisPoints: number;
+        collection: PublicKey;
+        creators: any[];
+    };
+}

package/dist/types/types/ShortMetadataArgs.js

@@ -0,0 +1,67 @@
+import { PublicKey } from "@solana/web3.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 ShortMetadataArgs {
+    constructor(fields) {
+        this.name = fields.name;
+        this.uri = fields.uri;
+        this.uriType = fields.uriType;
+        this.sellerFeeBasisPoints = fields.sellerFeeBasisPoints;
+        this.collection = fields.collection;
+        this.creators = fields.creators.map((item) => new types.ShortCreator(Object.assign({}, item)));
+    }
+    static layout(property) {
+        return borsh.struct([
+            borsh.str("name"),
+            borsh.str("uri"),
+            borsh.u8("uriType"),
+            borsh.u16("sellerFeeBasisPoints"),
+            borsh.publicKey("collection"),
+            borsh.vec(types.ShortCreator.layout(), "creators"),
+        ], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new ShortMetadataArgs({
+            name: obj.name,
+            uri: obj.uri,
+            uriType: obj.uriType,
+            sellerFeeBasisPoints: obj.sellerFeeBasisPoints,
+            collection: obj.collection,
+            creators: obj.creators.map((item /* eslint-disable-line @typescript-eslint/no-explicit-any */) => types.ShortCreator.fromDecoded(item)),
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            name: fields.name,
+            uri: fields.uri,
+            uriType: fields.uriType,
+            sellerFeeBasisPoints: fields.sellerFeeBasisPoints,
+            collection: fields.collection,
+            creators: fields.creators.map((item) => types.ShortCreator.toEncodable(item)),
+        };
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            uri: this.uri,
+            uriType: this.uriType,
+            sellerFeeBasisPoints: this.sellerFeeBasisPoints,
+            collection: this.collection.toString(),
+            creators: this.creators.map((item) => item.toJSON()),
+        };
+    }
+    static fromJSON(obj) {
+        return new ShortMetadataArgs({
+            name: obj.name,
+            uri: obj.uri,
+            uriType: obj.uriType,
+            sellerFeeBasisPoints: obj.sellerFeeBasisPoints,
+            collection: new PublicKey(obj.collection),
+            creators: obj.creators.map((item) => types.ShortCreator.fromJSON(item)),
+        });
+    }
+    toEncodable() {
+        return ShortMetadataArgs.toEncodable(this);
+    }
+}

package/dist/types/types/StoreConfig.d.ts

@@ -0,0 +1,43 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import * as types from "../types";
+export interface StoreConfigFields {
+    fee: BN;
+    feePercentage: number;
+    feeType: types.FeeTypeKind;
+    trust: PublicKey;
+    rules: Array<types.StoreRuleKind>;
+}
+export interface StoreConfigJSON {
+    fee: string;
+    feePercentage: number;
+    feeType: types.FeeTypeJSON;
+    trust: string;
+    rules: Array<types.StoreRuleJSON>;
+}
+export declare class StoreConfig {
+    readonly fee: BN;
+    readonly feePercentage: number;
+    readonly feeType: types.FeeTypeKind;
+    readonly trust: PublicKey;
+    readonly rules: Array<types.StoreRuleKind>;
+    constructor(fields: StoreConfigFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): StoreConfig;
+    static toEncodable(fields: StoreConfigFields): {
+        fee: BN;
+        feePercentage: number;
+        feeType: any;
+        trust: PublicKey;
+        rules: any[];
+    };
+    toJSON(): StoreConfigJSON;
+    static fromJSON(obj: StoreConfigJSON): StoreConfig;
+    toEncodable(): {
+        fee: BN;
+        feePercentage: number;
+        feeType: any;
+        trust: PublicKey;
+        rules: any[];
+    };
+}

package/dist/types/types/StoreConfig.js

@@ -0,0 +1,62 @@
+import { PublicKey } from "@solana/web3.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+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 StoreConfig {
+    constructor(fields) {
+        this.fee = fields.fee;
+        this.feePercentage = fields.feePercentage;
+        this.feeType = fields.feeType;
+        this.trust = fields.trust;
+        this.rules = fields.rules;
+    }
+    static layout(property) {
+        return borsh.struct([
+            borsh.u64("fee"),
+            borsh.u16("feePercentage"),
+            types.FeeType.layout("feeType"),
+            borsh.publicKey("trust"),
+            borsh.vec(types.StoreRule.layout(), "rules"),
+        ], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new StoreConfig({
+            fee: obj.fee,
+            feePercentage: obj.feePercentage,
+            feeType: types.FeeType.fromDecoded(obj.feeType),
+            trust: obj.trust,
+            rules: obj.rules.map((item /* eslint-disable-line @typescript-eslint/no-explicit-any */) => types.StoreRule.fromDecoded(item)),
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            fee: fields.fee,
+            feePercentage: fields.feePercentage,
+            feeType: fields.feeType.toEncodable(),
+            trust: fields.trust,
+            rules: fields.rules.map((item) => item.toEncodable()),
+        };
+    }
+    toJSON() {
+        return {
+            fee: this.fee.toString(),
+            feePercentage: this.feePercentage,
+            feeType: this.feeType.toJSON(),
+            trust: this.trust.toString(),
+            rules: this.rules.map((item) => item.toJSON()),
+        };
+    }
+    static fromJSON(obj) {
+        return new StoreConfig({
+            fee: new BN(obj.fee),
+            feePercentage: obj.feePercentage,
+            feeType: types.FeeType.fromJSON(obj.feeType),
+            trust: new PublicKey(obj.trust),
+            rules: obj.rules.map((item) => types.StoreRule.fromJSON(item)),
+        });
+    }
+    toEncodable() {
+        return StoreConfig.toEncodable(this);
+    }
+}

package/dist/types/types/StoreRule.d.ts

@@ -0,0 +1,56 @@
+import * as types from "../types";
+export type ListingPerWalletFields = {
+    config: types.ListingPerWalletArgsFields;
+};
+export type ListingPerWalletValue = {
+    config: types.ListingPerWalletArgs;
+};
+export interface ListingPerWalletJSON {
+    kind: "ListingPerWallet";
+    value: {
+        config: types.ListingPerWalletArgsJSON;
+    };
+}
+export declare class ListingPerWallet {
+    static readonly discriminator = 0;
+    static readonly kind = "ListingPerWallet";
+    readonly discriminator = 0;
+    readonly kind = "ListingPerWallet";
+    readonly value: ListingPerWalletValue;
+    constructor(value: ListingPerWalletFields);
+    toJSON(): ListingPerWalletJSON;
+    toEncodable(): {
+        ListingPerWallet: {
+            config: any;
+        };
+    };
+}
+export type AllowedCurrencyFields = {
+    config: types.CurrencyTypeKind;
+};
+export type AllowedCurrencyValue = {
+    config: types.CurrencyTypeKind;
+};
+export interface AllowedCurrencyJSON {
+    kind: "AllowedCurrency";
+    value: {
+        config: types.CurrencyTypeJSON;
+    };
+}
+export declare class AllowedCurrency {
+    static readonly discriminator = 1;
+    static readonly kind = "AllowedCurrency";
+    readonly discriminator = 1;
+    readonly kind = "AllowedCurrency";
+    readonly value: AllowedCurrencyValue;
+    constructor(value: AllowedCurrencyFields);
+    toJSON(): AllowedCurrencyJSON;
+    toEncodable(): {
+        AllowedCurrency: {
+            config: any;
+        };
+    };
+}
+export declare function fromDecoded(obj: any): types.StoreRuleKind;
+export declare function fromJSON(obj: types.StoreRuleJSON): types.StoreRuleKind;
+export declare function layout(property?: string): any;

package/dist/types/types/StoreRule.js

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

package/dist/types/types/SuperCategory.d.ts

@@ -0,0 +1,25 @@
+export interface SuperCategoryFields {
+    cat1: number;
+    cat2: number;
+}
+export interface SuperCategoryJSON {
+    cat1: number;
+    cat2: number;
+}
+export declare class SuperCategory {
+    readonly cat1: number;
+    readonly cat2: number;
+    constructor(fields: SuperCategoryFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): SuperCategory;
+    static toEncodable(fields: SuperCategoryFields): {
+        cat1: number;
+        cat2: number;
+    };
+    toJSON(): SuperCategoryJSON;
+    static fromJSON(obj: SuperCategoryJSON): SuperCategory;
+    toEncodable(): {
+        cat1: number;
+        cat2: number;
+    };
+}

package/dist/types/types/SuperCategory.js

@@ -0,0 +1,38 @@
+import * as borsh from "@coral-xyz/borsh";
+export class SuperCategory {
+    constructor(fields) {
+        this.cat1 = fields.cat1;
+        this.cat2 = fields.cat2;
+    }
+    static layout(property) {
+        return borsh.struct([borsh.u8("cat1"), borsh.u8("cat2")], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new SuperCategory({
+            cat1: obj.cat1,
+            cat2: obj.cat2,
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            cat1: fields.cat1,
+            cat2: fields.cat2,
+        };
+    }
+    toJSON() {
+        return {
+            cat1: this.cat1,
+            cat2: this.cat2,
+        };
+    }
+    static fromJSON(obj) {
+        return new SuperCategory({
+            cat1: obj.cat1,
+            cat2: obj.cat2,
+        });
+    }
+    toEncodable() {
+        return SuperCategory.toEncodable(this);
+    }
+}

package/dist/types/types/TightCardMetadata.d.ts

@@ -0,0 +1,53 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import * as types from "../types";
+export interface TightCardMetadataFields {
+    traitHash: BN;
+    name: string;
+    arweave: string;
+    royalty: number;
+    chunkSize: number;
+    creators: Array<types.ShortCreatorFields>;
+    uploader: PublicKey | null;
+}
+export interface TightCardMetadataJSON {
+    traitHash: string;
+    name: string;
+    arweave: string;
+    royalty: number;
+    chunkSize: number;
+    creators: Array<types.ShortCreatorJSON>;
+    uploader: string | null;
+}
+export declare class TightCardMetadata {
+    readonly traitHash: BN;
+    readonly name: string;
+    readonly arweave: string;
+    readonly royalty: number;
+    readonly chunkSize: number;
+    readonly creators: Array<types.ShortCreator>;
+    readonly uploader: PublicKey | null;
+    constructor(fields: TightCardMetadataFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): TightCardMetadata;
+    static toEncodable(fields: TightCardMetadataFields): {
+        traitHash: BN;
+        name: string;
+        arweave: string;
+        royalty: number;
+        chunkSize: number;
+        creators: any[];
+        uploader: any;
+    };
+    toJSON(): TightCardMetadataJSON;
+    static fromJSON(obj: TightCardMetadataJSON): TightCardMetadata;
+    toEncodable(): {
+        traitHash: BN;
+        name: string;
+        arweave: string;
+        royalty: number;
+        chunkSize: number;
+        creators: any[];
+        uploader: any;
+    };
+}

package/dist/types/types/TightCardMetadata.js

@@ -0,0 +1,74 @@
+import { PublicKey } from "@solana/web3.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+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 TightCardMetadata {
+    constructor(fields) {
+        this.traitHash = fields.traitHash;
+        this.name = fields.name;
+        this.arweave = fields.arweave;
+        this.royalty = fields.royalty;
+        this.chunkSize = fields.chunkSize;
+        this.creators = fields.creators.map((item) => new types.ShortCreator(Object.assign({}, item)));
+        this.uploader = fields.uploader;
+    }
+    static layout(property) {
+        return borsh.struct([
+            borsh.u64("traitHash"),
+            borsh.str("name"),
+            borsh.str("arweave"),
+            borsh.u16("royalty"),
+            borsh.u8("chunkSize"),
+            borsh.vec(types.ShortCreator.layout(), "creators"),
+            borsh.option(borsh.publicKey(), "uploader"),
+        ], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new TightCardMetadata({
+            traitHash: obj.traitHash,
+            name: obj.name,
+            arweave: obj.arweave,
+            royalty: obj.royalty,
+            chunkSize: obj.chunkSize,
+            creators: obj.creators.map((item /* eslint-disable-line @typescript-eslint/no-explicit-any */) => types.ShortCreator.fromDecoded(item)),
+            uploader: obj.uploader,
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            traitHash: fields.traitHash,
+            name: fields.name,
+            arweave: fields.arweave,
+            royalty: fields.royalty,
+            chunkSize: fields.chunkSize,
+            creators: fields.creators.map((item) => types.ShortCreator.toEncodable(item)),
+            uploader: fields.uploader,
+        };
+    }
+    toJSON() {
+        return {
+            traitHash: this.traitHash.toString(),
+            name: this.name,
+            arweave: this.arweave,
+            royalty: this.royalty,
+            chunkSize: this.chunkSize,
+            creators: this.creators.map((item) => item.toJSON()),
+            uploader: (this.uploader && this.uploader.toString()) || null,
+        };
+    }
+    static fromJSON(obj) {
+        return new TightCardMetadata({
+            traitHash: new BN(obj.traitHash),
+            name: obj.name,
+            arweave: obj.arweave,
+            royalty: obj.royalty,
+            chunkSize: obj.chunkSize,
+            creators: obj.creators.map((item) => types.ShortCreator.fromJSON(item)),
+            uploader: (obj.uploader && new PublicKey(obj.uploader)) || null,
+        });
+    }
+    toEncodable() {
+        return TightCardMetadata.toEncodable(this);
+    }
+}