3land_sdk 1.0.1 → 1.0.2

package/dist/types/accounts/Store.d.ts

@@ -0,0 +1,53 @@
+import { PublicKey, Connection } from "@solana/web3.js";
+import BN from "bn.js";
+import * as types from "../types";
+export interface StoreFields {
+    class: types.AccountClassKind;
+    holder: PublicKey;
+    creator: PublicKey;
+    page: BN;
+    count: BN;
+    live: BN;
+    name: string;
+    config: types.StoreConfigFields;
+    storeId: number;
+    globalFee: types.GlobalFeeFields | null;
+    globalDeposit: BN;
+    cacheHolder: Array<number>;
+}
+export interface StoreJSON {
+    class: types.AccountClassJSON;
+    holder: string;
+    creator: string;
+    page: string;
+    count: string;
+    live: string;
+    name: string;
+    config: types.StoreConfigJSON;
+    storeId: number;
+    globalFee: types.GlobalFeeJSON | null;
+    globalDeposit: string;
+    cacheHolder: Array<number>;
+}
+export declare class Store {
+    readonly class: types.AccountClassKind;
+    readonly holder: PublicKey;
+    readonly creator: PublicKey;
+    readonly page: BN;
+    readonly count: BN;
+    readonly live: BN;
+    readonly name: string;
+    readonly config: types.StoreConfig;
+    readonly storeId: number;
+    readonly globalFee: types.GlobalFee | null;
+    readonly globalDeposit: BN;
+    readonly cacheHolder: Array<number>;
+    static readonly discriminator: Buffer;
+    static readonly layout: any;
+    constructor(fields: StoreFields);
+    static fetch(c: Connection, address: PublicKey, programId?: PublicKey): Promise<Store | null>;
+    static fetchMultiple(c: Connection, addresses: PublicKey[], programId?: PublicKey): Promise<Array<Store | null>>;
+    static decode(data: Buffer): Store;
+    toJSON(): StoreJSON;
+    static fromJSON(obj: StoreJSON): Store;
+}

package/dist/types/accounts/Store.js

@@ -0,0 +1,126 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export class Store {
+    constructor(fields) {
+        this.class = fields.class;
+        this.holder = fields.holder;
+        this.creator = fields.creator;
+        this.page = fields.page;
+        this.count = fields.count;
+        this.live = fields.live;
+        this.name = fields.name;
+        this.config = new types.StoreConfig(Object.assign({}, fields.config));
+        this.storeId = fields.storeId;
+        this.globalFee =
+            (fields.globalFee && new types.GlobalFee(Object.assign({}, fields.globalFee))) || null;
+        this.globalDeposit = fields.globalDeposit;
+        this.cacheHolder = fields.cacheHolder;
+    }
+    static fetch(c_1, address_1) {
+        return __awaiter(this, arguments, void 0, function* (c, address, programId = PROGRAM_ID) {
+            const info = yield c.getAccountInfo(address);
+            if (info === null) {
+                return null;
+            }
+            if (!info.owner.equals(programId)) {
+                throw new Error("account doesn't belong to this program");
+            }
+            return this.decode(info.data);
+        });
+    }
+    static fetchMultiple(c_1, addresses_1) {
+        return __awaiter(this, arguments, void 0, function* (c, addresses, programId = PROGRAM_ID) {
+            const infos = yield c.getMultipleAccountsInfo(addresses);
+            return infos.map((info) => {
+                if (info === null) {
+                    return null;
+                }
+                if (!info.owner.equals(programId)) {
+                    throw new Error("account doesn't belong to this program");
+                }
+                return this.decode(info.data);
+            });
+        });
+    }
+    static decode(data) {
+        if (!data.slice(0, 8).equals(Store.discriminator)) {
+            throw new Error("invalid account discriminator");
+        }
+        const dec = Store.layout.decode(data.slice(8));
+        return new Store({
+            class: types.AccountClass.fromDecoded(dec.class),
+            holder: dec.holder,
+            creator: dec.creator,
+            page: dec.page,
+            count: dec.count,
+            live: dec.live,
+            name: dec.name,
+            config: types.StoreConfig.fromDecoded(dec.config),
+            storeId: dec.storeId,
+            globalFee: (dec.globalFee && types.GlobalFee.fromDecoded(dec.globalFee)) || null,
+            globalDeposit: dec.globalDeposit,
+            cacheHolder: dec.cacheHolder,
+        });
+    }
+    toJSON() {
+        return {
+            class: this.class.toJSON(),
+            holder: this.holder.toString(),
+            creator: this.creator.toString(),
+            page: this.page.toString(),
+            count: this.count.toString(),
+            live: this.live.toString(),
+            name: this.name,
+            config: this.config.toJSON(),
+            storeId: this.storeId,
+            globalFee: (this.globalFee && this.globalFee.toJSON()) || null,
+            globalDeposit: this.globalDeposit.toString(),
+            cacheHolder: this.cacheHolder,
+        };
+    }
+    static fromJSON(obj) {
+        return new Store({
+            class: types.AccountClass.fromJSON(obj.class),
+            holder: new PublicKey(obj.holder),
+            creator: new PublicKey(obj.creator),
+            page: new BN(obj.page),
+            count: new BN(obj.count),
+            live: new BN(obj.live),
+            name: obj.name,
+            config: types.StoreConfig.fromJSON(obj.config),
+            storeId: obj.storeId,
+            globalFee: (obj.globalFee && types.GlobalFee.fromJSON(obj.globalFee)) || null,
+            globalDeposit: new BN(obj.globalDeposit),
+            cacheHolder: obj.cacheHolder,
+        });
+    }
+}
+Store.discriminator = Buffer.from([
+    130, 48, 247, 244, 182, 191, 30, 26,
+]);
+Store.layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    borsh.publicKey("holder"),
+    borsh.publicKey("creator"),
+    borsh.u64("page"),
+    borsh.u64("count"),
+    borsh.u64("live"),
+    borsh.str("name"),
+    types.StoreConfig.layout("config"),
+    borsh.u16("storeId"),
+    borsh.option(types.GlobalFee.layout(), "globalFee"),
+    borsh.u64("globalDeposit"),
+    borsh.array(borsh.u8(), 128, "cacheHolder"),
+]);

package/dist/types/accounts/StoresHolder.d.ts

@@ -0,0 +1,32 @@
+import { PublicKey, Connection } from "@solana/web3.js";
+import BN from "bn.js";
+import * as types from "../types";
+export interface StoresHolderFields {
+    class: types.AccountClassKind;
+    slot: BN;
+    creator: PublicKey;
+    count: BN;
+    defaultGlobalFee: types.GlobalFeeFields | null;
+}
+export interface StoresHolderJSON {
+    class: types.AccountClassJSON;
+    slot: string;
+    creator: string;
+    count: string;
+    defaultGlobalFee: types.GlobalFeeJSON | null;
+}
+export declare class StoresHolder {
+    readonly class: types.AccountClassKind;
+    readonly slot: BN;
+    readonly creator: PublicKey;
+    readonly count: BN;
+    readonly defaultGlobalFee: types.GlobalFee | null;
+    static readonly discriminator: Buffer;
+    static readonly layout: any;
+    constructor(fields: StoresHolderFields);
+    static fetch(c: Connection, address: PublicKey, programId?: PublicKey): Promise<StoresHolder | null>;
+    static fetchMultiple(c: Connection, addresses: PublicKey[], programId?: PublicKey): Promise<Array<StoresHolder | null>>;
+    static decode(data: Buffer): StoresHolder;
+    toJSON(): StoresHolderJSON;
+    static fromJSON(obj: StoresHolderJSON): StoresHolder;
+}

package/dist/types/accounts/StoresHolder.js

@@ -0,0 +1,97 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export class StoresHolder {
+    constructor(fields) {
+        this.class = fields.class;
+        this.slot = fields.slot;
+        this.creator = fields.creator;
+        this.count = fields.count;
+        this.defaultGlobalFee =
+            (fields.defaultGlobalFee &&
+                new types.GlobalFee(Object.assign({}, fields.defaultGlobalFee))) ||
+                null;
+    }
+    static fetch(c_1, address_1) {
+        return __awaiter(this, arguments, void 0, function* (c, address, programId = PROGRAM_ID) {
+            const info = yield c.getAccountInfo(address);
+            if (info === null) {
+                return null;
+            }
+            if (!info.owner.equals(programId)) {
+                throw new Error("account doesn't belong to this program");
+            }
+            return this.decode(info.data);
+        });
+    }
+    static fetchMultiple(c_1, addresses_1) {
+        return __awaiter(this, arguments, void 0, function* (c, addresses, programId = PROGRAM_ID) {
+            const infos = yield c.getMultipleAccountsInfo(addresses);
+            return infos.map((info) => {
+                if (info === null) {
+                    return null;
+                }
+                if (!info.owner.equals(programId)) {
+                    throw new Error("account doesn't belong to this program");
+                }
+                return this.decode(info.data);
+            });
+        });
+    }
+    static decode(data) {
+        if (!data.slice(0, 8).equals(StoresHolder.discriminator)) {
+            throw new Error("invalid account discriminator");
+        }
+        const dec = StoresHolder.layout.decode(data.slice(8));
+        return new StoresHolder({
+            class: types.AccountClass.fromDecoded(dec.class),
+            slot: dec.slot,
+            creator: dec.creator,
+            count: dec.count,
+            defaultGlobalFee: (dec.defaultGlobalFee &&
+                types.GlobalFee.fromDecoded(dec.defaultGlobalFee)) ||
+                null,
+        });
+    }
+    toJSON() {
+        return {
+            class: this.class.toJSON(),
+            slot: this.slot.toString(),
+            creator: this.creator.toString(),
+            count: this.count.toString(),
+            defaultGlobalFee: (this.defaultGlobalFee && this.defaultGlobalFee.toJSON()) || null,
+        };
+    }
+    static fromJSON(obj) {
+        return new StoresHolder({
+            class: types.AccountClass.fromJSON(obj.class),
+            slot: new BN(obj.slot),
+            creator: new PublicKey(obj.creator),
+            count: new BN(obj.count),
+            defaultGlobalFee: (obj.defaultGlobalFee &&
+                types.GlobalFee.fromJSON(obj.defaultGlobalFee)) ||
+                null,
+        });
+    }
+}
+StoresHolder.discriminator = Buffer.from([
+    237, 16, 131, 248, 150, 182, 165, 234,
+]);
+StoresHolder.layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    borsh.u64("slot"),
+    borsh.publicKey("creator"),
+    borsh.u64("count"),
+    borsh.option(types.GlobalFee.layout(), "defaultGlobalFee"),
+]);

package/dist/types/accounts/ThreeId.d.ts

@@ -0,0 +1,56 @@
+import { PublicKey, Connection } from "@solana/web3.js";
+import BN from "bn.js";
+import * as types from "../types";
+export interface ThreeIdFields {
+    class: types.AccountClassKind;
+    holderHash: BN;
+    creator: PublicKey;
+    lutAccount: PublicKey;
+    points1: BN;
+    points2: BN;
+    coin1: number;
+    coin2: number;
+    settings: Array<number>;
+    subwallets: Array<PublicKey>;
+    username: string;
+    generalStore: Array<types.GeneralStoreKind>;
+    extra: Array<number>;
+}
+export interface ThreeIdJSON {
+    class: types.AccountClassJSON;
+    holderHash: string;
+    creator: string;
+    lutAccount: string;
+    points1: string;
+    points2: string;
+    coin1: number;
+    coin2: number;
+    settings: Array<number>;
+    subwallets: Array<string>;
+    username: string;
+    generalStore: Array<types.GeneralStoreJSON>;
+    extra: Array<number>;
+}
+export declare class ThreeId {
+    readonly class: types.AccountClassKind;
+    readonly holderHash: BN;
+    readonly creator: PublicKey;
+    readonly lutAccount: PublicKey;
+    readonly points1: BN;
+    readonly points2: BN;
+    readonly coin1: number;
+    readonly coin2: number;
+    readonly settings: Array<number>;
+    readonly subwallets: Array<PublicKey>;
+    readonly username: string;
+    readonly generalStore: Array<types.GeneralStoreKind>;
+    readonly extra: Array<number>;
+    static readonly discriminator: Buffer;
+    static readonly layout: any;
+    constructor(fields: ThreeIdFields);
+    static fetch(c: Connection, address: PublicKey, programId?: PublicKey): Promise<ThreeId | null>;
+    static fetchMultiple(c: Connection, addresses: PublicKey[], programId?: PublicKey): Promise<Array<ThreeId | null>>;
+    static decode(data: Buffer): ThreeId;
+    toJSON(): ThreeIdJSON;
+    static fromJSON(obj: ThreeIdJSON): ThreeId;
+}

package/dist/types/accounts/ThreeId.js

@@ -0,0 +1,128 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export class ThreeId {
+    constructor(fields) {
+        this.class = fields.class;
+        this.holderHash = fields.holderHash;
+        this.creator = fields.creator;
+        this.lutAccount = fields.lutAccount;
+        this.points1 = fields.points1;
+        this.points2 = fields.points2;
+        this.coin1 = fields.coin1;
+        this.coin2 = fields.coin2;
+        this.settings = fields.settings;
+        this.subwallets = fields.subwallets;
+        this.username = fields.username;
+        this.generalStore = fields.generalStore;
+        this.extra = fields.extra;
+    }
+    static fetch(c_1, address_1) {
+        return __awaiter(this, arguments, void 0, function* (c, address, programId = PROGRAM_ID) {
+            const info = yield c.getAccountInfo(address);
+            if (info === null) {
+                return null;
+            }
+            if (!info.owner.equals(programId)) {
+                throw new Error("account doesn't belong to this program");
+            }
+            return this.decode(info.data);
+        });
+    }
+    static fetchMultiple(c_1, addresses_1) {
+        return __awaiter(this, arguments, void 0, function* (c, addresses, programId = PROGRAM_ID) {
+            const infos = yield c.getMultipleAccountsInfo(addresses);
+            return infos.map((info) => {
+                if (info === null) {
+                    return null;
+                }
+                if (!info.owner.equals(programId)) {
+                    throw new Error("account doesn't belong to this program");
+                }
+                return this.decode(info.data);
+            });
+        });
+    }
+    static decode(data) {
+        if (!data.slice(0, 8).equals(ThreeId.discriminator)) {
+            throw new Error("invalid account discriminator");
+        }
+        const dec = ThreeId.layout.decode(data.slice(8));
+        return new ThreeId({
+            class: types.AccountClass.fromDecoded(dec.class),
+            holderHash: dec.holderHash,
+            creator: dec.creator,
+            lutAccount: dec.lutAccount,
+            points1: dec.points1,
+            points2: dec.points2,
+            coin1: dec.coin1,
+            coin2: dec.coin2,
+            settings: dec.settings,
+            subwallets: dec.subwallets,
+            username: dec.username,
+            generalStore: dec.generalStore.map((item /* eslint-disable-line @typescript-eslint/no-explicit-any */) => types.GeneralStore.fromDecoded(item)),
+            extra: dec.extra,
+        });
+    }
+    toJSON() {
+        return {
+            class: this.class.toJSON(),
+            holderHash: this.holderHash.toString(),
+            creator: this.creator.toString(),
+            lutAccount: this.lutAccount.toString(),
+            points1: this.points1.toString(),
+            points2: this.points2.toString(),
+            coin1: this.coin1,
+            coin2: this.coin2,
+            settings: this.settings,
+            subwallets: this.subwallets.map((item) => item.toString()),
+            username: this.username,
+            generalStore: this.generalStore.map((item) => item.toJSON()),
+            extra: this.extra,
+        };
+    }
+    static fromJSON(obj) {
+        return new ThreeId({
+            class: types.AccountClass.fromJSON(obj.class),
+            holderHash: new BN(obj.holderHash),
+            creator: new PublicKey(obj.creator),
+            lutAccount: new PublicKey(obj.lutAccount),
+            points1: new BN(obj.points1),
+            points2: new BN(obj.points2),
+            coin1: obj.coin1,
+            coin2: obj.coin2,
+            settings: obj.settings,
+            subwallets: obj.subwallets.map((item) => new PublicKey(item)),
+            username: obj.username,
+            generalStore: obj.generalStore.map((item) => types.GeneralStore.fromJSON(item)),
+            extra: obj.extra,
+        });
+    }
+}
+ThreeId.discriminator = Buffer.from([123, 56, 150, 21, 8, 4, 144, 81]);
+ThreeId.layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    borsh.u64("holderHash"),
+    borsh.publicKey("creator"),
+    borsh.publicKey("lutAccount"),
+    borsh.u64("points1"),
+    borsh.u64("points2"),
+    borsh.u32("coin1"),
+    borsh.u32("coin2"),
+    borsh.array(borsh.u8(), 8, "settings"),
+    borsh.vec(borsh.publicKey(), "subwallets"),
+    borsh.str("username"),
+    borsh.vec(types.GeneralStore.layout(), "generalStore"),
+    borsh.array(borsh.u8(), 32, "extra"),
+]);

package/dist/types/accounts/TokenManager.d.ts

@@ -0,0 +1,68 @@
+import { PublicKey, Connection } from "@solana/web3.js";
+import BN from "bn.js";
+import * as types from "../types";
+export interface TokenManagerFields {
+    class: types.AccountClassKind;
+    storeHash: BN;
+    tokenType: types.TokenTypeKind;
+    state: types.TokenStateKind;
+    currency: PublicKey;
+    creator: PublicKey;
+    communityShare: number;
+    name: string;
+    base: BN;
+    price: BN;
+    supply: BN;
+    created: BN;
+    pool: BN;
+    pending: BN;
+    taxes: Array<number>;
+    options: Array<number>;
+    extra: Array<number>;
+}
+export interface TokenManagerJSON {
+    class: types.AccountClassJSON;
+    storeHash: string;
+    tokenType: types.TokenTypeJSON;
+    state: types.TokenStateJSON;
+    currency: string;
+    creator: string;
+    communityShare: number;
+    name: string;
+    base: string;
+    price: string;
+    supply: string;
+    created: string;
+    pool: string;
+    pending: string;
+    taxes: Array<number>;
+    options: Array<number>;
+    extra: Array<number>;
+}
+export declare class TokenManager {
+    readonly class: types.AccountClassKind;
+    readonly storeHash: BN;
+    readonly tokenType: types.TokenTypeKind;
+    readonly state: types.TokenStateKind;
+    readonly currency: PublicKey;
+    readonly creator: PublicKey;
+    readonly communityShare: number;
+    readonly name: string;
+    readonly base: BN;
+    readonly price: BN;
+    readonly supply: BN;
+    readonly created: BN;
+    readonly pool: BN;
+    readonly pending: BN;
+    readonly taxes: Array<number>;
+    readonly options: Array<number>;
+    readonly extra: Array<number>;
+    static readonly discriminator: Buffer;
+    static readonly layout: any;
+    constructor(fields: TokenManagerFields);
+    static fetch(c: Connection, address: PublicKey, programId?: PublicKey): Promise<TokenManager | null>;
+    static fetchMultiple(c: Connection, addresses: PublicKey[], programId?: PublicKey): Promise<Array<TokenManager | null>>;
+    static decode(data: Buffer): TokenManager;
+    toJSON(): TokenManagerJSON;
+    static fromJSON(obj: TokenManagerJSON): TokenManager;
+}