@iqlabs-official/solana-sdk 0.1.0

package/dist/contract/instructions.d.ts

@@ -0,0 +1,246 @@
+import { BN, type Idl } from "@coral-xyz/anchor";
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+export type Bytes = Uint8Array;
+export type OptionalPubkey = PublicKey | null;
+export type OptionalPubkeyList = PublicKey[] | null;
+export type InstructionName = "create_admin_table" | "create_ext_table" | "create_private_table" | "create_session" | "create_table" | "database_instruction" | "db_code_in" | "db_instruction_code_in" | "wallet_connection_code_in" | "user_inventory_code_in" | "user_inventory_code_in_for_free" | "initialize_config" | "initialize_db_root" | "manage_connection" | "post_chunk" | "request_connection" | "send_code" | "server_initialize" | "set_merkle_root" | "update_db_root_table_list" | "update_table" | "update_user_metadata" | "user_initialize" | "write_connection_data" | "write_data";
+export type SessionFinalize = {
+    seq: BN;
+    total_chunks: number;
+};
+export type InstructionBuilder = {
+    programId: PublicKey;
+    build: <TArgs extends Record<string, unknown> | undefined>(name: InstructionName, accounts: Record<string, PublicKey | undefined>, args?: TArgs) => TransactionInstruction;
+};
+export declare const createInstructionBuilder: (idl: Idl, programId: PublicKey) => InstructionBuilder;
+export type TableCreateArgs = {
+    db_root_id: Bytes;
+    table_seed: Bytes;
+    table_name: Bytes;
+    column_names: Bytes[];
+    id_col: Bytes;
+    ext_keys: Bytes[];
+    gate_mint_opt: OptionalPubkey;
+    writers_opt: OptionalPubkeyList;
+};
+export type CreateAdminTableAccounts = {
+    signer: PublicKey;
+    db_root: PublicKey;
+    table: PublicKey;
+    instruction_table: PublicKey;
+    system_program?: PublicKey;
+};
+export declare const createAdminTableInstruction: (builder: InstructionBuilder, accounts: CreateAdminTableAccounts, args: TableCreateArgs) => TransactionInstruction;
+export declare const createExtTableInstruction: (builder: InstructionBuilder, accounts: CreateAdminTableAccounts, args: TableCreateArgs) => TransactionInstruction;
+export declare const createPrivateTableInstruction: (builder: InstructionBuilder, accounts: CreateAdminTableAccounts, args: TableCreateArgs) => TransactionInstruction;
+export declare const createSessionInstruction: (builder: InstructionBuilder, accounts: {
+    user: PublicKey;
+    user_state: PublicKey;
+    session: PublicKey;
+    system_program?: PublicKey;
+}, args: {
+    seq: BN;
+}) => TransactionInstruction;
+export declare const createTableInstruction: (builder: InstructionBuilder, accounts: {
+    db_root: PublicKey;
+    receiver: PublicKey;
+    signer: PublicKey;
+    table: PublicKey;
+    instruction_table: PublicKey;
+    system_program?: PublicKey;
+}, args: TableCreateArgs) => TransactionInstruction;
+export declare const userInventoryCodeInInstruction: (builder: InstructionBuilder, accounts: {
+    user: PublicKey;
+    user_inventory: PublicKey;
+    system_program?: PublicKey;
+    receiver: PublicKey;
+    session?: PublicKey;
+    iq_ata?: PublicKey;
+}, args: {
+    on_chain_path: string;
+    metadata: string;
+    session: SessionFinalize | null;
+}) => TransactionInstruction;
+export declare const userInventoryCodeInForFreeInstruction: (builder: InstructionBuilder, accounts: {
+    user: PublicKey;
+    user_inventory: PublicKey;
+    config: PublicKey;
+    system_program?: PublicKey;
+    session?: PublicKey;
+}, args: {
+    on_chain_path: string;
+    metadata: string;
+    session: SessionFinalize | null;
+    proof: Bytes[];
+}) => TransactionInstruction;
+export declare const initializeConfigInstruction: (builder: InstructionBuilder, accounts: {
+    user: PublicKey;
+    config: PublicKey;
+    system_program?: PublicKey;
+}, args: {
+    merkle_root: Bytes;
+}) => TransactionInstruction;
+export declare const initializeDbRootInstruction: (builder: InstructionBuilder, accounts: {
+    db_root: PublicKey;
+    signer: PublicKey;
+    system_program?: PublicKey;
+}, args: {
+    db_root_id: Bytes;
+}) => TransactionInstruction;
+export declare const manageConnectionInstruction: (builder: InstructionBuilder, accounts: {
+    db_root: PublicKey;
+    connection_table: PublicKey;
+    signer: PublicKey;
+}, args: {
+    db_root_id: Bytes;
+    connection_seed: Bytes;
+    new_status: number;
+}) => TransactionInstruction;
+export declare const postChunkInstruction: (builder: InstructionBuilder, accounts: {
+    user: PublicKey;
+    session: PublicKey;
+}, args: {
+    index: number;
+    chunk: string;
+    method: number;
+    decode_break: number;
+}) => TransactionInstruction;
+export declare const requestConnectionInstruction: (builder: InstructionBuilder, accounts: {
+    requester: PublicKey;
+    db_root: PublicKey;
+    connection_table: PublicKey;
+    instruction_table: PublicKey;
+    requester_user: PublicKey;
+    receiver_user: PublicKey;
+    table_ref: PublicKey;
+    target_table_ref: PublicKey;
+    system_program?: PublicKey;
+}, args: {
+    db_root_id: Bytes;
+    connection_seed: Bytes;
+    receiver: PublicKey;
+    table_name: Bytes;
+    column_names: Bytes[];
+    id_col: Bytes;
+    ext_keys: Bytes[];
+    user_payload: Bytes;
+}) => TransactionInstruction;
+export declare const sendCodeInstruction: (builder: InstructionBuilder, accounts: {
+    user: PublicKey;
+    code_account: PublicKey;
+    system_program?: PublicKey;
+}, args: {
+    code: string;
+    before_tx: string;
+    method: number;
+    decode_break: number;
+}) => TransactionInstruction;
+export declare const serverInitializeInstruction: (builder: InstructionBuilder, accounts: {
+    user: PublicKey;
+    server_account: PublicKey;
+    system_program?: PublicKey;
+}, args: {
+    server_id: string;
+    server_type: string;
+    allowed_merkle_root: string;
+}) => TransactionInstruction;
+export declare const setMerkleRootInstruction: (builder: InstructionBuilder, accounts: {
+    authority: PublicKey;
+    config: PublicKey;
+}, args: {
+    new_root: Bytes;
+    new_authority: OptionalPubkey;
+}) => TransactionInstruction;
+export declare const updateDbRootTableListInstruction: (builder: InstructionBuilder, accounts: {
+    db_root: PublicKey;
+    signer: PublicKey;
+}, args: {
+    db_root_id: Bytes;
+    new_table_seeds: Bytes[];
+}) => TransactionInstruction;
+export declare const updateTableInstruction: (builder: InstructionBuilder, accounts: {
+    db_root: PublicKey;
+    table: PublicKey;
+    signer: PublicKey;
+}, args: {
+    db_root_id: Bytes;
+    table_seed: Bytes;
+    table_name: Bytes;
+    column_names: Bytes[];
+    id_col: Bytes;
+    ext_keys: Bytes[];
+    writers_opt: OptionalPubkeyList;
+}) => TransactionInstruction;
+export declare const updateUserMetadataInstruction: (builder: InstructionBuilder, accounts: {
+    user: PublicKey;
+    db_root: PublicKey;
+    signer: PublicKey;
+    system_program?: PublicKey;
+}, args: {
+    db_root_id: Bytes;
+    meta: Bytes;
+}) => TransactionInstruction;
+export declare const userInitializeInstruction: (builder: InstructionBuilder, accounts: {
+    user: PublicKey;
+    code_account: PublicKey;
+    user_state: PublicKey;
+    user_inventory: PublicKey;
+    system_program?: PublicKey;
+}) => TransactionInstruction;
+export declare const walletConnectionCodeInInstruction: (builder: InstructionBuilder, accounts: {
+    user: PublicKey;
+    signer?: PublicKey;
+    user_inventory: PublicKey;
+    db_root: PublicKey;
+    connection_table: PublicKey;
+    table_ref: PublicKey;
+    system_program?: PublicKey;
+    receiver: PublicKey;
+    session?: PublicKey;
+    iq_ata?: PublicKey;
+}, args: {
+    db_root_id: Bytes;
+    connection_seed: Bytes;
+    on_chain_path: string;
+    metadata: string;
+    session: SessionFinalize | null;
+}) => TransactionInstruction;
+export declare const dbCodeInInstruction: (builder: InstructionBuilder, accounts: {
+    user: PublicKey;
+    signer?: PublicKey;
+    user_inventory: PublicKey;
+    db_root: PublicKey;
+    table: PublicKey;
+    signer_ata?: PublicKey;
+    system_program?: PublicKey;
+    receiver: PublicKey;
+    session?: PublicKey;
+    iq_ata?: PublicKey;
+}, args: {
+    db_root_id: Bytes;
+    table_seed: Bytes;
+    on_chain_path: string;
+    metadata: string;
+    session: SessionFinalize | null;
+}) => TransactionInstruction;
+export declare const dbInstructionCodeInInstruction: (builder: InstructionBuilder, accounts: {
+    user: PublicKey;
+    signer?: PublicKey;
+    user_inventory: PublicKey;
+    db_root: PublicKey;
+    table: PublicKey;
+    instruction_table: PublicKey;
+    signer_ata?: PublicKey;
+    system_program?: PublicKey;
+    receiver: PublicKey;
+    session?: PublicKey;
+    iq_ata?: PublicKey;
+}, args: {
+    db_root_id: Bytes;
+    table_seed: Bytes;
+    table_name: Bytes;
+    target_tx: Bytes;
+    on_chain_path: string;
+    metadata: string;
+    session: SessionFinalize | null;
+}) => TransactionInstruction;

package/dist/contract/instructions.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dbInstructionCodeInInstruction = exports.dbCodeInInstruction = exports.walletConnectionCodeInInstruction = exports.userInitializeInstruction = exports.updateUserMetadataInstruction = exports.updateTableInstruction = exports.updateDbRootTableListInstruction = exports.setMerkleRootInstruction = exports.serverInitializeInstruction = exports.sendCodeInstruction = exports.requestConnectionInstruction = exports.postChunkInstruction = exports.manageConnectionInstruction = exports.initializeDbRootInstruction = exports.initializeConfigInstruction = exports.userInventoryCodeInForFreeInstruction = exports.userInventoryCodeInInstruction = exports.createTableInstruction = exports.createSessionInstruction = exports.createPrivateTableInstruction = exports.createExtTableInstruction = exports.createAdminTableInstruction = exports.createInstructionBuilder = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const toAccountMeta = (account, accounts, programId) => {
+    const pubkey = account.address
+        ? new web3_js_1.PublicKey(account.address)
+        : accounts[account.name];
+    if (!pubkey) {
+        if (account.optional) {
+            // For optional accounts, pass the program ID as a placeholder
+            // This is how Anchor handles optional accounts - they expect the
+            // program ID to signal "None" rather than omitting the account
+            return {
+                pubkey: programId,
+                isSigner: false,
+                isWritable: false,
+            };
+        }
+        throw new Error(`Missing account: ${account.name}`);
+    }
+    return {
+        pubkey,
+        isSigner: Boolean(account.signer),
+        isWritable: Boolean(account.writable),
+    };
+};
+const createInstructionBuilder = (idl, programId) => {
+    const coder = new anchor_1.BorshInstructionCoder(idl);
+    const instructions = (idl.instructions ?? []);
+    const instructionMap = new Map(instructions.map((instruction) => [instruction.name, instruction]));
+    const build = (name, accounts, args) => {
+        const instruction = instructionMap.get(name);
+        if (!instruction) {
+            throw new Error(`Unknown instruction: ${name}`);
+        }
+        const keys = instruction.accounts.map((account) => toAccountMeta(account, accounts, programId));
+        const data = coder.encode(name, args ?? {});
+        return new web3_js_1.TransactionInstruction({ programId, keys, data });
+    };
+    return { programId, build };
+};
+exports.createInstructionBuilder = createInstructionBuilder;
+const createAdminTableInstruction = (builder, accounts, args) => builder.build("create_admin_table", accounts, args);
+exports.createAdminTableInstruction = createAdminTableInstruction;
+const createExtTableInstruction = (builder, accounts, args) => builder.build("create_ext_table", accounts, args);
+exports.createExtTableInstruction = createExtTableInstruction;
+const createPrivateTableInstruction = (builder, accounts, args) => builder.build("create_private_table", accounts, args);
+exports.createPrivateTableInstruction = createPrivateTableInstruction;
+const createSessionInstruction = (builder, accounts, args) => builder.build("create_session", accounts, args);
+exports.createSessionInstruction = createSessionInstruction;
+const createTableInstruction = (builder, accounts, args) => builder.build("create_table", accounts, args);
+exports.createTableInstruction = createTableInstruction;
+const userInventoryCodeInInstruction = (builder, accounts, args) => builder.build("user_inventory_code_in", accounts, args);
+exports.userInventoryCodeInInstruction = userInventoryCodeInInstruction;
+// SDK writer does not wrap this instruction yet; add a helper if needed.
+const userInventoryCodeInForFreeInstruction = (builder, accounts, args) => builder.build("user_inventory_code_in_for_free", accounts, args);
+exports.userInventoryCodeInForFreeInstruction = userInventoryCodeInForFreeInstruction;
+const initializeConfigInstruction = (builder, accounts, args) => builder.build("initialize_config", accounts, args);
+exports.initializeConfigInstruction = initializeConfigInstruction;
+const initializeDbRootInstruction = (builder, accounts, args) => builder.build("initialize_db_root", accounts, args);
+exports.initializeDbRootInstruction = initializeDbRootInstruction;
+const manageConnectionInstruction = (builder, accounts, args) => builder.build("manage_connection", accounts, args);
+exports.manageConnectionInstruction = manageConnectionInstruction;
+const postChunkInstruction = (builder, accounts, args) => builder.build("post_chunk", accounts, args);
+exports.postChunkInstruction = postChunkInstruction;
+const requestConnectionInstruction = (builder, accounts, args) => builder.build("request_connection", accounts, args);
+exports.requestConnectionInstruction = requestConnectionInstruction;
+const sendCodeInstruction = (builder, accounts, args) => builder.build("send_code", accounts, args);
+exports.sendCodeInstruction = sendCodeInstruction;
+const serverInitializeInstruction = (builder, accounts, args) => builder.build("server_initialize", accounts, args);
+exports.serverInitializeInstruction = serverInitializeInstruction;
+const setMerkleRootInstruction = (builder, accounts, args) => builder.build("set_merkle_root", accounts, args);
+exports.setMerkleRootInstruction = setMerkleRootInstruction;
+const updateDbRootTableListInstruction = (builder, accounts, args) => builder.build("update_db_root_table_list", accounts, args);
+exports.updateDbRootTableListInstruction = updateDbRootTableListInstruction;
+const updateTableInstruction = (builder, accounts, args) => builder.build("update_table", accounts, args);
+exports.updateTableInstruction = updateTableInstruction;
+const updateUserMetadataInstruction = (builder, accounts, args) => builder.build("update_user_metadata", accounts, args);
+exports.updateUserMetadataInstruction = updateUserMetadataInstruction;
+const userInitializeInstruction = (builder, accounts) => builder.build("user_initialize", accounts);
+exports.userInitializeInstruction = userInitializeInstruction;
+// export const writeConnectionDataInstruction = (
+//     builder: InstructionBuilder,
+//     accounts: {
+//         db_root: PublicKey;
+//         connection_table: PublicKey;
+//         table_ref: PublicKey;
+//         signer: PublicKey;
+//     },
+//     args: {
+//         db_root_id: Bytes;
+//         connection_seed: Bytes;
+//         row_json_tx: Bytes;
+//     },
+// ) => builder.build("write_connection_data", accounts, args);
+//
+// export const writeDataInstruction = (
+//     builder: InstructionBuilder,
+//     accounts: {
+//         db_root: PublicKey;
+//         table: PublicKey;
+//         signer_ata?: PublicKey;
+//         signer: PublicKey;
+//     },
+//     args: {
+//         db_root_id: Bytes;
+//         table_seed: Bytes;
+//         row_json_tx: Bytes;
+//     },
+// ) => builder.build("write_data", accounts, args);
+// export const databaseInstructionInstruction = (
+//     builder: InstructionBuilder,
+//     accounts: {
+//         db_root: PublicKey;
+//         table: PublicKey;
+//         instruction_table: PublicKey;
+//         signer_ata?: PublicKey;
+//         signer: PublicKey
+//     },
+//     args: { db_root_id: Bytes; table_seed: Bytes; table_name: Bytes; target_tx: Bytes; content_json_tx: Bytes },
+// ) => builder.build("database_instruction", accounts, args);
+const walletConnectionCodeInInstruction = (builder, accounts, args) => builder.build("wallet_connection_code_in", accounts, args);
+exports.walletConnectionCodeInInstruction = walletConnectionCodeInInstruction;
+const dbCodeInInstruction = (builder, accounts, args) => builder.build("db_code_in", accounts, args);
+exports.dbCodeInInstruction = dbCodeInInstruction;
+const dbInstructionCodeInInstruction = (builder, accounts, args) => builder.build("db_instruction_code_in", accounts, args);
+exports.dbInstructionCodeInInstruction = dbInstructionCodeInInstruction;

package/dist/contract/pda.d.ts

@@ -0,0 +1,16 @@
+import { PublicKey } from "@solana/web3.js";
+type Bytes = Uint8Array<any>;
+export declare const getDbRootPda: (dbRootId: Bytes, programId?: PublicKey) => PublicKey;
+export declare const getTablePda: (dbRoot: PublicKey, tableSeed: Bytes, programId?: PublicKey) => PublicKey;
+export declare const getInstructionTablePda: (dbRoot: PublicKey, tableSeed: Bytes, programId?: PublicKey) => PublicKey;
+export declare const getConnectionTablePda: (dbRoot: PublicKey, connectionSeed: Bytes, programId?: PublicKey) => PublicKey;
+export declare const getConnectionInstructionTablePda: (dbRoot: PublicKey, connectionSeed: Bytes, programId?: PublicKey) => PublicKey;
+export declare const getConnectionTableRefPda: (dbRoot: PublicKey, connectionSeed: Bytes, programId?: PublicKey) => PublicKey;
+export declare const getTargetTableRefPda: (dbRoot: PublicKey, tableSeed: Bytes, programId?: PublicKey) => PublicKey;
+export declare const getTargetConnectionTableRefPda: (dbRoot: PublicKey, connectionSeed: Bytes, programId?: PublicKey) => PublicKey;
+export declare const getUserPda: (user: PublicKey, programId?: PublicKey) => PublicKey;
+export declare const getSessionPda: (user: PublicKey, seq: bigint | number, programId?: PublicKey) => PublicKey;
+export declare const getCodeAccountPda: (user: PublicKey, programId?: PublicKey) => PublicKey;
+export declare const getUserInventoryPda: (user: PublicKey, programId?: PublicKey) => PublicKey;
+export declare const getServerAccountPda: (user: PublicKey, serverId: string, programId?: PublicKey) => PublicKey;
+export {};

package/dist/contract/pda.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServerAccountPda = exports.getUserInventoryPda = exports.getCodeAccountPda = exports.getSessionPda = exports.getUserPda = exports.getTargetConnectionTableRefPda = exports.getTargetTableRefPda = exports.getConnectionTableRefPda = exports.getConnectionInstructionTablePda = exports.getConnectionTablePda = exports.getInstructionTablePda = exports.getTablePda = exports.getDbRootPda = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("./constants");
+const profile_1 = require("./profile");
+const SEED_CONFIG_BYTES = Buffer.from(constants_1.SEED_CONFIG);
+const SEED_DB_ROOT_BYTES = Buffer.from(constants_1.SEED_DB_ROOT);
+const SEED_TABLE_BYTES = Buffer.from(constants_1.SEED_TABLE);
+const SEED_TABLE_REF_BYTES = Buffer.from(constants_1.SEED_TABLE_REF);
+const SEED_INSTRUCTION_BYTES = Buffer.from(constants_1.SEED_INSTRUCTION);
+const SEED_TARGET_BYTES = Buffer.from(constants_1.SEED_TARGET);
+const SEED_USER_BYTES = Buffer.from(constants_1.SEED_USER);
+const SEED_BUNDLE_BYTES = Buffer.from(constants_1.SEED_BUNDLE);
+const SEED_CONNECTION_BYTES = Buffer.from(constants_1.SEED_CONNECTION);
+const SEED_CODE_ACCOUNT_BYTES = Buffer.from(constants_1.SEED_CODE_ACCOUNT);
+const SEED_USER_INVENTORY_BYTES = Buffer.from(constants_1.SEED_USER_INVENTORY);
+const encodeBytesSeed = (value) => Buffer.from(value);
+const encodeU64Seed = (value) => {
+    const data = Buffer.alloc(8);
+    const numberValue = typeof value === "bigint" ? value : BigInt(value);
+    data.writeBigUInt64LE(numberValue, 0);
+    return data;
+};
+const findPda = (seeds, programId) => web3_js_1.PublicKey.findProgramAddressSync(seeds, programId)[0];
+const getProgramIdSeed = (programId) => programId.toBuffer();
+const getDbRootPda = (dbRootId, programId = (0, profile_1.getProgramId)()) => findPda([
+    SEED_DB_ROOT_BYTES,
+    getProgramIdSeed(programId),
+    encodeBytesSeed(dbRootId),
+], programId);
+exports.getDbRootPda = getDbRootPda;
+const getTablePda = (dbRoot, tableSeed, programId = (0, profile_1.getProgramId)()) => findPda([
+    SEED_TABLE_BYTES,
+    getProgramIdSeed(programId),
+    dbRoot.toBuffer(),
+    encodeBytesSeed(tableSeed),
+], programId);
+exports.getTablePda = getTablePda;
+const getInstructionTablePda = (dbRoot, tableSeed, programId = (0, profile_1.getProgramId)()) => findPda([
+    SEED_TABLE_BYTES,
+    getProgramIdSeed(programId),
+    dbRoot.toBuffer(),
+    encodeBytesSeed(tableSeed),
+    SEED_INSTRUCTION_BYTES,
+], programId);
+exports.getInstructionTablePda = getInstructionTablePda;
+const getConnectionTablePda = (dbRoot, connectionSeed, programId = (0, profile_1.getProgramId)()) => findPda([
+    SEED_CONNECTION_BYTES,
+    getProgramIdSeed(programId),
+    dbRoot.toBuffer(),
+    encodeBytesSeed(connectionSeed),
+], programId);
+exports.getConnectionTablePda = getConnectionTablePda;
+const getConnectionInstructionTablePda = (dbRoot, connectionSeed, programId = (0, profile_1.getProgramId)()) => findPda([
+    SEED_CONNECTION_BYTES,
+    getProgramIdSeed(programId),
+    dbRoot.toBuffer(),
+    encodeBytesSeed(connectionSeed),
+    SEED_INSTRUCTION_BYTES,
+], programId);
+exports.getConnectionInstructionTablePda = getConnectionInstructionTablePda;
+const getConnectionTableRefPda = (dbRoot, connectionSeed, programId = (0, profile_1.getProgramId)()) => findPda([
+    SEED_TABLE_REF_BYTES,
+    getProgramIdSeed(programId),
+    dbRoot.toBuffer(),
+    encodeBytesSeed(connectionSeed),
+], programId);
+exports.getConnectionTableRefPda = getConnectionTableRefPda;
+const getTargetTableRefPda = (dbRoot, tableSeed, programId = (0, profile_1.getProgramId)()) => findPda([
+    SEED_TABLE_REF_BYTES,
+    getProgramIdSeed(programId),
+    dbRoot.toBuffer(),
+    encodeBytesSeed(tableSeed),
+    SEED_TARGET_BYTES,
+], programId);
+exports.getTargetTableRefPda = getTargetTableRefPda;
+const getTargetConnectionTableRefPda = (dbRoot, connectionSeed, programId = (0, profile_1.getProgramId)()) => findPda([
+    SEED_TABLE_REF_BYTES,
+    getProgramIdSeed(programId),
+    dbRoot.toBuffer(),
+    encodeBytesSeed(connectionSeed),
+    SEED_TARGET_BYTES,
+], programId);
+exports.getTargetConnectionTableRefPda = getTargetConnectionTableRefPda;
+const getUserPda = (user, programId = (0, profile_1.getProgramId)()) => findPda([
+    SEED_USER_BYTES,
+    getProgramIdSeed(programId),
+    user.toBuffer(),
+], programId);
+exports.getUserPda = getUserPda;
+const getSessionPda = (user, seq, programId = (0, profile_1.getProgramId)()) => findPda([
+    SEED_BUNDLE_BYTES,
+    getProgramIdSeed(programId),
+    user.toBuffer(),
+    encodeU64Seed(seq),
+], programId);
+exports.getSessionPda = getSessionPda;
+const getCodeAccountPda = (user, programId = (0, profile_1.getProgramId)()) => findPda([SEED_CODE_ACCOUNT_BYTES, user.toBuffer()], programId);
+exports.getCodeAccountPda = getCodeAccountPda;
+const getUserInventoryPda = (user, programId = (0, profile_1.getProgramId)()) => findPda([SEED_USER_INVENTORY_BYTES, user.toBuffer()], programId);
+exports.getUserInventoryPda = getUserInventoryPda;
+const getServerAccountPda = (user, serverId, programId = (0, profile_1.getProgramId)()) => findPda([Buffer.from(serverId), user.toBuffer()], programId);
+exports.getServerAccountPda = getServerAccountPda;

package/dist/contract/profile.d.ts

@@ -0,0 +1,3 @@
+import { PublicKey } from "@solana/web3.js";
+export declare const resolveContractRuntime: (mode?: string) => "anchor" | "pinocchio";
+export declare const getProgramId: (mode?: string) => PublicKey;

package/dist/contract/profile.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProgramId = exports.resolveContractRuntime = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("../constants");
+const constants_2 = require("./constants");
+const DEFAULT_PROGRAM_IDS = {
+    anchor: new web3_js_1.PublicKey(constants_2.DEFAULT_ANCHOR_PROGRAM_ID),
+    pinocchio: new web3_js_1.PublicKey(constants_2.DEFAULT_PINOCCHIO_PROGRAM_ID),
+};
+const resolveContractRuntime = (mode = constants_1.DEFAULT_CONTRACT_MODE) => mode === "pinocchio" ? "pinocchio" : "anchor";
+exports.resolveContractRuntime = resolveContractRuntime;
+const getProgramId = (mode = constants_1.DEFAULT_CONTRACT_MODE) => DEFAULT_PROGRAM_IDS[(0, exports.resolveContractRuntime)(mode)];
+exports.getProgramId = getProgramId;

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import * as contract from "./contract";
+import * as reader from "./sdk/reader";
+import * as writer from "./sdk/writer";
+import * as wallet from "./sdk/utils/wallet";
+import * as constants from "./sdk/constants";
+import * as utils from "./sdk/utils";
+import { setRpcUrl } from "./sdk/utils/connection_helper";
+export { contract, reader, writer, constants, wallet, utils, setRpcUrl };
+import { getRpcUrl } from "./sdk/utils/connection_helper";
+declare const iqlabs: {
+    contract: typeof contract;
+    reader: typeof reader;
+    writer: typeof writer;
+    utils: typeof utils;
+    wallet: typeof wallet;
+    constants: typeof constants;
+    setRpcUrl: typeof setRpcUrl;
+    getRpcUrl: typeof getRpcUrl;
+};
+export { iqlabs };
+export default iqlabs;

package/dist/index.js

@@ -0,0 +1,63 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iqlabs = exports.setRpcUrl = exports.utils = exports.wallet = exports.constants = exports.writer = exports.reader = exports.contract = void 0;
+const contract = __importStar(require("./contract"));
+exports.contract = contract;
+const reader = __importStar(require("./sdk/reader"));
+exports.reader = reader;
+const writer = __importStar(require("./sdk/writer"));
+exports.writer = writer;
+const wallet = __importStar(require("./sdk/utils/wallet"));
+exports.wallet = wallet;
+const constants = __importStar(require("./sdk/constants"));
+exports.constants = constants;
+const utils = __importStar(require("./sdk/utils"));
+exports.utils = utils;
+const connection_helper_1 = require("./sdk/utils/connection_helper");
+Object.defineProperty(exports, "setRpcUrl", { enumerable: true, get: function () { return connection_helper_1.setRpcUrl; } });
+const connection_helper_2 = require("./sdk/utils/connection_helper");
+const iqlabs = {
+    contract,
+    reader,
+    writer,
+    utils,
+    wallet,
+    constants,
+    setRpcUrl: connection_helper_1.setRpcUrl,
+    getRpcUrl: connection_helper_2.getRpcUrl,
+};
+exports.iqlabs = iqlabs;
+exports.default = iqlabs;

package/dist/sdk/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const DEFAULT_LINKED_LIST_THRESHOLD = 10;
+export declare const CHUNK_SIZE = 800;
+export declare const DIRECT_METADATA_MAX_BYTES = 900;
+export declare const DEFAULT_WRITE_FEE_RECEIVER = "EWNSTD8tikwqHMcRNuuNbZrnYJUiJdKq9UXLXSEU4wZ1";
+export declare const DEFAULT_IQ_MINT = "3uXACfojUrya7VH51jVC1DCHq3uzK4A7g469Q954LABS";

package/dist/sdk/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_IQ_MINT = exports.DEFAULT_WRITE_FEE_RECEIVER = exports.DIRECT_METADATA_MAX_BYTES = exports.CHUNK_SIZE = exports.DEFAULT_LINKED_LIST_THRESHOLD = void 0;
+exports.DEFAULT_LINKED_LIST_THRESHOLD = 10;
+exports.CHUNK_SIZE = 800;
+exports.DIRECT_METADATA_MAX_BYTES = 900;
+exports.DEFAULT_WRITE_FEE_RECEIVER = "EWNSTD8tikwqHMcRNuuNbZrnYJUiJdKq9UXLXSEU4wZ1";
+exports.DEFAULT_IQ_MINT = "3uXACfojUrya7VH51jVC1DCHq3uzK4A7g469Q954LABS";

package/dist/sdk/reader/index.d.ts

@@ -0,0 +1,5 @@
+export { deriveDmSeed } from "../utils/seed";
+export { readCodeIn } from "./read_code_in";
+export { readConnection, readTableRows, collectSignatures, getTablelistFromRoot, } from "./iqdb";
+export { readUserState, readInventoryMetadata, fetchInventoryTransactions, } from "./reading_flow";
+export { getSessionPdaList, fetchUserConnections, } from "./reader_utils";

package/dist/sdk/reader/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchUserConnections = exports.getSessionPdaList = exports.fetchInventoryTransactions = exports.readInventoryMetadata = exports.readUserState = exports.getTablelistFromRoot = exports.collectSignatures = exports.readTableRows = exports.readConnection = exports.readCodeIn = exports.deriveDmSeed = void 0;
+var seed_1 = require("../utils/seed");
+Object.defineProperty(exports, "deriveDmSeed", { enumerable: true, get: function () { return seed_1.deriveDmSeed; } });
+var read_code_in_1 = require("./read_code_in");
+Object.defineProperty(exports, "readCodeIn", { enumerable: true, get: function () { return read_code_in_1.readCodeIn; } });
+var iqdb_1 = require("./iqdb");
+Object.defineProperty(exports, "readConnection", { enumerable: true, get: function () { return iqdb_1.readConnection; } });
+Object.defineProperty(exports, "readTableRows", { enumerable: true, get: function () { return iqdb_1.readTableRows; } });
+Object.defineProperty(exports, "collectSignatures", { enumerable: true, get: function () { return iqdb_1.collectSignatures; } });
+Object.defineProperty(exports, "getTablelistFromRoot", { enumerable: true, get: function () { return iqdb_1.getTablelistFromRoot; } });
+var reading_flow_1 = require("./reading_flow");
+Object.defineProperty(exports, "readUserState", { enumerable: true, get: function () { return reading_flow_1.readUserState; } });
+Object.defineProperty(exports, "readInventoryMetadata", { enumerable: true, get: function () { return reading_flow_1.readInventoryMetadata; } });
+Object.defineProperty(exports, "fetchInventoryTransactions", { enumerable: true, get: function () { return reading_flow_1.fetchInventoryTransactions; } });
+var reader_utils_1 = require("./reader_utils");
+Object.defineProperty(exports, "getSessionPdaList", { enumerable: true, get: function () { return reader_utils_1.getSessionPdaList; } });
+Object.defineProperty(exports, "fetchUserConnections", { enumerable: true, get: function () { return reader_utils_1.fetchUserConnections; } });

package/dist/sdk/reader/iqdb.d.ts

@@ -0,0 +1,19 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+export declare function readConnection(dbRootId: Uint8Array<any> | string, partyA: string, partyB: string, mode?: string): Promise<{
+    status: "pending" | "approved" | "blocked" | "unknown";
+    requester: "a" | "b";
+    blocker: "a" | "b" | "none";
+}>;
+export declare function getTablelistFromRoot(connection: Connection, dbRootId: Uint8Array | string, mode?: string): Promise<{
+    rootPda: PublicKey;
+    creator: string;
+    tableSeeds: any;
+    globalTableSeeds: any;
+}>;
+export declare function readTableRows(account: PublicKey | string, options?: {
+    before?: string;
+    limit?: number;
+    signatures?: string[];
+    speed?: string;
+}): Promise<Array<Record<string, unknown>>>;
+export declare function collectSignatures(account: PublicKey | string, maxSignatures?: number): Promise<string[]>;