3land_sdk 1.0.1 → 1.0.2

package/dist/types/types/ItemState.js

@@ -0,0 +1,245 @@
+import * as borsh from "@coral-xyz/borsh";
+export class Active {
+    constructor() {
+        this.discriminator = 0;
+        this.kind = "Active";
+    }
+    toJSON() {
+        return {
+            kind: "Active",
+        };
+    }
+    toEncodable() {
+        return {
+            Active: {},
+        };
+    }
+}
+Active.discriminator = 0;
+Active.kind = "Active";
+export class Hidden {
+    constructor() {
+        this.discriminator = 1;
+        this.kind = "Hidden";
+    }
+    toJSON() {
+        return {
+            kind: "Hidden",
+        };
+    }
+    toEncodable() {
+        return {
+            Hidden: {},
+        };
+    }
+}
+Hidden.discriminator = 1;
+Hidden.kind = "Hidden";
+export class Inactive {
+    constructor() {
+        this.discriminator = 2;
+        this.kind = "Inactive";
+    }
+    toJSON() {
+        return {
+            kind: "Inactive",
+        };
+    }
+    toEncodable() {
+        return {
+            Inactive: {},
+        };
+    }
+}
+Inactive.discriminator = 2;
+Inactive.kind = "Inactive";
+export class Retired {
+    constructor() {
+        this.discriminator = 3;
+        this.kind = "Retired";
+    }
+    toJSON() {
+        return {
+            kind: "Retired",
+        };
+    }
+    toEncodable() {
+        return {
+            Retired: {},
+        };
+    }
+}
+Retired.discriminator = 3;
+Retired.kind = "Retired";
+export class SoldOut {
+    constructor() {
+        this.discriminator = 4;
+        this.kind = "SoldOut";
+    }
+    toJSON() {
+        return {
+            kind: "SoldOut",
+        };
+    }
+    toEncodable() {
+        return {
+            SoldOut: {},
+        };
+    }
+}
+SoldOut.discriminator = 4;
+SoldOut.kind = "SoldOut";
+export class None {
+    constructor() {
+        this.discriminator = 5;
+        this.kind = "None";
+    }
+    toJSON() {
+        return {
+            kind: "None",
+        };
+    }
+    toEncodable() {
+        return {
+            None: {},
+        };
+    }
+}
+None.discriminator = 5;
+None.kind = "None";
+export class NotReady {
+    constructor() {
+        this.discriminator = 6;
+        this.kind = "NotReady";
+    }
+    toJSON() {
+        return {
+            kind: "NotReady",
+        };
+    }
+    toEncodable() {
+        return {
+            NotReady: {},
+        };
+    }
+}
+NotReady.discriminator = 6;
+NotReady.kind = "NotReady";
+export class NotReadyStarted {
+    constructor() {
+        this.discriminator = 7;
+        this.kind = "NotReadyStarted";
+    }
+    toJSON() {
+        return {
+            kind: "NotReadyStarted",
+        };
+    }
+    toEncodable() {
+        return {
+            NotReadyStarted: {},
+        };
+    }
+}
+NotReadyStarted.discriminator = 7;
+NotReadyStarted.kind = "NotReadyStarted";
+export class Flagged {
+    constructor() {
+        this.discriminator = 8;
+        this.kind = "Flagged";
+    }
+    toJSON() {
+        return {
+            kind: "Flagged",
+        };
+    }
+    toEncodable() {
+        return {
+            Flagged: {},
+        };
+    }
+}
+Flagged.discriminator = 8;
+Flagged.kind = "Flagged";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj) {
+    if (typeof obj !== "object") {
+        throw new Error("Invalid enum object");
+    }
+    if ("Active" in obj) {
+        return new Active();
+    }
+    if ("Hidden" in obj) {
+        return new Hidden();
+    }
+    if ("Inactive" in obj) {
+        return new Inactive();
+    }
+    if ("Retired" in obj) {
+        return new Retired();
+    }
+    if ("SoldOut" in obj) {
+        return new SoldOut();
+    }
+    if ("None" in obj) {
+        return new None();
+    }
+    if ("NotReady" in obj) {
+        return new NotReady();
+    }
+    if ("NotReadyStarted" in obj) {
+        return new NotReadyStarted();
+    }
+    if ("Flagged" in obj) {
+        return new Flagged();
+    }
+    throw new Error("Invalid enum object");
+}
+export function fromJSON(obj) {
+    switch (obj.kind) {
+        case "Active": {
+            return new Active();
+        }
+        case "Hidden": {
+            return new Hidden();
+        }
+        case "Inactive": {
+            return new Inactive();
+        }
+        case "Retired": {
+            return new Retired();
+        }
+        case "SoldOut": {
+            return new SoldOut();
+        }
+        case "None": {
+            return new None();
+        }
+        case "NotReady": {
+            return new NotReady();
+        }
+        case "NotReadyStarted": {
+            return new NotReadyStarted();
+        }
+        case "Flagged": {
+            return new Flagged();
+        }
+    }
+}
+export function layout(property) {
+    const ret = borsh.rustEnum([
+        borsh.struct([], "Active"),
+        borsh.struct([], "Hidden"),
+        borsh.struct([], "Inactive"),
+        borsh.struct([], "Retired"),
+        borsh.struct([], "SoldOut"),
+        borsh.struct([], "None"),
+        borsh.struct([], "NotReady"),
+        borsh.struct([], "NotReadyStarted"),
+        borsh.struct([], "Flagged"),
+    ]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

package/dist/types/types/ItemTrack.d.ts

@@ -0,0 +1,32 @@
+import BN from "bn.js";
+import * as types from "../types";
+export interface ItemTrackFields {
+    state: types.ItemStateKind;
+    supply: BN;
+    created: BN;
+}
+export interface ItemTrackJSON {
+    state: types.ItemStateJSON;
+    supply: string;
+    created: string;
+}
+export declare class ItemTrack {
+    readonly state: types.ItemStateKind;
+    readonly supply: BN;
+    readonly created: BN;
+    constructor(fields: ItemTrackFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): ItemTrack;
+    static toEncodable(fields: ItemTrackFields): {
+        state: any;
+        supply: BN;
+        created: BN;
+    };
+    toJSON(): ItemTrackJSON;
+    static fromJSON(obj: ItemTrackJSON): ItemTrack;
+    toEncodable(): {
+        state: any;
+        supply: BN;
+        created: BN;
+    };
+}

package/dist/types/types/ItemTrack.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 ItemTrack {
+    constructor(fields) {
+        this.state = fields.state;
+        this.supply = fields.supply;
+        this.created = fields.created;
+    }
+    static layout(property) {
+        return borsh.struct([
+            types.ItemState.layout("state"),
+            borsh.u64("supply"),
+            borsh.u64("created"),
+        ], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new ItemTrack({
+            state: types.ItemState.fromDecoded(obj.state),
+            supply: obj.supply,
+            created: obj.created,
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            state: fields.state.toEncodable(),
+            supply: fields.supply,
+            created: fields.created,
+        };
+    }
+    toJSON() {
+        return {
+            state: this.state.toJSON(),
+            supply: this.supply.toString(),
+            created: this.created.toString(),
+        };
+    }
+    static fromJSON(obj) {
+        return new ItemTrack({
+            state: types.ItemState.fromJSON(obj.state),
+            supply: new BN(obj.supply),
+            created: new BN(obj.created),
+        });
+    }
+    toEncodable() {
+        return ItemTrack.toEncodable(this);
+    }
+}

package/dist/types/types/ListingPerWalletArgs.d.ts

@@ -0,0 +1,20 @@
+export interface ListingPerWalletArgsFields {
+    amount: number;
+}
+export interface ListingPerWalletArgsJSON {
+    amount: number;
+}
+export declare class ListingPerWalletArgs {
+    readonly amount: number;
+    constructor(fields: ListingPerWalletArgsFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): ListingPerWalletArgs;
+    static toEncodable(fields: ListingPerWalletArgsFields): {
+        amount: number;
+    };
+    toJSON(): ListingPerWalletArgsJSON;
+    static fromJSON(obj: ListingPerWalletArgsJSON): ListingPerWalletArgs;
+    toEncodable(): {
+        amount: number;
+    };
+}

package/dist/types/types/ListingPerWalletArgs.js

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

package/dist/types/types/MemeVaultProof.d.ts

@@ -0,0 +1,26 @@
+import BN from "bn.js";
+export interface MemeVaultProofFields {
+    amount: BN;
+    halfCurrencyHash: number;
+}
+export interface MemeVaultProofJSON {
+    amount: string;
+    halfCurrencyHash: number;
+}
+export declare class MemeVaultProof {
+    readonly amount: BN;
+    readonly halfCurrencyHash: number;
+    constructor(fields: MemeVaultProofFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): MemeVaultProof;
+    static toEncodable(fields: MemeVaultProofFields): {
+        amount: BN;
+        halfCurrencyHash: number;
+    };
+    toJSON(): MemeVaultProofJSON;
+    static fromJSON(obj: MemeVaultProofJSON): MemeVaultProof;
+    toEncodable(): {
+        amount: BN;
+        halfCurrencyHash: number;
+    };
+}

package/dist/types/types/MemeVaultProof.js

@@ -0,0 +1,39 @@
+import BN from "bn.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh";
+export class MemeVaultProof {
+    constructor(fields) {
+        this.amount = fields.amount;
+        this.halfCurrencyHash = fields.halfCurrencyHash;
+    }
+    static layout(property) {
+        return borsh.struct([borsh.u64("amount"), borsh.u32("halfCurrencyHash")], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new MemeVaultProof({
+            amount: obj.amount,
+            halfCurrencyHash: obj.halfCurrencyHash,
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            amount: fields.amount,
+            halfCurrencyHash: fields.halfCurrencyHash,
+        };
+    }
+    toJSON() {
+        return {
+            amount: this.amount.toString(),
+            halfCurrencyHash: this.halfCurrencyHash,
+        };
+    }
+    static fromJSON(obj) {
+        return new MemeVaultProof({
+            amount: new BN(obj.amount),
+            halfCurrencyHash: obj.halfCurrencyHash,
+        });
+    }
+    toEncodable() {
+        return MemeVaultProof.toEncodable(this);
+    }
+}

package/dist/types/types/MetadataArgs.d.ts

@@ -0,0 +1,100 @@
+import * as types from "../types";
+export interface MetadataArgsFields {
+    /** The name of the asset */
+    name: string;
+    /** The symbol for the asset */
+    symbol: string;
+    /** URI pointing to JSON representing the asset */
+    uri: string;
+    /** Royalty basis points that goes to creators in secondary sales (0-10000) */
+    sellerFeeBasisPoints: number;
+    primarySaleHappened: boolean;
+    isMutable: boolean;
+    /** nonce for easy calculation of editions, if present */
+    editionNonce: number | null;
+    /** Since we cannot easily change Metadata, we add the new DataV2 fields here at the end. */
+    tokenStandard: types.TokenStandardKind | null;
+    /** Collection */
+    collection: types.CollectionFields | null;
+    /** Uses */
+    uses: types.UsesFields | null;
+    tokenProgramVersion: types.TokenProgramVersionKind;
+    creators: Array<types.CreatorFields>;
+}
+export interface MetadataArgsJSON {
+    /** The name of the asset */
+    name: string;
+    /** The symbol for the asset */
+    symbol: string;
+    /** URI pointing to JSON representing the asset */
+    uri: string;
+    /** Royalty basis points that goes to creators in secondary sales (0-10000) */
+    sellerFeeBasisPoints: number;
+    primarySaleHappened: boolean;
+    isMutable: boolean;
+    /** nonce for easy calculation of editions, if present */
+    editionNonce: number | null;
+    /** Since we cannot easily change Metadata, we add the new DataV2 fields here at the end. */
+    tokenStandard: types.TokenStandardJSON | null;
+    /** Collection */
+    collection: types.CollectionJSON | null;
+    /** Uses */
+    uses: types.UsesJSON | null;
+    tokenProgramVersion: types.TokenProgramVersionJSON;
+    creators: Array<types.CreatorJSON>;
+}
+export declare class MetadataArgs {
+    /** The name of the asset */
+    readonly name: string;
+    /** The symbol for the asset */
+    readonly symbol: string;
+    /** URI pointing to JSON representing the asset */
+    readonly uri: string;
+    /** Royalty basis points that goes to creators in secondary sales (0-10000) */
+    readonly sellerFeeBasisPoints: number;
+    readonly primarySaleHappened: boolean;
+    readonly isMutable: boolean;
+    /** nonce for easy calculation of editions, if present */
+    readonly editionNonce: number | null;
+    /** Since we cannot easily change Metadata, we add the new DataV2 fields here at the end. */
+    readonly tokenStandard: types.TokenStandardKind | null;
+    /** Collection */
+    readonly collection: types.Collection | null;
+    /** Uses */
+    readonly uses: types.Uses | null;
+    readonly tokenProgramVersion: types.TokenProgramVersionKind;
+    readonly creators: Array<types.Creator>;
+    constructor(fields: MetadataArgsFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): MetadataArgs;
+    static toEncodable(fields: MetadataArgsFields): {
+        name: string;
+        symbol: string;
+        uri: string;
+        sellerFeeBasisPoints: number;
+        primarySaleHappened: boolean;
+        isMutable: boolean;
+        editionNonce: number | null;
+        tokenStandard: any;
+        collection: any;
+        uses: any;
+        tokenProgramVersion: any;
+        creators: any[];
+    };
+    toJSON(): MetadataArgsJSON;
+    static fromJSON(obj: MetadataArgsJSON): MetadataArgs;
+    toEncodable(): {
+        name: string;
+        symbol: string;
+        uri: string;
+        sellerFeeBasisPoints: number;
+        primarySaleHappened: boolean;
+        isMutable: boolean;
+        editionNonce: number | null;
+        tokenStandard: any;
+        collection: any;
+        uses: any;
+        tokenProgramVersion: any;
+        creators: any[];
+    };
+}

package/dist/types/types/MetadataArgs.js

@@ -0,0 +1,111 @@
+import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh";
+export class MetadataArgs {
+    constructor(fields) {
+        this.name = fields.name;
+        this.symbol = fields.symbol;
+        this.uri = fields.uri;
+        this.sellerFeeBasisPoints = fields.sellerFeeBasisPoints;
+        this.primarySaleHappened = fields.primarySaleHappened;
+        this.isMutable = fields.isMutable;
+        this.editionNonce = fields.editionNonce;
+        this.tokenStandard = fields.tokenStandard;
+        this.collection =
+            (fields.collection && new types.Collection(Object.assign({}, fields.collection))) ||
+                null;
+        this.uses = (fields.uses && new types.Uses(Object.assign({}, fields.uses))) || null;
+        this.tokenProgramVersion = fields.tokenProgramVersion;
+        this.creators = fields.creators.map((item) => new types.Creator(Object.assign({}, item)));
+    }
+    static layout(property) {
+        return borsh.struct([
+            borsh.str("name"),
+            borsh.str("symbol"),
+            borsh.str("uri"),
+            borsh.u16("sellerFeeBasisPoints"),
+            borsh.bool("primarySaleHappened"),
+            borsh.bool("isMutable"),
+            borsh.option(borsh.u8(), "editionNonce"),
+            borsh.option(types.TokenStandard.layout(), "tokenStandard"),
+            borsh.option(types.Collection.layout(), "collection"),
+            borsh.option(types.Uses.layout(), "uses"),
+            types.TokenProgramVersion.layout("tokenProgramVersion"),
+            borsh.vec(types.Creator.layout(), "creators"),
+        ], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new MetadataArgs({
+            name: obj.name,
+            symbol: obj.symbol,
+            uri: obj.uri,
+            sellerFeeBasisPoints: obj.sellerFeeBasisPoints,
+            primarySaleHappened: obj.primarySaleHappened,
+            isMutable: obj.isMutable,
+            editionNonce: obj.editionNonce,
+            tokenStandard: (obj.tokenStandard &&
+                types.TokenStandard.fromDecoded(obj.tokenStandard)) ||
+                null,
+            collection: (obj.collection && types.Collection.fromDecoded(obj.collection)) ||
+                null,
+            uses: (obj.uses && types.Uses.fromDecoded(obj.uses)) || null,
+            tokenProgramVersion: types.TokenProgramVersion.fromDecoded(obj.tokenProgramVersion),
+            creators: obj.creators.map((item /* eslint-disable-line @typescript-eslint/no-explicit-any */) => types.Creator.fromDecoded(item)),
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            name: fields.name,
+            symbol: fields.symbol,
+            uri: fields.uri,
+            sellerFeeBasisPoints: fields.sellerFeeBasisPoints,
+            primarySaleHappened: fields.primarySaleHappened,
+            isMutable: fields.isMutable,
+            editionNonce: fields.editionNonce,
+            tokenStandard: (fields.tokenStandard && fields.tokenStandard.toEncodable()) || null,
+            collection: (fields.collection &&
+                types.Collection.toEncodable(fields.collection)) ||
+                null,
+            uses: (fields.uses && types.Uses.toEncodable(fields.uses)) || null,
+            tokenProgramVersion: fields.tokenProgramVersion.toEncodable(),
+            creators: fields.creators.map((item) => types.Creator.toEncodable(item)),
+        };
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            symbol: this.symbol,
+            uri: this.uri,
+            sellerFeeBasisPoints: this.sellerFeeBasisPoints,
+            primarySaleHappened: this.primarySaleHappened,
+            isMutable: this.isMutable,
+            editionNonce: this.editionNonce,
+            tokenStandard: (this.tokenStandard && this.tokenStandard.toJSON()) || null,
+            collection: (this.collection && this.collection.toJSON()) || null,
+            uses: (this.uses && this.uses.toJSON()) || null,
+            tokenProgramVersion: this.tokenProgramVersion.toJSON(),
+            creators: this.creators.map((item) => item.toJSON()),
+        };
+    }
+    static fromJSON(obj) {
+        return new MetadataArgs({
+            name: obj.name,
+            symbol: obj.symbol,
+            uri: obj.uri,
+            sellerFeeBasisPoints: obj.sellerFeeBasisPoints,
+            primarySaleHappened: obj.primarySaleHappened,
+            isMutable: obj.isMutable,
+            editionNonce: obj.editionNonce,
+            tokenStandard: (obj.tokenStandard &&
+                types.TokenStandard.fromJSON(obj.tokenStandard)) ||
+                null,
+            collection: (obj.collection && types.Collection.fromJSON(obj.collection)) || null,
+            uses: (obj.uses && types.Uses.fromJSON(obj.uses)) || null,
+            tokenProgramVersion: types.TokenProgramVersion.fromJSON(obj.tokenProgramVersion),
+            creators: obj.creators.map((item) => types.Creator.fromJSON(item)),
+        });
+    }
+    toEncodable() {
+        return MetadataArgs.toEncodable(this);
+    }
+}

package/dist/types/types/NonFungibleTraitInit.d.ts

@@ -0,0 +1,26 @@
+import BN from "bn.js";
+export interface NonFungibleTraitInitFields {
+    hash: BN;
+    values: Array<BN>;
+}
+export interface NonFungibleTraitInitJSON {
+    hash: string;
+    values: Array<string>;
+}
+export declare class NonFungibleTraitInit {
+    readonly hash: BN;
+    readonly values: Array<BN>;
+    constructor(fields: NonFungibleTraitInitFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): NonFungibleTraitInit;
+    static toEncodable(fields: NonFungibleTraitInitFields): {
+        hash: BN;
+        values: BN[];
+    };
+    toJSON(): NonFungibleTraitInitJSON;
+    static fromJSON(obj: NonFungibleTraitInitJSON): NonFungibleTraitInit;
+    toEncodable(): {
+        hash: BN;
+        values: BN[];
+    };
+}