@loyal-labs/loyal-smart-accounts-core 0.1.1

package/dist/src/types.js

@@ -0,0 +1,129 @@
+import * as beet from "@metaplex-foundation/beet";
+import * as beetSolana from "@metaplex-foundation/beet-solana";
+import invariant from "invariant";
+export { isProposalStatusActive, isProposalStatusApproved, isProposalStatusRejected, isProposalStatusCancelled, isProposalStatusExecuted, isSettingsActionAddSigner, isSettingsActionRemoveSigner, isSettingsActionChangeThreshold, isSettingsActionAddSpendingLimit, isSettingsActionRemoveSpendingLimit, isSettingsActionSetTimeLock, } from "./generated";
+export const Permission = {
+    Initiate: 0b0000_0001,
+    Vote: 0b0000_0010,
+    Execute: 0b0000_0100,
+};
+export class Permissions {
+    mask;
+    constructor(mask) {
+        this.mask = mask;
+    }
+    static fromPermissions(permissions) {
+        return new Permissions(permissions.reduce((mask, permission) => mask | permission, 0));
+    }
+    static all() {
+        return new Permissions(Object.values(Permission).reduce((mask, permission) => mask | permission, 0));
+    }
+    static has(permissions, permission) {
+        return (permissions.mask & permission) === permission;
+    }
+}
+/**
+ * De/Serializes a small array with configurable length prefix and a specific number of elements of type {@link T}
+ * which do not all have the same size.
+ *
+ * @template T type of elements held in the array
+ *
+ * @param lengthBeet the De/Serializer for the array length prefix
+ * @param elements the De/Serializers for the element types
+ * @param elementsByteSize size of all elements in the array combined
+ *
+ * The implementation is minor modification of `fixedSizeArray` where the length is encoded as `lengthBeet.byteSize` bytes:
+ * https://github.dev/metaplex-foundation/beet/blob/e053b7b5b0c46ce7f6906ecd38be9fd85d6e5254/beet/src/beets/collections.ts#L84
+ */
+export function fixedSizeSmallArray(lengthBeet, elements, elementsByteSize) {
+    const len = elements.length;
+    const firstElement = len === 0 ? "<EMPTY>" : elements[0].description;
+    return {
+        write: function (buf, offset, value) {
+            invariant(value.length === len, `array length ${value.length} should match len ${len}`);
+            lengthBeet.write(buf, offset, len);
+            let cursor = offset + lengthBeet.byteSize;
+            for (let i = 0; i < len; i++) {
+                const element = elements[i];
+                element.write(buf, cursor, value[i]);
+                cursor += element.byteSize;
+            }
+        },
+        read: function (buf, offset) {
+            const size = lengthBeet.read(buf, offset);
+            invariant(size === len, "invalid byte size");
+            let cursor = offset + lengthBeet.byteSize;
+            const arr = new Array(len);
+            for (let i = 0; i < len; i++) {
+                const element = elements[i];
+                arr[i] = element.read(buf, cursor);
+                cursor += element.byteSize;
+            }
+            return arr;
+        },
+        byteSize: lengthBeet.byteSize + elementsByteSize,
+        length: len,
+        description: `Array<${firstElement}>(${len})[ ${lengthBeet.byteSize} + ${elementsByteSize} ]`,
+    };
+}
+/**
+ * Wraps a small array De/Serializer with configurable length prefix and elements of type {@link T}
+ * which do not all have the same size.
+ *
+ * @template T type of elements held in the array
+ *
+ * @param lengthBeet the De/Serializer for the array length prefix
+ * @param element the De/Serializer for the element types
+ *
+ * The implementation is minor modification of `array` where the length is encoded as `lengthBeet.byteSize` bytes:
+ * https://github.dev/metaplex-foundation/beet/blob/e053b7b5b0c46ce7f6906ecd38be9fd85d6e5254/beet/src/beets/collections.ts#L137
+ */
+export function smallArray(lengthBeet, element) {
+    return {
+        toFixedFromData(buf, offset) {
+            const len = lengthBeet.read(buf, offset);
+            const cursorStart = offset + lengthBeet.byteSize;
+            let cursor = cursorStart;
+            const fixedElements = new Array(len);
+            for (let i = 0; i < len; i++) {
+                const fixedElement = beet.fixBeetFromData(element, buf, cursor);
+                fixedElements[i] = fixedElement;
+                cursor += fixedElement.byteSize;
+            }
+            return fixedSizeSmallArray(lengthBeet, fixedElements, cursor - cursorStart);
+        },
+        toFixedFromValue(vals) {
+            invariant(Array.isArray(vals), `${vals} should be an array`);
+            let elementsSize = 0;
+            const fixedElements = new Array(vals.length);
+            for (let i = 0; i < vals.length; i++) {
+                const fixedElement = beet.fixBeetFromValue(element, vals[i]);
+                fixedElements[i] = fixedElement;
+                elementsSize += fixedElement.byteSize;
+            }
+            return fixedSizeSmallArray(lengthBeet, fixedElements, elementsSize);
+        },
+        description: `smallArray`,
+    };
+}
+export const compiledMsInstructionBeet = new beet.FixableBeetArgsStruct([
+    ["programIdIndex", beet.u8],
+    ["accountIndexes", smallArray(beet.u8, beet.u8)],
+    ["data", smallArray(beet.u16, beet.u8)],
+], "CompiledMsInstruction");
+export const messageAddressTableLookupBeet = new beet.FixableBeetArgsStruct([
+    ["accountKey", beetSolana.publicKey],
+    ["writableIndexes", smallArray(beet.u8, beet.u8)],
+    ["readonlyIndexes", smallArray(beet.u8, beet.u8)],
+], "MessageAddressTableLookup");
+export const transactionMessageBeet = new beet.FixableBeetArgsStruct([
+    ["numSigners", beet.u8],
+    ["numWritableSigners", beet.u8],
+    ["numWritableNonSigners", beet.u8],
+    ["accountKeys", smallArray(beet.u8, beetSolana.publicKey)],
+    ["instructions", smallArray(beet.u8, compiledMsInstructionBeet)],
+    [
+        "addressTableLookups",
+        smallArray(beet.u8, messageAddressTableLookupBeet),
+    ],
+], "TransactionMessage");

package/dist/src/utils/compileToSynchronousMessage.d.ts

@@ -0,0 +1,9 @@
+import { AccountMeta, PublicKey, TransactionInstruction } from "@solana/web3.js";
+export declare function compileToSynchronousMessageAndAccounts({ vaultPda, members, instructions, }: {
+    vaultPda: PublicKey;
+    members: PublicKey[];
+    instructions: TransactionInstruction[];
+}): {
+    instructions: Uint8Array;
+    accounts: AccountMeta[];
+};

package/dist/src/utils/compileToSynchronousMessage.js

@@ -0,0 +1,87 @@
+import { CompiledKeys } from "./compiled-keys";
+export function compileToSynchronousMessageAndAccounts({ vaultPda, members, instructions, }) {
+    // Compile instructions to get account mapping
+    const compiledKeys = CompiledKeys.compileWithoutPayer(instructions);
+    // Get message components
+    const [header, staticAccountKeys] = compiledKeys.getMessageComponents();
+    // Mark the vault as non-signer if it exists
+    // Create remaining accounts array starting with vault
+    const remainingAccounts = [];
+    // Add the members as signers
+    members.forEach((member) => {
+        remainingAccounts.unshift({
+            pubkey: member,
+            isSigner: true,
+            isWritable: false,
+        });
+    });
+    // Add all other accounts
+    staticAccountKeys.forEach((key, index) => {
+        remainingAccounts.push({
+            pubkey: key,
+            isSigner: index < header.numRequiredSignatures,
+            isWritable: index <
+                header.numRequiredSignatures - header.numReadonlySignedAccounts ||
+                (index >= header.numRequiredSignatures &&
+                    index <
+                        staticAccountKeys.length - header.numReadonlyUnsignedAccounts),
+        });
+    });
+    // Mark the vault as non-signer if it exists
+    if (remainingAccounts.find((acc) => acc.pubkey.equals(vaultPda))) {
+        remainingAccounts.find((acc) => acc.pubkey.equals(vaultPda)).isSigner =
+            false;
+    }
+    // Compile instructions with updated indices
+    let args_buffer = Buffer.alloc(0);
+    // Insert instruction length as u8 as first byte
+    args_buffer = Buffer.concat([Buffer.from([instructions.length])]);
+    // Serialize each instruction
+    instructions.forEach((ix) => {
+        const accounts = ix.keys.map((key) => {
+            const index = remainingAccounts.findIndex((acc) => acc.pubkey.equals(key.pubkey));
+            if (index === -1) {
+                throw new Error(`Account ${key.pubkey.toBase58()} not found in remaining accounts`);
+            }
+            return index;
+        });
+        const programIdIndex = remainingAccounts.findIndex((id) => id.pubkey.equals(ix.programId));
+        if (programIdIndex === -1) {
+            throw new Error(`ProgramId ${ix.programId.toBase58()} not found in remaining accounts`);
+        }
+        const serialized_ix = serializeCompiledInstruction({
+            programIdIndex,
+            accountIndexes: accounts,
+            data: ix.data,
+        });
+        // Concatenate the serialized instruction to the buffer
+        args_buffer = Buffer.concat([args_buffer, serialized_ix]);
+    });
+    return {
+        instructions: args_buffer,
+        accounts: remainingAccounts,
+    };
+}
+function serializeCompiledInstruction(ix) {
+    // Create a buffer to hold the serialized instruction
+    let buffer = Buffer.alloc(0);
+    // Add program id index (u8)
+    buffer = Buffer.concat([buffer, Buffer.from([ix.programIdIndex])]);
+    // SmallVec<u8, u8> for account indexes
+    buffer = Buffer.concat([
+        buffer,
+        // Length prefix as u8
+        Buffer.from([ix.accountIndexes.length]),
+        // The account indexes
+        Buffer.from(ix.accountIndexes),
+    ]);
+    // SmallVec<u16, u8> for data
+    buffer = Buffer.concat([
+        buffer,
+        // Length prefix as u16 (little endian)
+        Buffer.from(new Uint16Array([ix.data.length]).buffer),
+        // The actual data bytes
+        ix.data,
+    ]);
+    return Uint8Array.from(buffer);
+}

package/dist/src/utils/compileToSynchronousMessageV2.d.ts

@@ -0,0 +1,19 @@
+import { AccountMeta, PublicKey, TransactionInstruction } from "@solana/web3.js";
+export declare function compileToSynchronousMessageAndAccountsV2({ vaultPda, members, instructions, }: {
+    vaultPda: PublicKey;
+    members: PublicKey[];
+    instructions: TransactionInstruction[];
+}): {
+    instructions: Uint8Array;
+    accounts: AccountMeta[];
+};
+export declare function compileToSynchronousMessageAndAccountsV2WithHooks({ vaultPda, members, preHookAccounts, postHookAccounts, instructions, }: {
+    vaultPda: PublicKey;
+    members: PublicKey[];
+    preHookAccounts: AccountMeta[];
+    postHookAccounts: AccountMeta[];
+    instructions: TransactionInstruction[];
+}): {
+    instructions: Uint8Array;
+    accounts: AccountMeta[];
+};

package/dist/src/utils/compileToSynchronousMessageV2.js

@@ -0,0 +1,154 @@
+import { CompiledKeys } from "./compiled-keys";
+export function compileToSynchronousMessageAndAccountsV2({ vaultPda, members, instructions, }) {
+    // Compile instructions to get account mapping
+    const compiledKeys = CompiledKeys.compileWithoutPayer(instructions);
+    // Get message components
+    const [header, staticAccountKeys] = compiledKeys.getMessageComponents();
+    // Mark the vault as non-signer if it exists
+    // Create remaining accounts array starting with vault
+    const remainingAccounts = [];
+    // Add all other accounts
+    staticAccountKeys.forEach((key, index) => {
+        remainingAccounts.push({
+            pubkey: key,
+            isSigner: index < header.numRequiredSignatures,
+            isWritable: index <
+                header.numRequiredSignatures - header.numReadonlySignedAccounts ||
+                (index >= header.numRequiredSignatures &&
+                    index <
+                        staticAccountKeys.length - header.numReadonlyUnsignedAccounts),
+        });
+    });
+    // Mark the vault as non-signer if it exists
+    if (remainingAccounts.find((acc) => acc.pubkey.equals(vaultPda))) {
+        remainingAccounts.find((acc) => acc.pubkey.equals(vaultPda)).isSigner =
+            false;
+    }
+    // Compile instructions with updated indices
+    let args_buffer = Buffer.alloc(0);
+    // Insert instruction length as u8 as first byte
+    args_buffer = Buffer.concat([Buffer.from([instructions.length])]);
+    // Serialize each instruction
+    instructions.forEach((ix) => {
+        const accounts = ix.keys.map((key) => {
+            const index = remainingAccounts.findIndex((acc) => acc.pubkey.equals(key.pubkey));
+            if (index === -1) {
+                throw new Error(`Account ${key.pubkey.toBase58()} not found in remaining accounts`);
+            }
+            return index;
+        });
+        const programIdIndex = remainingAccounts.findIndex((id) => id.pubkey.equals(ix.programId));
+        if (programIdIndex === -1) {
+            throw new Error(`ProgramId ${ix.programId.toBase58()} not found in remaining accounts`);
+        }
+        const serialized_ix = serializeCompiledInstruction({
+            programIdIndex,
+            accountIndexes: accounts,
+            data: ix.data,
+        });
+        // Concatenate the serialized instruction to the buffer
+        args_buffer = Buffer.concat([args_buffer, serialized_ix]);
+        // Add the members as signers
+        members.forEach((member) => {
+            remainingAccounts.unshift({
+                pubkey: member,
+                isSigner: true,
+                isWritable: false,
+            });
+        });
+    });
+    return {
+        instructions: args_buffer,
+        accounts: remainingAccounts,
+    };
+}
+export function compileToSynchronousMessageAndAccountsV2WithHooks({ vaultPda, members, preHookAccounts, postHookAccounts, instructions, }) {
+    // Compile instructions to get account mapping
+    const compiledKeys = CompiledKeys.compileWithoutPayer(instructions);
+    // Get message components
+    const [header, staticAccountKeys] = compiledKeys.getMessageComponents();
+    // Mark the vault as non-signer if it exists
+    // Create remaining accounts array starting with vault
+    const remainingAccounts = [];
+    // Add all other accounts
+    staticAccountKeys.forEach((key, index) => {
+        remainingAccounts.push({
+            pubkey: key,
+            isSigner: index < header.numRequiredSignatures,
+            isWritable: index <
+                header.numRequiredSignatures - header.numReadonlySignedAccounts ||
+                (index >= header.numRequiredSignatures &&
+                    index <
+                        staticAccountKeys.length - header.numReadonlyUnsignedAccounts),
+        });
+    });
+    // Mark the vault as non-signer if it exists
+    if (remainingAccounts.find((acc) => acc.pubkey.equals(vaultPda))) {
+        remainingAccounts.find((acc) => acc.pubkey.equals(vaultPda)).isSigner =
+            false;
+    }
+    // Compile instructions with updated indices
+    let args_buffer = Buffer.alloc(0);
+    // Insert instruction length as u8 as first byte
+    args_buffer = Buffer.concat([Buffer.from([instructions.length])]);
+    // Serialize each instruction
+    instructions.forEach((ix) => {
+        const accounts = ix.keys.map((key) => {
+            const index = remainingAccounts.findIndex((acc) => acc.pubkey.equals(key.pubkey));
+            if (index === -1) {
+                throw new Error(`Account ${key.pubkey.toBase58()} not found in remaining accounts`);
+            }
+            return index;
+        });
+        const programIdIndex = remainingAccounts.findIndex((id) => id.pubkey.equals(ix.programId));
+        if (programIdIndex === -1) {
+            throw new Error(`ProgramId ${ix.programId.toBase58()} not found in remaining accounts`);
+        }
+        const serialized_ix = serializeCompiledInstruction({
+            programIdIndex,
+            accountIndexes: accounts,
+            data: ix.data,
+        });
+        // Concatenate the serialized instruction to the buffer
+        args_buffer = Buffer.concat([args_buffer, serialized_ix]);
+        // Add the members as signers
+        members.forEach((member) => {
+            remainingAccounts.unshift({
+                pubkey: member,
+                isSigner: true,
+                isWritable: false,
+            });
+        });
+        // Add the pre hook accounts after the members
+        remainingAccounts.splice(members.length, 0, ...preHookAccounts);
+        // Add the post hook accounts after the pre hook accounts
+        remainingAccounts.splice(members.length + preHookAccounts.length, 0, ...postHookAccounts);
+    });
+    return {
+        instructions: args_buffer,
+        accounts: remainingAccounts,
+    };
+}
+function serializeCompiledInstruction(ix) {
+    // Create a buffer to hold the serialized instruction
+    let buffer = Buffer.alloc(0);
+    // Add program id index (u8)
+    buffer = Buffer.concat([buffer, Buffer.from([ix.programIdIndex])]);
+    // SmallVec<u8, u8> for account indexes
+    buffer = Buffer.concat([
+        buffer,
+        // Length prefix as u8
+        Buffer.from([ix.accountIndexes.length]),
+        // The account indexes
+        Buffer.from(ix.accountIndexes),
+    ]);
+    // SmallVec<u16, u8> for data
+    buffer = Buffer.concat([
+        buffer,
+        // Length prefix as u16 (little endian)
+        Buffer.from(new Uint16Array([ix.data.length]).buffer),
+        // The actual data bytes
+        ix.data,
+    ]);
+    return Uint8Array.from(buffer);
+}

package/dist/src/utils/compileToWrappedMessageV0.d.ts

@@ -0,0 +1,7 @@
+import { AddressLookupTableAccount, MessageV0, PublicKey, TransactionInstruction } from "@solana/web3.js";
+export declare function compileToWrappedMessageV0({ payerKey, recentBlockhash, instructions, addressLookupTableAccounts, }: {
+    payerKey: PublicKey;
+    recentBlockhash: string;
+    instructions: TransactionInstruction[];
+    addressLookupTableAccounts?: AddressLookupTableAccount[];
+}): MessageV0;

package/dist/src/utils/compileToWrappedMessageV0.js

@@ -0,0 +1,30 @@
+import { MessageAccountKeys, MessageV0, } from "@solana/web3.js";
+import { CompiledKeys } from "./compiled-keys";
+export function compileToWrappedMessageV0({ payerKey, recentBlockhash, instructions, addressLookupTableAccounts, }) {
+    const compiledKeys = CompiledKeys.compile(instructions, payerKey);
+    const addressTableLookups = new Array();
+    const accountKeysFromLookups = {
+        writable: [],
+        readonly: [],
+    };
+    const lookupTableAccounts = addressLookupTableAccounts || [];
+    for (const lookupTable of lookupTableAccounts) {
+        const extractResult = compiledKeys.extractTableLookup(lookupTable);
+        if (extractResult !== undefined) {
+            const [addressTableLookup, { writable, readonly }] = extractResult;
+            addressTableLookups.push(addressTableLookup);
+            accountKeysFromLookups.writable.push(...writable);
+            accountKeysFromLookups.readonly.push(...readonly);
+        }
+    }
+    const [header, staticAccountKeys] = compiledKeys.getMessageComponents();
+    const accountKeys = new MessageAccountKeys(staticAccountKeys, accountKeysFromLookups);
+    const compiledInstructions = accountKeys.compileInstructions(instructions);
+    return new MessageV0({
+        header,
+        staticAccountKeys,
+        recentBlockhash,
+        compiledInstructions,
+        addressTableLookups,
+    });
+}

package/dist/src/utils/compiled-keys.d.ts

@@ -0,0 +1,31 @@
+import { AccountKeysFromLookups, AddressLookupTableAccount, MessageAddressTableLookup, MessageHeader, PublicKey, TransactionInstruction } from "@solana/web3.js";
+export type CompiledKeyMeta = {
+    isSigner: boolean;
+    isWritable: boolean;
+    isInvoked: boolean;
+};
+type KeyMetaMap = Map<string, CompiledKeyMeta>;
+/**
+ *  This is almost completely copy-pasted from solana-web3.js and slightly adapted to work with "wrapped" transaction messaged such as in VaultTransaction.
+ *  @see https://github.com/solana-labs/solana-web3.js/blob/87d33ac68e2453b8a01cf8c425aa7623888434e8/packages/library-legacy/src/message/compiled-keys.ts
+ */
+export declare class CompiledKeys {
+    payer?: PublicKey;
+    keyMetaMap: KeyMetaMap;
+    constructor(payer: PublicKey | undefined, keyMetaMap: KeyMetaMap);
+    /**
+     * The only difference between this and the original is that we don't mark the instruction programIds as invoked.
+     * It makes sense to do because the instructions will be called via CPI, so the programIds can come from Address Lookup Tables.
+     * This allows to compress the message size and avoid hitting the tx size limit during vault_transaction_create instruction calls.
+     */
+    static compile(instructions: Array<TransactionInstruction>, payer: PublicKey): CompiledKeys;
+    /**
+     * Compiles instructions without a payer.
+     */
+    static compileWithoutPayer(instructions: Array<TransactionInstruction>): CompiledKeys;
+    getMessageComponents(): [MessageHeader, Array<PublicKey>];
+    extractTableLookup(lookupTable: AddressLookupTableAccount): [MessageAddressTableLookup, AccountKeysFromLookups] | undefined;
+    /** @internal */
+    private drainKeysFoundInLookupTable;
+}
+export {};

package/dist/src/utils/compiled-keys.js

@@ -0,0 +1,144 @@
+import { PublicKey, } from "@solana/web3.js";
+import assert from "assert";
+/**
+ *  This is almost completely copy-pasted from solana-web3.js and slightly adapted to work with "wrapped" transaction messaged such as in VaultTransaction.
+ *  @see https://github.com/solana-labs/solana-web3.js/blob/87d33ac68e2453b8a01cf8c425aa7623888434e8/packages/library-legacy/src/message/compiled-keys.ts
+ */
+export class CompiledKeys {
+    payer;
+    keyMetaMap;
+    constructor(payer, keyMetaMap) {
+        this.payer = payer;
+        this.keyMetaMap = keyMetaMap;
+    }
+    /**
+     * The only difference between this and the original is that we don't mark the instruction programIds as invoked.
+     * It makes sense to do because the instructions will be called via CPI, so the programIds can come from Address Lookup Tables.
+     * This allows to compress the message size and avoid hitting the tx size limit during vault_transaction_create instruction calls.
+     */
+    static compile(instructions, payer) {
+        const keyMetaMap = new Map();
+        const getOrInsertDefault = (pubkey) => {
+            const address = pubkey.toBase58();
+            let keyMeta = keyMetaMap.get(address);
+            if (keyMeta === undefined) {
+                keyMeta = {
+                    isSigner: false,
+                    isWritable: false,
+                    isInvoked: false,
+                };
+                keyMetaMap.set(address, keyMeta);
+            }
+            return keyMeta;
+        };
+        const payerKeyMeta = getOrInsertDefault(payer);
+        payerKeyMeta.isSigner = true;
+        payerKeyMeta.isWritable = true;
+        for (const ix of instructions) {
+            // This is the only difference from the original.
+            // getOrInsertDefault(ix.programId).isInvoked = true;
+            getOrInsertDefault(ix.programId).isInvoked = false;
+            for (const accountMeta of ix.keys) {
+                const keyMeta = getOrInsertDefault(accountMeta.pubkey);
+                keyMeta.isSigner ||= accountMeta.isSigner;
+                keyMeta.isWritable ||= accountMeta.isWritable;
+            }
+        }
+        return new CompiledKeys(payer, keyMetaMap);
+    }
+    /**
+     * Compiles instructions without a payer.
+     */
+    static compileWithoutPayer(instructions) {
+        const keyMetaMap = new Map();
+        const getOrInsertDefault = (pubkey) => {
+            const address = pubkey.toBase58();
+            let keyMeta = keyMetaMap.get(address);
+            if (keyMeta === undefined) {
+                keyMeta = {
+                    isSigner: false,
+                    isWritable: false,
+                    isInvoked: false,
+                };
+                keyMetaMap.set(address, keyMeta);
+            }
+            return keyMeta;
+        };
+        for (const ix of instructions) {
+            // This is the only difference from the original.
+            // getOrInsertDefault(ix.programId).isInvoked = true;
+            getOrInsertDefault(ix.programId).isInvoked = false;
+            for (const accountMeta of ix.keys) {
+                const keyMeta = getOrInsertDefault(accountMeta.pubkey);
+                keyMeta.isSigner ||= accountMeta.isSigner;
+                keyMeta.isWritable ||= accountMeta.isWritable;
+            }
+        }
+        return new CompiledKeys(undefined, keyMetaMap);
+    }
+    getMessageComponents() {
+        const mapEntries = [...this.keyMetaMap.entries()];
+        assert(mapEntries.length <= 256, "Max static account keys length exceeded");
+        const writableSigners = mapEntries.filter(([, meta]) => meta.isSigner && meta.isWritable);
+        const readonlySigners = mapEntries.filter(([, meta]) => meta.isSigner && !meta.isWritable);
+        const writableNonSigners = mapEntries.filter(([, meta]) => !meta.isSigner && meta.isWritable);
+        const readonlyNonSigners = mapEntries.filter(([, meta]) => !meta.isSigner && !meta.isWritable);
+        const header = {
+            numRequiredSignatures: writableSigners.length + readonlySigners.length,
+            numReadonlySignedAccounts: readonlySigners.length,
+            numReadonlyUnsignedAccounts: readonlyNonSigners.length,
+        };
+        // sanity checks
+        {
+            assert(writableSigners.length > 0, "Expected at least one writable signer key");
+            const [payerAddress] = writableSigners[0];
+            if (this.payer) {
+                assert(payerAddress === this.payer.toBase58(), "Expected first writable signer key to be the fee payer");
+            }
+        }
+        const staticAccountKeys = [
+            ...writableSigners.map(([address]) => new PublicKey(address)),
+            ...readonlySigners.map(([address]) => new PublicKey(address)),
+            ...writableNonSigners.map(([address]) => new PublicKey(address)),
+            ...readonlyNonSigners.map(([address]) => new PublicKey(address)),
+        ];
+        return [header, staticAccountKeys];
+    }
+    extractTableLookup(lookupTable) {
+        const [writableIndexes, drainedWritableKeys] = this.drainKeysFoundInLookupTable(lookupTable.state.addresses, (keyMeta) => !keyMeta.isSigner && !keyMeta.isInvoked && keyMeta.isWritable);
+        const [readonlyIndexes, drainedReadonlyKeys] = this.drainKeysFoundInLookupTable(lookupTable.state.addresses, (keyMeta) => !keyMeta.isSigner && !keyMeta.isInvoked && !keyMeta.isWritable);
+        // Don't extract lookup if no keys were found
+        if (writableIndexes.length === 0 && readonlyIndexes.length === 0) {
+            return;
+        }
+        return [
+            {
+                accountKey: lookupTable.key,
+                writableIndexes,
+                readonlyIndexes,
+            },
+            {
+                writable: drainedWritableKeys,
+                readonly: drainedReadonlyKeys,
+            },
+        ];
+    }
+    /** @internal */
+    drainKeysFoundInLookupTable(lookupTableEntries, keyMetaFilter) {
+        const lookupTableIndexes = new Array();
+        const drainedKeys = new Array();
+        for (const [address, keyMeta] of this.keyMetaMap.entries()) {
+            if (keyMetaFilter(keyMeta)) {
+                const key = new PublicKey(address);
+                const lookupTableIndex = lookupTableEntries.findIndex((entry) => entry.equals(key));
+                if (lookupTableIndex >= 0) {
+                    assert(lookupTableIndex < 256, "Max lookup table index exceeded");
+                    lookupTableIndexes.push(lookupTableIndex);
+                    drainedKeys.push(key);
+                    this.keyMetaMap.delete(address);
+                }
+            }
+        }
+        return [lookupTableIndexes, drainedKeys];
+    }
+}