@xgamesfun/solana 0.0.0-stage → 0.20.1

package/types/chain/curve.d.ts

@@ -0,0 +1 @@
+export declare function isOnCurve(bytes: any): boolean;

package/types/chain/lookup.d.ts

@@ -0,0 +1,191 @@
+export declare const LOOKUP_TABLE_PROGRAM = "AddressLookupTab1e1111111111111111111111111";
+/** A table's account: 56 bytes of header, then its addresses, 32 bytes each (at most 256). */
+export declare const TABLE_HEADER_BYTES = 56;
+export declare const TABLE_MAX_ADDRESSES = 256;
+/** The accounts a transaction may lock. */
+export declare const MAX_ACCOUNT_LOCKS = 64;
+/** A deactivated table can be closed once its deactivation slot has left the 512 recent slot hashes. */
+export declare const TABLE_COOLDOWN_SLOTS = 513n;
+/** The table `authority` makes at `slot` (a recent slot: the table's address names it): [address, bump]. */
+export declare const tableAddress: (authority: any, slot: any) => any;
+/** Makes the table `authority` owns at `slot`, its rent paid by `payer`. Returns { address, instruction }. */
+export declare function createTableIx({ authority, payer, slot }: {
+    authority: any;
+    payer?: any;
+    slot: any;
+}): {
+    address: any;
+    instruction: {
+        programId: string;
+        keys: any;
+        data: any;
+    };
+};
+/** Adds `addresses` to `table`, the rent of its growth paid by `payer`. */
+export declare const extendTableIx: ({ table, authority, payer, addresses }: {
+    addresses: any;
+    authority: any;
+    payer?: any;
+    table: any;
+}) => {
+    programId: string;
+    keys: any;
+    data: any;
+};
+/** Freezes `table`: nobody can add to it or close it after. */
+export declare const freezeTableIx: ({ table, authority }: {
+    authority: any;
+    table: any;
+}) => {
+    programId: string;
+    keys: any;
+    data: any;
+};
+/** Deactivates `table`: transactions can still use it until it cools down, then it can be closed. */
+export declare const deactivateTableIx: ({ table, authority }: {
+    authority: any;
+    table: any;
+}) => {
+    programId: string;
+    keys: any;
+    data: any;
+};
+/** Closes a cooled-down `table`: its rent goes to `recipient`. */
+export declare const closeTableIx: ({ table, authority, recipient }: {
+    authority: any;
+    recipient?: any;
+    table: any;
+}) => {
+    programId: string;
+    keys: any;
+    data: any;
+};
+/**
+ * A table's account read back: { authority (null once frozen), deactivationSlot (null while active),
+ * lastExtendedSlot, addresses }, or null when `account` is not a lookup table.
+ */
+export declare function readTable(account: any): {
+    authority: string | null;
+    deactivationSlot: bigint | null;
+    lastExtendedSlot: bigint;
+    addresses: string[];
+} | null;
+/** The filter that finds the tables `authority` owns (getProgramAccounts on LOOKUP_TABLE_PROGRAM). */
+export declare const tablesOf: (authority: any) => {
+    memcmp: {
+        offset: number;
+        bytes: any;
+    };
+}[];
+/**
+ * The slots the SlotHashes sysvar holds (its account's data: a count, then a slot and a hash each), newest first. It
+ * holds the last 512 slots that had a block: a table is made at one of them, and closes only once its deactivation
+ * slot has left them.
+ */
+export declare function slotHashes(data: any): bigint[];
+/** How many slots the SlotHashes sysvar holds when full. */
+export declare const SLOT_HASHES_HELD = 512;
+/**
+ * What is due for a table of yours at `slot`: 'close' (deactivated, and its deactivation slot has left `recent`, the
+ * slots SlotHashes holds: its rent comes back), 'cooling' (deactivated, not yet closable), or 'active'. A table is
+ * closable only when `recent` is a full read (512 slots) and its deactivation slot is older than all of them: an empty
+ * or short read (an RPC that answered nothing, a young chain) says cooling. Without `recent`, a table is counted
+ * closable 513 slots after its deactivation, which skipped slots can make too early.
+ */
+export declare function tableStep(table: any, slot: any, recent?: null): "active" | "close" | "cooling";
+/**
+ * How many accounts a transaction of `instructions` from `payer` locks: every account once, its programs included. As
+ * v0 with a lookup table it deactivates (`planTable`), the table and the lookup-table program are two more
+ * (`asV0`).
+ */
+export declare function transactionLocks(payer: any, instructions: any, { asV0 }?: {
+    asV0?: boolean | undefined;
+}): number;
+/** The accounts of `instructions` a table can hold: every one that is neither a signer nor a program they call, once. */
+export declare function tableAccounts(instructions: any): any[];
+/**
+ * The message for `instructions` from `payer`: legacy when it fits, else v0 loading what it can from `tables`
+ * ([{ address, addresses }]). null when neither fits.
+ */
+export declare function compileFitting({ payer, blockhash, instructions, tables }: {
+    blockhash: any;
+    instructions: any;
+    payer: any;
+    tables?: never[] | undefined;
+}): Uint8Array<any> | null;
+/**
+ * The plan for sending `instructions` from `payer` as v0 with a table of their accounts made at `slot`, `first` the
+ * addresses it holds first:
+ * { table: { address, addresses }, steps: [instructions…] (each a legacy transaction: the table's creation and as
+ * many additions as it takes), final: the instructions with the table's deactivation after them }. null when even that
+ * does not fit (more accounts than a transaction can lock, or instructions too long).
+ */
+export declare function planTable({ payer, blockhash, slot, instructions, first }: {
+    blockhash: any;
+    first?: never[] | undefined;
+    instructions: any;
+    payer: any;
+    slot: any;
+}): {
+    table: {
+        address: any;
+        addresses: any[];
+    };
+    steps: {
+        programId: string;
+        keys: any;
+        data: any;
+    }[][];
+    final: any[];
+} | null;
+/**
+ * How `instructions` from `payer` can be sent, decided before anyone signs:
+ *   { legacy: true }                              they fit a legacy transaction;
+ *   { table: true, first: [] }                    they fit one v0 transaction with a lookup table of their accounts,
+ *                                                 a compressed NFT's prove_leaf included (one transaction: nobody can
+ *                                                 prove its leaf again between the proof and the move);
+ *   { first, rest, table }                        only when they don't: `first`, the instructions `alone` picks (each
+ *                                                 compressed NFT's prove_leaf), each sent alone with the transaction's
+ *                                                 compute-budget instructions, after the table is made (`table`: the
+ *                                                 rest goes as v0 with one) or before a legacy rest.
+ * null when nothing fits: more accounts than a transaction locks, or instructions too long even as v0.
+ */
+export declare function sendPlan({ payer, blockhash, instructions, alone }: {
+    alone?: (() => boolean) | undefined;
+    blockhash?: string | undefined;
+    instructions: any;
+    payer: any;
+}): {
+    legacy: boolean;
+    first: any;
+    budget: any;
+    rest: any;
+    table: boolean;
+} | null;
+declare const pause: (ms: any) => Promise<any>;
+/**
+ * Sends `instructions` paid by `payer` (the only signer of a table's own transactions) and confirms it, as `sendPlan`
+ * decides before anything is signed: legacy when it fits; else one v0 transaction with a lookup table `payer` makes
+ * first (`planTable`); else the table first, then each compressed NFT's prove_leaf alone, then the rest as v0 (or the
+ * proofs then a legacy rest, when that fits with no table). The v0 transaction is compiled against the table as the
+ * chain holds it. `sign(message)` → the signed wire transaction. `rpc`: the client's (latestBlockhash, send, confirm,
+ * account, call('getSlot')). `table: false` sends no lookup table (a throwaway key holds no rent for one); `first`:
+ * addresses a table holds first (`planTable`). Throws a
+ * plain sentence when it can't be sent. Returns { signature (the last transaction's), table (its address, or null),
+ * steps (the signatures of the transactions before it) }.
+ */
+export declare function sendFitting({ rpc, payer, instructions, sign, table, alone, first, sleep }: {
+    alone?: (() => boolean) | undefined;
+    first?: never[] | undefined;
+    instructions: any;
+    payer: any;
+    rpc: any;
+    sign: any;
+    sleep?: typeof pause | undefined;
+    table?: boolean | undefined;
+}): Promise<{
+    signature: any;
+    table: any;
+    steps: any[];
+}>;
+export {};

package/types/chain/mint.d.ts

@@ -0,0 +1,25 @@
+/** Metaplex token metadata: key, update authority and mint come before name, symbol and uri. */
+export declare function parseMetaplexMetadata(data: any): {
+    mint: string;
+    name: string;
+    symbol: string;
+    uri: string;
+};
+/**
+ * A mint account read: `owner` is the account's program. Returns null when it is not a mint: a classic mint is exactly
+ * 82 bytes; a Token-2022 mint is 82 bytes, or longer than a token account with its account type saying mint (a
+ * Token-2022 token account with extensions is longer too, and says it is an account).
+ * metadataData: the Metaplex metadata account's data, when there is one.
+ */
+export declare function parseMint(address: any, owner: any, data: any, metadataData?: null): {
+    mint: any;
+    program: string;
+    native: boolean;
+    decimals: any;
+    supply: string;
+    mintAuthority: string | null;
+    freezeAuthority: string | null;
+    name: string | null;
+    symbol: string | null;
+    uri: string | null;
+} | null;

package/types/chain/pda.d.ts

@@ -0,0 +1,25 @@
+export declare const SYSTEM_PROGRAM = "11111111111111111111111111111111";
+export declare const TOKEN_PROGRAM = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+export declare const TOKEN_2022_PROGRAM = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
+export declare const ASSOCIATED_TOKEN_PROGRAM = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+export declare const COMPUTE_BUDGET_PROGRAM = "ComputeBudget111111111111111111111111111111";
+export declare const METAPLEX_METADATA_PROGRAM = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
+/** Metaplex Core: the program of Core assets and collections. */
+export declare const MPL_CORE_PROGRAM = "CoREENxT6tW1HoK8ypY1SxRMZTcVPm7R94rH4PZNhX7d";
+export declare const SYSVAR_INSTRUCTIONS = "Sysvar1nstructions1111111111111111111111111";
+export declare const SYSVAR_SLOT_HASHES = "SysvarS1otHashes111111111111111111111111111";
+/** Wrapped SOL: a shop priced in SOL holds this mint, and players pay plain SOL. */
+export declare const NATIVE_MINT = "So11111111111111111111111111111111111111112";
+/** The address for these seeds (bump included), or null when it lands on the curve (not a valid PDA). */
+export declare function createProgramAddress(seeds: any, programId: any): string | null;
+/** The canonical PDA and its bump: the highest bump whose address is off the curve. */
+export declare function findProgramAddress(seeds: any, programId: any): any;
+/** The PDA address alone. */
+export declare const pdaOf: (seeds: any, programId: any) => any;
+/** `owner`'s associated token account for `mint` (the owner may itself be a PDA). */
+export declare function associatedTokenAddress(owner: any, mint: any, tokenProgram?: string): any;
+/**
+ * The address System's `CreateAccountWithSeed` makes from `base`, a `seed` text (32 bytes at most) and the program that
+ * will own it: sha256(base | seed | owner). Only `base` signs for it, so no new key is needed.
+ */
+export declare function addressWithSeed(base: any, seed: any, owner: any): string;

package/types/chain/programs.d.ts

@@ -0,0 +1,65 @@
+/** An account as an instruction lists it. */
+export declare const meta: (pubkey: any, isSigner: any, isWritable: any) => {
+    pubkey: any;
+    isSigner: any;
+    isWritable: any;
+};
+export declare function transferLamports(from: any, to: any, lamports: any): {
+    programId: string;
+    keys: {
+        pubkey: any;
+        isSigner: any;
+        isWritable: any;
+    }[];
+    data: Uint8Array<any>;
+};
+/** Compute Budget `RequestHeapFrame`: the transaction's programs get a heap of `bytes` (a multiple of 1 KiB, 32 KiB to 256 KiB). */
+export declare const requestHeapFrame: (bytes: any) => {
+    programId: string;
+    keys: never[];
+    data: Uint8Array<any>;
+};
+export declare const computeUnitLimit: (units: any) => {
+    programId: string;
+    keys: never[];
+    data: Uint8Array<any>;
+};
+export declare const computeUnitPrice: (microLamports: any) => {
+    programId: string;
+    keys: never[];
+    data: Uint8Array<any>;
+};
+/** Create `owner`'s token account for `mint` unless it already exists; `payer` pays the rent. */
+export declare function createAssociatedTokenAccountIdempotent(payer: any, owner: any, mint: any, tokenProgram?: string): {
+    programId: string;
+    keys: {
+        pubkey: any;
+        isSigner: any;
+        isWritable: any;
+    }[];
+    data: Uint8Array<ArrayBuffer>;
+};
+export declare const syncNative: (account: any) => {
+    programId: string;
+    keys: {
+        pubkey: any;
+        isSigner: any;
+        isWritable: any;
+    }[];
+    data: Uint8Array<ArrayBuffer>;
+};
+export declare const closeTokenAccount: (account: any, destination: any, owner: any) => {
+    programId: string;
+    keys: {
+        pubkey: any;
+        isSigner: any;
+        isWritable: any;
+    }[];
+    data: Uint8Array<ArrayBuffer>;
+};
+/**
+ * A purchase from a shop priced in SOL: wrap exactly the price into the player's wrapped-SOL account first and close
+ * that account after, so the player pays and keeps plain SOL. Other mints pass through. Compute-budget instructions
+ * stay in front.
+ */
+export declare function withSolWrap(player: any, mint: any, price: any, instructions: any): any;

package/types/chain/rpc.d.ts

@@ -0,0 +1,66 @@
+/** A JSON-RPC failure, with the node's own message (and logs for a failed simulation). */
+export declare class RpcError extends Error {
+    code: any;
+    logs: any;
+    constructor(message: any, { code, logs }?: Readonly<Record<string, any>>);
+}
+declare const sleep: (ms: any) => Promise<any>;
+/** The first block of each public Solana cluster: it names the cluster whatever URL reaches it. */
+export declare const GENESIS: Readonly<{
+    devnet: "EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG";
+    mainnet: "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d";
+    testnet: "4uhcVJyU9pJkvQyS88uRDiswHXSCkY3zQawwpjk2NsNY";
+}>;
+/** Refuses an RPC URL that names mainnet. Returns the URL. */
+export declare function notMainnet(url: any): any;
+/**
+ * Refuses a chain that is mainnet or testnet, by its genesis block, whatever its URL says (a local validator is
+ * let through). `rpc` has `call`. Returns the genesis hash.
+ */
+export declare function checkCluster(rpc: any): Promise<any>;
+/** The program's own words for a failed run (`AnchorError … Error Message: …`), else the last error log line. */
+export declare function programError(err: any, logs: any): any;
+/** A client for one RPC URL. `fetchImpl` and `sleepImpl` are for tests. */
+export declare function rpcClient(url: any, { fetchImpl, sleepImpl }?: {
+    fetchImpl?: typeof fetch | undefined;
+    sleepImpl?: typeof sleep | undefined;
+}): {
+    url: any;
+    call: (method: any, params?: any[]) => Promise<any>;
+    /** Accounts as of `commitment`; `minContextSlot`: from a node that has seen at least that slot (one's own landed send). */
+    accounts: (addresses: any, commitment?: string, { minContextSlot }?: Readonly<Record<string, any>>) => Promise<any[]>;
+    account(address: any, commitment?: string, options?: {}): Promise<any>;
+    latestBlockhash(): Promise<{
+        blockhash: any;
+        lastValidBlockHeight: any;
+    }>;
+    blockHeight(): Promise<any>;
+    balance(address: any): Promise<bigint>;
+    /**
+     * A token account's balance in base units, or 0n when there is no account there. Any other refusal throws: an
+     * address that is not a token account (a wallet's, passed by mistake: "Invalid param: not a Token account") is
+     * not an empty one.
+     */
+    tokenBalance(tokenAccount: any): Promise<bigint>;
+    programAccounts(program: any, filters: any): Promise<any>;
+    /**
+     * Dry-run a wire transaction (empty signature slots are fine). Throws with the program's reason when it fails.
+     * `accounts`: addresses whose state after the run to return (base64-decoded, or null).
+     */
+    simulate(wire: any, { accounts: watch, replaceBlockhash }?: {
+        accounts?: never[] | undefined;
+        replaceBlockhash?: boolean | undefined;
+    }): Promise<{
+        unitsConsumed: any;
+        logs: any;
+        accounts: any;
+    }>;
+    send(wire: any): Promise<any>;
+    signatureStatus: (signature: any) => Promise<any>;
+    /** Wait until a sent transaction is confirmed; throws with the program's reason when it failed. */
+    confirm(signature: any, { timeoutMs, lastValidBlockHeight }?: {
+        lastValidBlockHeight?: null | undefined;
+        timeoutMs?: number | undefined;
+    }): Promise<any>;
+};
+export {};

package/types/chain/sha256.d.ts

@@ -0,0 +1 @@
+export declare function sha256(message: any): Uint8Array<ArrayBuffer>;

package/types/chain/token.d.ts

@@ -0,0 +1,141 @@
+/** A classic mint's size. */
+export declare const MINT_BYTES = 82;
+/** A classic token account's size. */
+export declare const TOKEN_ACCOUNT_BYTES = 165;
+/** System `CreateAccount`: `from` pays `lamports` for `space` bytes at `address` (which signs), owned by `owner`. */
+export declare function createAccountIx({ from, address, lamports, space, owner }: {
+    address: any;
+    from: any;
+    lamports: any;
+    owner: any;
+    space: any;
+}): {
+    programId: string;
+    keys: {
+        pubkey: any;
+        isSigner: any;
+        isWritable: any;
+    }[];
+    data: Uint8Array<any>;
+};
+/**
+ * System `CreateAccountWithSeed`: `from` pays `lamports` for `space` bytes at `addressWithSeed(from, seed, owner)`, owned
+ * by `owner`. `from` is the base too, so it alone signs.
+ */
+export declare function createAccountWithSeedIx({ from, address, seed, lamports, space, owner }: {
+    address: any;
+    from: any;
+    lamports: any;
+    owner: any;
+    seed: any;
+    space: any;
+}): {
+    programId: string;
+    keys: {
+        pubkey: any;
+        isSigner: any;
+        isWritable: any;
+    }[];
+    data: Uint8Array<any>;
+};
+/**
+ * System `AllocateWithSeed`: the account at `addressWithSeed(base, seed, owner)`, which holds only lamports (System's, no
+ * data), gets `space` bytes and becomes `owner`'s. `base` alone signs. Unlike `CreateAccountWithSeed` it takes an address
+ * someone already sent lamports to; whoever pays tops it up to the rent first (a System transfer).
+ */
+export declare function allocateWithSeedIx({ base, address, seed, space, owner }: {
+    address: any;
+    base: any;
+    owner: any;
+    seed: any;
+    space: any;
+}): {
+    programId: string;
+    keys: {
+        pubkey: any;
+        isSigner: any;
+        isWritable: any;
+    }[];
+    data: Uint8Array<any>;
+};
+/** Token `InitializeAccount3`: `account` (made empty first) becomes a token account of `mint` that `owner` holds. */
+export declare const initializeAccount3Ix: ({ account, mint, owner, tokenProgram }: {
+    account: any;
+    mint: any;
+    owner: any;
+    tokenProgram?: string | undefined;
+}) => {
+    programId: string;
+    keys: {
+        pubkey: any;
+        isSigner: any;
+        isWritable: any;
+    }[];
+    data: Uint8Array<any>;
+};
+/** Token `InitializeMint2`. */
+export declare function initializeMint2Ix({ mint, decimals, authority, freezeAuthority, tokenProgram }: {
+    authority: any;
+    decimals: any;
+    freezeAuthority?: null | undefined;
+    mint: any;
+    tokenProgram?: string | undefined;
+}): {
+    programId: string;
+    keys: {
+        pubkey: any;
+        isSigner: any;
+        isWritable: any;
+    }[];
+    data: Uint8Array<any>;
+};
+/** Token `MintTo`: `authority` (the mint authority, which signs) mints `amount` into the token account `to`. */
+export declare const mintToIx: ({ mint, to, authority, amount, tokenProgram }: {
+    amount: any;
+    authority: any;
+    mint: any;
+    to: any;
+    tokenProgram?: string | undefined;
+}) => {
+    programId: string;
+    keys: {
+        pubkey: any;
+        isSigner: any;
+        isWritable: any;
+    }[];
+    data: Uint8Array<any>;
+};
+/** Token `TransferChecked`. */
+export declare const transferCheckedIx: ({ from, mint, to, owner, amount, decimals, tokenProgram }: {
+    amount: any;
+    decimals: any;
+    from: any;
+    mint: any;
+    owner: any;
+    to: any;
+    tokenProgram?: string | undefined;
+}) => {
+    programId: string;
+    keys: {
+        pubkey: any;
+        isSigner: any;
+        isWritable: any;
+    }[];
+    data: Uint8Array<any>;
+};
+/** Token `SetAuthority` of a mint's minting (`kind` 0) or freezing (1) to `newAuthority` (null: none). */
+export declare const setAuthorityIx: ({ account, current, kind, newAuthority, tokenProgram }: {
+    account: any;
+    current: any;
+    kind?: number | undefined;
+    newAuthority: any;
+    tokenProgram?: string | undefined;
+}) => {
+    programId: string;
+    keys: {
+        pubkey: any;
+        isSigner: any;
+        isWritable: any;
+    }[];
+    data: Uint8Array<any>;
+};

package/types/chain/token2022.d.ts

@@ -0,0 +1,53 @@
+export declare const MEMO_PROGRAM = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
+/** The hook interface's Execute instruction: its discriminator, then the amount (u64). */
+export declare const EXECUTE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+/** The value of extension `type` in a Token-2022 mint or account, or null. */
+export declare function extension(data: any, type: any): any;
+/** The transfer hook program a Token-2022 mint names, or null. */
+export declare function hookProgramOf(mintData: any): string | null;
+/**
+ * Whether a mint's new accounts start frozen, or can be made to (as the program judges it): a Token-2022
+ * mint carrying `DefaultAccountState` set to frozen, or set to anything while it has a freeze authority, which can switch
+ * it to frozen whenever it likes. An auction, a contest, a lottery, an offer and a sealed schedule refuse such a mint:
+ * each reads the setting once, as it opens, and a refund or payout opened into a frozen account would never land.
+ */
+export declare function mayStartFrozen({ owner, data }: {
+    data: any;
+    owner: any;
+}): boolean;
+/**
+ * Who can stop a mint's tokens moving, read from its account (`owner`, its token program; `data`): its freeze authority
+ * (it can freeze any account of the mint), a Token-2022 pause (`PausableConfig`: its authority stops every transfer), a
+ * transfer hook (its program runs on every transfer and can refuse one), a permanent delegate (it can move anyone's
+ * tokens of the mint away). Each is [{ power, holder }], `holder` the address that has it. Empty for a plain mint.
+ */
+export declare function mintPowers({ owner, data }: {
+    data: any;
+    owner: any;
+}): any[];
+/** Whether a token account requires a memo on every transfer into it. */
+export declare function requiresMemo(accountData: any): boolean;
+/** The hook's list of extra accounts for this mint. */
+export declare const validationAddress: (mint: any, hookProgram: any) => any;
+/** The ExtraAccountMeta entries of an "extra-account-metas" account: [{ discriminator, config, isSigner, isWritable }]. */
+export declare function readExtraMetas(data: any): {
+    discriminator: any;
+    config: any;
+    isSigner: boolean;
+    isWritable: boolean;
+}[];
+/**
+ * The accounts to append after an instruction's own remaining accounts so every transfer of `mint` it makes can run:
+ * [] for a classic mint; the Memo program, and for a hooked mint the hook's accounts, for a Token-2022 one.
+ * `transfers`: the transfers the instruction makes ({ source, destination, authority, amount }), needed only when the
+ * hook's list depends on them; the accounts of all of them are passed. `rpc` reads the mint and the hook's list.
+ */
+export declare function transferExtras(rpc: any, mint: any, transfers?: any[]): Promise<any[]>;
+/** Length of a newly created associated account, including Token-2022's immutable owner. */
+export declare function associatedAccountSize(mintAccount: any): number;
+/** Shared browser/keeper resolution for all transfers of one mint, preserving role accounts before extras. */
+export declare function resolveTransfers(rpc: any, mint: any, transfers?: any[]): Promise<{
+    tokenProgram: any;
+    accountSize: number;
+    extraAccounts: any[];
+}>;

package/types/chain/tx.d.ts

@@ -0,0 +1,60 @@
+/** A serialized transaction must fit one packet. */
+export declare const MAX_TRANSACTION_BYTES = 1232;
+export declare const SIGNATURE_BYTES = 64;
+/**
+ * A message. `version` is 'legacy' (default) or 0. For v0, `lookupTables` is [{ address, addresses: [base58] }]:
+ * read-only and writable accounts that are neither signers nor invoked programs load from a table when it holds them.
+ */
+export declare function compileMessage({ payer, blockhash, instructions, version, lookupTables }: {
+    blockhash: any;
+    instructions: any;
+    lookupTables?: never[] | undefined;
+    payer: any;
+    version?: string | undefined;
+}): Uint8Array<any>;
+/**
+ * The parts of a message: version, header, static keys, blockhash and compiled instructions. Throws, saying so, on a
+ * message cut short or with bytes after its end.
+ */
+export declare function readMessage(message: any): {
+    version: string;
+    header: {
+        numRequiredSignatures: any;
+        numReadonlySigned: any;
+        numReadonlyUnsigned: any;
+    };
+    keys: string[];
+    blockhash: string;
+    instructions: {
+        programIndex: any;
+        accountIndexes: any[];
+        data: any;
+    }[];
+    lookups: {
+        address: string;
+        writable: any[];
+        readonly: any[];
+    }[];
+};
+/** The addresses that must sign a message, in signature-slot order. */
+export declare function signersOf(message: any): string[];
+/** The wire form: one signature slot per required signer (empty unless given), then the message. */
+export declare function wireTransaction(message: any, signatures?: any[]): Uint8Array<any>;
+/** A wire transaction read back: its signatures, its message bytes and its signers. */
+export declare function readTransaction(wire: any): {
+    signatures: any[];
+    message: any;
+    signers: string[];
+};
+/** A copy of the wire transaction with `signer`'s slot holding `signature`. */
+export declare function withSignature(wire: any, signer: any, signature: any): Uint8Array<any>;
+/** The transaction's id: its first signature, in base58. */
+export declare const transactionId: (wire: any) => string;
+/** Whether a signature slot is still empty. */
+export declare const isEmptySignature: (signature: any) => any;
+/** Whether two wire transactions carry the same message. */
+export declare const sameMessage: (a: any, b: any) => boolean;
+/** The size this message's transaction takes on the wire. */
+export declare const transactionSize: (message: any) => number;
+/** Whether these instructions fit one transaction from this payer. */
+export declare function fits(input: any): boolean;