3land_sdk 1.0.2 → 1.0.4

package/dist/types/types/UnwrapMetadata.d.ts

@@ -1,72 +0,0 @@
-import BN from "bn.js";
-import * as types from "../types";
-export interface UnwrapMetadataFields {
-    wrappedAmount: BN;
-    decimals: number;
-    traitHash: BN;
-    name: string;
-    arweave: string;
-    edition: number;
-    leafIndex: number;
-    cardIndex: number | null;
-    royalty: number;
-    creators: Array<types.ShortCreatorFields>;
-    bumps: Array<number>;
-}
-export interface UnwrapMetadataJSON {
-    wrappedAmount: string;
-    decimals: number;
-    traitHash: string;
-    name: string;
-    arweave: string;
-    edition: number;
-    leafIndex: number;
-    cardIndex: number | null;
-    royalty: number;
-    creators: Array<types.ShortCreatorJSON>;
-    bumps: Array<number>;
-}
-export declare class UnwrapMetadata {
-    readonly wrappedAmount: BN;
-    readonly decimals: number;
-    readonly traitHash: BN;
-    readonly name: string;
-    readonly arweave: string;
-    readonly edition: number;
-    readonly leafIndex: number;
-    readonly cardIndex: number | null;
-    readonly royalty: number;
-    readonly creators: Array<types.ShortCreator>;
-    readonly bumps: Array<number>;
-    constructor(fields: UnwrapMetadataFields);
-    static layout(property?: string): any;
-    static fromDecoded(obj: any): UnwrapMetadata;
-    static toEncodable(fields: UnwrapMetadataFields): {
-        wrappedAmount: BN;
-        decimals: number;
-        traitHash: BN;
-        name: string;
-        arweave: string;
-        edition: number;
-        leafIndex: number;
-        cardIndex: number | null;
-        royalty: number;
-        creators: any[];
-        bumps: number[];
-    };
-    toJSON(): UnwrapMetadataJSON;
-    static fromJSON(obj: UnwrapMetadataJSON): UnwrapMetadata;
-    toEncodable(): {
-        wrappedAmount: BN;
-        decimals: number;
-        traitHash: BN;
-        name: string;
-        arweave: string;
-        edition: number;
-        leafIndex: number;
-        cardIndex: number | null;
-        royalty: number;
-        creators: any[];
-        bumps: number[];
-    };
-}

package/dist/types/types/UnwrapMetadata.js

@@ -1,97 +0,0 @@
-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 UnwrapMetadata {
-    constructor(fields) {
-        this.wrappedAmount = fields.wrappedAmount;
-        this.decimals = fields.decimals;
-        this.traitHash = fields.traitHash;
-        this.name = fields.name;
-        this.arweave = fields.arweave;
-        this.edition = fields.edition;
-        this.leafIndex = fields.leafIndex;
-        this.cardIndex = fields.cardIndex;
-        this.royalty = fields.royalty;
-        this.creators = fields.creators.map((item) => new types.ShortCreator(Object.assign({}, item)));
-        this.bumps = fields.bumps;
-    }
-    static layout(property) {
-        return borsh.struct([
-            borsh.u64("wrappedAmount"),
-            borsh.u8("decimals"),
-            borsh.u64("traitHash"),
-            borsh.str("name"),
-            borsh.str("arweave"),
-            borsh.u32("edition"),
-            borsh.u32("leafIndex"),
-            borsh.option(borsh.u32(), "cardIndex"),
-            borsh.u16("royalty"),
-            borsh.vec(types.ShortCreator.layout(), "creators"),
-            borsh.array(borsh.u8(), 2, "bumps"),
-        ], property);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static fromDecoded(obj) {
-        return new UnwrapMetadata({
-            wrappedAmount: obj.wrappedAmount,
-            decimals: obj.decimals,
-            traitHash: obj.traitHash,
-            name: obj.name,
-            arweave: obj.arweave,
-            edition: obj.edition,
-            leafIndex: obj.leafIndex,
-            cardIndex: obj.cardIndex,
-            royalty: obj.royalty,
-            creators: obj.creators.map((item /* eslint-disable-line @typescript-eslint/no-explicit-any */) => types.ShortCreator.fromDecoded(item)),
-            bumps: obj.bumps,
-        });
-    }
-    static toEncodable(fields) {
-        return {
-            wrappedAmount: fields.wrappedAmount,
-            decimals: fields.decimals,
-            traitHash: fields.traitHash,
-            name: fields.name,
-            arweave: fields.arweave,
-            edition: fields.edition,
-            leafIndex: fields.leafIndex,
-            cardIndex: fields.cardIndex,
-            royalty: fields.royalty,
-            creators: fields.creators.map((item) => types.ShortCreator.toEncodable(item)),
-            bumps: fields.bumps,
-        };
-    }
-    toJSON() {
-        return {
-            wrappedAmount: this.wrappedAmount.toString(),
-            decimals: this.decimals,
-            traitHash: this.traitHash.toString(),
-            name: this.name,
-            arweave: this.arweave,
-            edition: this.edition,
-            leafIndex: this.leafIndex,
-            cardIndex: this.cardIndex,
-            royalty: this.royalty,
-            creators: this.creators.map((item) => item.toJSON()),
-            bumps: this.bumps,
-        };
-    }
-    static fromJSON(obj) {
-        return new UnwrapMetadata({
-            wrappedAmount: new BN(obj.wrappedAmount),
-            decimals: obj.decimals,
-            traitHash: new BN(obj.traitHash),
-            name: obj.name,
-            arweave: obj.arweave,
-            edition: obj.edition,
-            leafIndex: obj.leafIndex,
-            cardIndex: obj.cardIndex,
-            royalty: obj.royalty,
-            creators: obj.creators.map((item) => types.ShortCreator.fromJSON(item)),
-            bumps: obj.bumps,
-        });
-    }
-    toEncodable() {
-        return UnwrapMetadata.toEncodable(this);
-    }
-}

package/dist/types/types/UseMethod.d.ts

@@ -1,43 +0,0 @@
-import * as types from "../types";
-export interface BurnJSON {
-    kind: "Burn";
-}
-export declare class Burn {
-    static readonly discriminator = 0;
-    static readonly kind = "Burn";
-    readonly discriminator = 0;
-    readonly kind = "Burn";
-    toJSON(): BurnJSON;
-    toEncodable(): {
-        Burn: {};
-    };
-}
-export interface MultipleJSON {
-    kind: "Multiple";
-}
-export declare class Multiple {
-    static readonly discriminator = 1;
-    static readonly kind = "Multiple";
-    readonly discriminator = 1;
-    readonly kind = "Multiple";
-    toJSON(): MultipleJSON;
-    toEncodable(): {
-        Multiple: {};
-    };
-}
-export interface SingleJSON {
-    kind: "Single";
-}
-export declare class Single {
-    static readonly discriminator = 2;
-    static readonly kind = "Single";
-    readonly discriminator = 2;
-    readonly kind = "Single";
-    toJSON(): SingleJSON;
-    toEncodable(): {
-        Single: {};
-    };
-}
-export declare function fromDecoded(obj: any): types.UseMethodKind;
-export declare function fromJSON(obj: types.UseMethodJSON): types.UseMethodKind;
-export declare function layout(property?: string): any;

package/dist/types/types/UseMethod.js

@@ -1,95 +0,0 @@
-import * as borsh from "@coral-xyz/borsh";
-export class Burn {
-    constructor() {
-        this.discriminator = 0;
-        this.kind = "Burn";
-    }
-    toJSON() {
-        return {
-            kind: "Burn",
-        };
-    }
-    toEncodable() {
-        return {
-            Burn: {},
-        };
-    }
-}
-Burn.discriminator = 0;
-Burn.kind = "Burn";
-export class Multiple {
-    constructor() {
-        this.discriminator = 1;
-        this.kind = "Multiple";
-    }
-    toJSON() {
-        return {
-            kind: "Multiple",
-        };
-    }
-    toEncodable() {
-        return {
-            Multiple: {},
-        };
-    }
-}
-Multiple.discriminator = 1;
-Multiple.kind = "Multiple";
-export class Single {
-    constructor() {
-        this.discriminator = 2;
-        this.kind = "Single";
-    }
-    toJSON() {
-        return {
-            kind: "Single",
-        };
-    }
-    toEncodable() {
-        return {
-            Single: {},
-        };
-    }
-}
-Single.discriminator = 2;
-Single.kind = "Single";
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function fromDecoded(obj) {
-    if (typeof obj !== "object") {
-        throw new Error("Invalid enum object");
-    }
-    if ("Burn" in obj) {
-        return new Burn();
-    }
-    if ("Multiple" in obj) {
-        return new Multiple();
-    }
-    if ("Single" in obj) {
-        return new Single();
-    }
-    throw new Error("Invalid enum object");
-}
-export function fromJSON(obj) {
-    switch (obj.kind) {
-        case "Burn": {
-            return new Burn();
-        }
-        case "Multiple": {
-            return new Multiple();
-        }
-        case "Single": {
-            return new Single();
-        }
-    }
-}
-export function layout(property) {
-    const ret = borsh.rustEnum([
-        borsh.struct([], "Burn"),
-        borsh.struct([], "Multiple"),
-        borsh.struct([], "Single"),
-    ]);
-    if (property !== undefined) {
-        return ret.replicate(property);
-    }
-    return ret;
-}

package/dist/types/types/Uses.d.ts

@@ -1,32 +0,0 @@
-import BN from "bn.js";
-import * as types from "../types";
-export interface UsesFields {
-    useMethod: types.UseMethodKind;
-    remaining: BN;
-    total: BN;
-}
-export interface UsesJSON {
-    useMethod: types.UseMethodJSON;
-    remaining: string;
-    total: string;
-}
-export declare class Uses {
-    readonly useMethod: types.UseMethodKind;
-    readonly remaining: BN;
-    readonly total: BN;
-    constructor(fields: UsesFields);
-    static layout(property?: string): any;
-    static fromDecoded(obj: any): Uses;
-    static toEncodable(fields: UsesFields): {
-        useMethod: any;
-        remaining: BN;
-        total: BN;
-    };
-    toJSON(): UsesJSON;
-    static fromJSON(obj: UsesJSON): Uses;
-    toEncodable(): {
-        useMethod: any;
-        remaining: BN;
-        total: BN;
-    };
-}

package/dist/types/types/Uses.js

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

package/dist/types/types/VerifyCollectionMetadata.d.ts

@@ -1,46 +0,0 @@
-import * as types from "../types";
-export interface VerifyCollectionMetadataFields {
-    name: string;
-    symbol: string;
-    uri: string;
-    royalty: number;
-    collection: number;
-    creators: Array<types.CreatorFields>;
-}
-export interface VerifyCollectionMetadataJSON {
-    name: string;
-    symbol: string;
-    uri: string;
-    royalty: number;
-    collection: number;
-    creators: Array<types.CreatorJSON>;
-}
-export declare class VerifyCollectionMetadata {
-    readonly name: string;
-    readonly symbol: string;
-    readonly uri: string;
-    readonly royalty: number;
-    readonly collection: number;
-    readonly creators: Array<types.Creator>;
-    constructor(fields: VerifyCollectionMetadataFields);
-    static layout(property?: string): any;
-    static fromDecoded(obj: any): VerifyCollectionMetadata;
-    static toEncodable(fields: VerifyCollectionMetadataFields): {
-        name: string;
-        symbol: string;
-        uri: string;
-        royalty: number;
-        collection: number;
-        creators: any[];
-    };
-    toJSON(): VerifyCollectionMetadataJSON;
-    static fromJSON(obj: VerifyCollectionMetadataJSON): VerifyCollectionMetadata;
-    toEncodable(): {
-        name: string;
-        symbol: string;
-        uri: string;
-        royalty: number;
-        collection: number;
-        creators: any[];
-    };
-}

package/dist/types/types/VerifyCollectionMetadata.js

@@ -1,66 +0,0 @@
-import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
-import * as borsh from "@coral-xyz/borsh";
-export class VerifyCollectionMetadata {
-    constructor(fields) {
-        this.name = fields.name;
-        this.symbol = fields.symbol;
-        this.uri = fields.uri;
-        this.royalty = fields.royalty;
-        this.collection = fields.collection;
-        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("royalty"),
-            borsh.u8("collection"),
-            borsh.vec(types.Creator.layout(), "creators"),
-        ], property);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static fromDecoded(obj) {
-        return new VerifyCollectionMetadata({
-            name: obj.name,
-            symbol: obj.symbol,
-            uri: obj.uri,
-            royalty: obj.royalty,
-            collection: obj.collection,
-            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,
-            royalty: fields.royalty,
-            collection: fields.collection,
-            creators: fields.creators.map((item) => types.Creator.toEncodable(item)),
-        };
-    }
-    toJSON() {
-        return {
-            name: this.name,
-            symbol: this.symbol,
-            uri: this.uri,
-            royalty: this.royalty,
-            collection: this.collection,
-            creators: this.creators.map((item) => item.toJSON()),
-        };
-    }
-    static fromJSON(obj) {
-        return new VerifyCollectionMetadata({
-            name: obj.name,
-            symbol: obj.symbol,
-            uri: obj.uri,
-            royalty: obj.royalty,
-            collection: obj.collection,
-            creators: obj.creators.map((item) => types.Creator.fromJSON(item)),
-        });
-    }
-    toEncodable() {
-        return VerifyCollectionMetadata.toEncodable(this);
-    }
-}

package/dist/types/types/VolumeTrack.d.ts

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

package/dist/types/types/VolumeTrack.js

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

package/dist/types/types/WrappedSource.d.ts

@@ -1,37 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-import BN from "bn.js";
-export interface WrappedSourceFields {
-    pool: PublicKey;
-    amount: BN;
-    distribution: number;
-    track: number;
-}
-export interface WrappedSourceJSON {
-    pool: string;
-    amount: string;
-    distribution: number;
-    track: number;
-}
-export declare class WrappedSource {
-    readonly pool: PublicKey;
-    readonly amount: BN;
-    readonly distribution: number;
-    readonly track: number;
-    constructor(fields: WrappedSourceFields);
-    static layout(property?: string): any;
-    static fromDecoded(obj: any): WrappedSource;
-    static toEncodable(fields: WrappedSourceFields): {
-        pool: PublicKey;
-        amount: BN;
-        distribution: number;
-        track: number;
-    };
-    toJSON(): WrappedSourceJSON;
-    static fromJSON(obj: WrappedSourceJSON): WrappedSource;
-    toEncodable(): {
-        pool: PublicKey;
-        amount: BN;
-        distribution: number;
-        track: number;
-    };
-}

package/dist/types/types/WrappedSource.js

@@ -1,55 +0,0 @@
-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 borsh from "@coral-xyz/borsh";
-export class WrappedSource {
-    constructor(fields) {
-        this.pool = fields.pool;
-        this.amount = fields.amount;
-        this.distribution = fields.distribution;
-        this.track = fields.track;
-    }
-    static layout(property) {
-        return borsh.struct([
-            borsh.publicKey("pool"),
-            borsh.u64("amount"),
-            borsh.u16("distribution"),
-            borsh.u8("track"),
-        ], property);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static fromDecoded(obj) {
-        return new WrappedSource({
-            pool: obj.pool,
-            amount: obj.amount,
-            distribution: obj.distribution,
-            track: obj.track,
-        });
-    }
-    static toEncodable(fields) {
-        return {
-            pool: fields.pool,
-            amount: fields.amount,
-            distribution: fields.distribution,
-            track: fields.track,
-        };
-    }
-    toJSON() {
-        return {
-            pool: this.pool.toString(),
-            amount: this.amount.toString(),
-            distribution: this.distribution,
-            track: this.track,
-        };
-    }
-    static fromJSON(obj) {
-        return new WrappedSource({
-            pool: new PublicKey(obj.pool),
-            amount: new BN(obj.amount),
-            distribution: obj.distribution,
-            track: obj.track,
-        });
-    }
-    toEncodable() {
-        return WrappedSource.toEncodable(this);
-    }
-}

package/dist/types/types/ZeroConfig.d.ts

@@ -1,35 +0,0 @@
-export interface ZeroConfigFields {
-    bytes: number;
-    chunks: Array<number>;
-    chunkSize: number;
-    supplyChunkBytes: number;
-}
-export interface ZeroConfigJSON {
-    bytes: number;
-    chunks: Array<number>;
-    chunkSize: number;
-    supplyChunkBytes: number;
-}
-export declare class ZeroConfig {
-    readonly bytes: number;
-    readonly chunks: Array<number>;
-    readonly chunkSize: number;
-    readonly supplyChunkBytes: number;
-    constructor(fields: ZeroConfigFields);
-    static layout(property?: string): any;
-    static fromDecoded(obj: any): ZeroConfig;
-    static toEncodable(fields: ZeroConfigFields): {
-        bytes: number;
-        chunks: number[];
-        chunkSize: number;
-        supplyChunkBytes: number;
-    };
-    toJSON(): ZeroConfigJSON;
-    static fromJSON(obj: ZeroConfigJSON): ZeroConfig;
-    toEncodable(): {
-        bytes: number;
-        chunks: number[];
-        chunkSize: number;
-        supplyChunkBytes: number;
-    };
-}