3land_sdk 1.0.0 → 1.0.2

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

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,97 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -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 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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -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 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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,35 @@
+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;
+    };
+}