fortis-multisig-client 0.1.0 → 0.1.1

package/dist/instructions/proposalCreate.js

@@ -0,0 +1,27 @@
+import { SystemProgram } from "@solana/web3.js";
+import { getProposalCreateInstruction } from "../generated";
+import * as pda from "../pda";
+import * as utils from "../utils";
+import { fromLegacyPublicKey } from "@solana/compat";
+export async function proposalCreate({ creator, multisigPda, ephemeralSigners, votingDeadline, transactionMessage, addressLookupTableAccounts, transactionIndex, }) {
+    const transactionMessageBytes = await utils.transactionMessageToMultisigTransactionMessageBytes({
+        message: transactionMessage,
+        addressLookupTableAccounts,
+    });
+    const args = {
+        ephemeralSigners,
+        votingDeadline,
+        transactionMessage: transactionMessageBytes,
+    };
+    let txPda = await pda.getTransactionPda({ multisigPda: multisigPda, index: transactionIndex });
+    let proposalPda = await pda.getProposalPda({ multisigPda: multisigPda, transactionIndex: transactionIndex });
+    let ix = getProposalCreateInstruction({
+        multisig: fromLegacyPublicKey(multisigPda),
+        transaction: fromLegacyPublicKey(txPda[0]),
+        creator: fromLegacyPublicKey(creator),
+        proposal: fromLegacyPublicKey(proposalPda[0]),
+        systemProgram: fromLegacyPublicKey(SystemProgram.programId),
+        args,
+    });
+    return utils.toLegacyTransactionInstruction(ix, [2]);
+}

package/dist/instructions/proposalExecute.d.ts

@@ -0,0 +1,10 @@
+import { PublicKey, TransactionInstruction, Connection, AddressLookupTableAccount } from "@solana/web3.js";
+export declare function proposalExecute({ connection, member, multisigPda, transactionIndex, }: {
+    connection: Connection;
+    member: PublicKey;
+    multisigPda: PublicKey;
+    transactionIndex: bigint;
+}): Promise<{
+    instruction: TransactionInstruction;
+    lookupTableAccounts: AddressLookupTableAccount[];
+}>;

package/dist/instructions/proposalExecute.js

@@ -0,0 +1,39 @@
+import { PublicKey } from "@solana/web3.js";
+import { getProposalExecuteInstruction, getVaultTransactionCodec } from "../generated";
+import * as pda from "../pda";
+import * as utils from "../utils";
+import { address, AccountRole } from "@solana/kit";
+import { fromLegacyPublicKey } from "@solana/compat";
+export async function proposalExecute({ connection, member, multisigPda, transactionIndex, }) {
+    let transactionPda = await pda.getTransactionPda({ multisigPda: multisigPda, index: transactionIndex });
+    let proposalPda = await pda.getProposalPda({ multisigPda: multisigPda, transactionIndex: transactionIndex });
+    let vaultPda = await pda.getVaultPda({ multisigPda: multisigPda });
+    const txAccount = await connection.getAccountInfo(new PublicKey(transactionPda[0]));
+    if (!txAccount) {
+        throw new Error('Transaction account not found');
+    }
+    const transactionAccount = getVaultTransactionCodec().decode(txAccount.data);
+    const { accountMetas, lookupTableAccounts } = await utils.accountsForTransactionExecute({
+        connection,
+        message: transactionAccount.message,
+        ephemeralSignerBumps: [...transactionAccount.ephemeralSignerBumps],
+        vaultPda: vaultPda[0],
+        transactionPda: transactionPda[0]
+    });
+    let ix = getProposalExecuteInstruction({
+        multisig: fromLegacyPublicKey(multisigPda),
+        proposal: fromLegacyPublicKey(proposalPda[0]),
+        transaction: fromLegacyPublicKey(transactionPda[0]),
+        member: fromLegacyPublicKey(member),
+    });
+    // Convert only additional accounts to Kinobi type
+    const additionalAccounts = accountMetas.map(am => {
+        return {
+            address: address(am.pubkey.toBase58()),
+            role: am.isWritable ? AccountRole.WRITABLE : AccountRole.READONLY,
+        };
+    });
+    // Append them
+    ix.accounts.push(...additionalAccounts);
+    return { instruction: utils.toLegacyTransactionInstruction(ix, [3]), lookupTableAccounts };
+}

package/dist/pda.d.ts

@@ -0,0 +1,27 @@
+import { PublicKey } from "@solana/web3.js";
+import { Address } from "@solana/kit";
+export declare const FORTIS_TREASURY: Address<"5wBH8hqU4PxVCFXmu3JR6Kegdy2Vq8K7fZnRgN5ZJEr2">;
+export declare function getMultisigPda({ createKey, programId, }: {
+    createKey: PublicKey;
+    programId?: PublicKey;
+}): [PublicKey, number];
+export declare function getVaultPda({ multisigPda, programId, }: {
+    multisigPda: PublicKey;
+    programId?: PublicKey;
+}): [PublicKey, number];
+export declare function getEphemeralSignerPda({ transactionPda, ephemeralSignerIndex, programId, }: {
+    transactionPda: PublicKey;
+    ephemeralSignerIndex: number;
+    programId?: PublicKey;
+}): [PublicKey, number];
+export declare function getTransactionPda({ multisigPda, index, programId, }: {
+    multisigPda: PublicKey;
+    /** Transaction index. */
+    index: bigint;
+    programId?: PublicKey;
+}): [PublicKey, number];
+export declare function getProposalPda({ multisigPda, transactionIndex, programId, }: {
+    multisigPda: PublicKey;
+    transactionIndex: bigint;
+    programId?: PublicKey;
+}): [PublicKey, number];

package/dist/pda.js

@@ -0,0 +1,41 @@
+import { FORTIS_MULTISIG_PROGRAM_ADDRESS } from "./generated";
+import { toUtfBytes } from "./utils";
+import { PublicKey } from "@solana/web3.js";
+import { address, getU64Encoder } from "@solana/kit";
+const SEED_PREFIX = toUtfBytes("multisig");
+const SEED_MULTISIG = toUtfBytes("multisig");
+const SEED_VAULT = toUtfBytes("vault");
+const SEED_TRANSACTION = toUtfBytes("transaction");
+const SEED_PROPOSAL = toUtfBytes("proposal");
+const SEED_EPHEMERAL_SIGNER = toUtfBytes("ephemeral_signer");
+const prgramId = FORTIS_MULTISIG_PROGRAM_ADDRESS;
+export const FORTIS_TREASURY = address("5wBH8hqU4PxVCFXmu3JR6Kegdy2Vq8K7fZnRgN5ZJEr2");
+export function getMultisigPda({ createKey, programId = new PublicKey(FORTIS_MULTISIG_PROGRAM_ADDRESS), }) {
+    return PublicKey.findProgramAddressSync([SEED_PREFIX, SEED_MULTISIG, createKey.toBytes()], programId);
+}
+export function getVaultPda({ multisigPda, programId = new PublicKey(FORTIS_MULTISIG_PROGRAM_ADDRESS), }) {
+    return PublicKey.findProgramAddressSync([SEED_PREFIX, multisigPda.toBytes(), SEED_VAULT], programId);
+}
+export function getEphemeralSignerPda({ transactionPda, ephemeralSignerIndex, programId = new PublicKey(FORTIS_MULTISIG_PROGRAM_ADDRESS), }) {
+    const buf = new Uint8Array([ephemeralSignerIndex]); // ✅ works
+    return PublicKey.findProgramAddressSync([
+        SEED_PREFIX,
+        transactionPda.toBytes(),
+        SEED_EPHEMERAL_SIGNER,
+        buf,
+    ], programId);
+}
+export function getTransactionPda({ multisigPda, index, programId = new PublicKey(FORTIS_MULTISIG_PROGRAM_ADDRESS), }) {
+    const buf = Uint8Array.from(getU64Encoder().encode(index));
+    return PublicKey.findProgramAddressSync([SEED_PREFIX, multisigPda.toBytes(), SEED_TRANSACTION, buf], programId);
+}
+export function getProposalPda({ multisigPda, transactionIndex, programId = new PublicKey(FORTIS_MULTISIG_PROGRAM_ADDRESS), }) {
+    const buf = Uint8Array.from(getU64Encoder().encode(transactionIndex));
+    return PublicKey.findProgramAddressSync([
+        SEED_PREFIX,
+        multisigPda.toBytes(),
+        SEED_TRANSACTION,
+        buf,
+        SEED_PROPOSAL,
+    ], programId);
+}

package/dist/utils/compileToWrappedMessageV0.d.ts

@@ -0,0 +1,11 @@
+import { AddressLookupTableAccount, MessageAddressTableLookup, PublicKey, MessageCompiledInstruction, TransactionInstruction } from "@solana/web3.js";
+export declare function compileToWrappedMessageV0({ payerKey, instructions, addressLookupTableAccounts, }: {
+    payerKey: PublicKey;
+    instructions: TransactionInstruction[];
+    addressLookupTableAccounts?: AddressLookupTableAccount[];
+}): {
+    header: import("@solana/web3.js").MessageHeader;
+    staticAccountKeys: PublicKey[];
+    compiledInstructions: MessageCompiledInstruction[];
+    addressTableLookups: MessageAddressTableLookup[];
+};

package/dist/utils/compileToWrappedMessageV0.js

@@ -0,0 +1,29 @@
+import { MessageAccountKeys, } from "@solana/web3.js";
+import { CompiledKeys } from "./compiled-keys";
+export function compileToWrappedMessageV0({ payerKey, 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 {
+        header,
+        staticAccountKeys,
+        compiledInstructions,
+        addressTableLookups,
+    };
+}

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

@@ -0,0 +1,27 @@
+import { MessageHeader, MessageAddressTableLookup, AccountKeysFromLookups, AddressLookupTableAccount, TransactionInstruction, PublicKey } 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, 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;
+    getMessageComponents(): [MessageHeader, Array<PublicKey>];
+    extractTableLookup(lookupTable: AddressLookupTableAccount): [MessageAddressTableLookup, AccountKeysFromLookups] | undefined;
+    /** @internal */
+    private drainKeysFoundInLookupTable;
+}
+export {};

package/dist/utils/compiled-keys.js

@@ -0,0 +1,112 @@
+import assert from "assert";
+import { PublicKey, } from "@solana/web3.js";
+/**
+ *  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);
+    }
+    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];
+            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];
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,28 @@
+import { VaultTransactionMessage } from "./generated";
+import { AccountMeta, AddressLookupTableAccount, Connection, PublicKey, VersionedTransaction, TransactionInstruction, TransactionMessage } from "@solana/web3.js";
+import { ReadonlyUint8Array, Instruction } from "@solana/kit";
+export declare function toUtfBytes(str: string): Uint8Array;
+export declare function getAvailableMemoSize(txWithoutMemo: VersionedTransaction): number;
+export declare function isStaticWritableIndex(message: VaultTransactionMessage, index: number): boolean;
+export declare function isSignerIndex(message: VaultTransactionMessage, index: number): boolean;
+/** We use custom serialization for `transaction_message` that ensures as small byte size as possible. */
+export declare function transactionMessageToMultisigTransactionMessageBytes({ message, addressLookupTableAccounts, }: {
+    message: TransactionMessage;
+    addressLookupTableAccounts: AddressLookupTableAccount[];
+}): Promise<ReadonlyUint8Array>;
+export declare function toLegacyTransactionInstruction(instruction: Instruction, signerAccountIndexes: number[]): TransactionInstruction;
+/** Populate remaining accounts required for execution of the transaction. */
+export declare function accountsForTransactionExecute({ connection, transactionPda, vaultPda, message, ephemeralSignerBumps, programId, addressLookupTableAccounts: localAddressLookupTableAccounts, }: {
+    connection: Connection;
+    message: VaultTransactionMessage;
+    ephemeralSignerBumps: number[];
+    vaultPda: PublicKey;
+    transactionPda: PublicKey;
+    programId?: PublicKey;
+    addressLookupTableAccounts?: AddressLookupTableAccount[];
+}): Promise<{
+    /** Account metas used in the `message`. */
+    accountMetas: AccountMeta[];
+    /** Address lookup table accounts used in the `message`. */
+    lookupTableAccounts: AddressLookupTableAccount[];
+}>;

package/dist/utils.js

@@ -0,0 +1,184 @@
+import { fromLegacyPublicKey } from '@solana/compat';
+import { Buffer } from "buffer";
+import { getVaultTransactionMessageEncoder } from "./generated";
+import { PublicKey, TransactionInstruction, } from "@solana/web3.js";
+import { getEphemeralSignerPda } from "./pda";
+import invariant from "invariant";
+import { compileToWrappedMessageV0 } from "./utils/compileToWrappedMessageV0";
+import { AccountRole } from "@solana/kit";
+export function toUtfBytes(str) {
+    return new TextEncoder().encode(str);
+}
+const MAX_TX_SIZE_BYTES = 1232;
+const STRING_LEN_SIZE = 4;
+export function getAvailableMemoSize(txWithoutMemo) {
+    const txSize = txWithoutMemo.serialize().length;
+    return (MAX_TX_SIZE_BYTES -
+        txSize -
+        STRING_LEN_SIZE -
+        // Sometimes long memo can trigger switching from 1 to 2 bytes length encoding in Compact-u16,
+        // so we reserve 1 extra byte to make sure.
+        1);
+}
+export function isStaticWritableIndex(message, index) {
+    const numAccountKeys = message.accountKeys.length;
+    const { numSigners, numWritableSigners, numWritableNonSigners } = message;
+    if (index >= numAccountKeys) {
+        // `index` is not a part of static `accountKeys`.
+        return false;
+    }
+    if (index < numWritableSigners) {
+        // `index` is within the range of writable signer keys.
+        return true;
+    }
+    if (index >= numSigners) {
+        // `index` is within the range of non-signer keys.
+        const indexIntoNonSigners = index - numSigners;
+        // Whether `index` is within the range of writable non-signer keys.
+        return indexIntoNonSigners < numWritableNonSigners;
+    }
+    return false;
+}
+export function isSignerIndex(message, index) {
+    return index < message.numSigners;
+}
+/** We use custom serialization for `transaction_message` that ensures as small byte size as possible. */
+export async function transactionMessageToMultisigTransactionMessageBytes({ message, addressLookupTableAccounts, }) {
+    const compiledMessage = compileToWrappedMessageV0({
+        payerKey: message.payerKey,
+        instructions: message.instructions,
+        addressLookupTableAccounts,
+    });
+    const encoder = getVaultTransactionMessageEncoder();
+    let compiled_ixs = [];
+    for (const msg_cix of compiledMessage.compiledInstructions) {
+        compiled_ixs.push({
+            programIdIndex: msg_cix.programIdIndex,
+            accountIndexes: new Uint8Array(msg_cix.accountKeyIndexes ?? []),
+            data: msg_cix.data ?? new Uint8Array(),
+        });
+    }
+    let alts = [];
+    for (const alt of compiledMessage.addressTableLookups) {
+        alts.push({
+            accountKey: fromLegacyPublicKey(alt.accountKey),
+            writableIndexes: Uint8Array.from(alt.writableIndexes),
+            readonlyIndexes: Uint8Array.from(alt.readonlyIndexes)
+        });
+    }
+    const bytes = encoder.encode({
+        numSigners: compiledMessage.header.numRequiredSignatures,
+        numWritableSigners: compiledMessage.header.numRequiredSignatures - compiledMessage.header.numReadonlySignedAccounts,
+        numWritableNonSigners: compiledMessage.staticAccountKeys.length - compiledMessage.header.numRequiredSignatures - compiledMessage.header.numReadonlyUnsignedAccounts,
+        accountKeys: compiledMessage.staticAccountKeys.map((pk) => fromLegacyPublicKey(pk)),
+        addressTableLookups: alts,
+        instructions: compiled_ixs,
+    });
+    return bytes;
+}
+export function toLegacyTransactionInstruction(instruction, signerAccountIndexes) {
+    const signerSet = new Set(signerAccountIndexes);
+    const keys = (instruction.accounts ?? []).map((acct, index) => {
+        const pubkey = new PublicKey(acct.address);
+        // base flags from role
+        let { isSigner, isWritable } = roleToFlags(acct.role);
+        // 🔥 FORCE signer if index is listed
+        if (signerSet.has(index)) {
+            isSigner = true;
+        }
+        return { pubkey, isSigner, isWritable };
+    });
+    const data = instruction.data instanceof Uint8Array
+        ? Buffer.from(instruction.data)
+        : Buffer.alloc(0);
+    const programId = new PublicKey(instruction.programAddress);
+    return new TransactionInstruction({
+        keys,
+        programId,
+        data,
+    });
+}
+// Convert AccountRole back to isSigner / isWritable flags
+function roleToFlags(role) {
+    switch (role) {
+        case AccountRole.WRITABLE_SIGNER:
+            return { isSigner: true, isWritable: true };
+        case AccountRole.READONLY_SIGNER:
+            return { isSigner: true, isWritable: false };
+        case AccountRole.WRITABLE:
+            return { isSigner: false, isWritable: true };
+        case AccountRole.READONLY:
+        default:
+            return { isSigner: false, isWritable: false };
+    }
+}
+/** Populate remaining accounts required for execution of the transaction. */
+export async function accountsForTransactionExecute({ connection, transactionPda, vaultPda, message, ephemeralSignerBumps, programId, addressLookupTableAccounts: localAddressLookupTableAccounts, }) {
+    const ephemeralSignerPdas = await Promise.all(ephemeralSignerBumps.map(async (_, additionalSignerIndex) => {
+        const [pda] = await getEphemeralSignerPda({
+            transactionPda: transactionPda,
+            ephemeralSignerIndex: additionalSignerIndex,
+        });
+        return pda;
+    }));
+    const addressLookupTableKeys = message.addressTableLookups.map(({ accountKey }) => accountKey);
+    const addressLookupTableAccounts = new Map(await Promise.all(addressLookupTableKeys.map(async (key) => {
+        const localAccount = localAddressLookupTableAccounts?.find((a) => a.key.toBase58() === key);
+        if (localAccount) {
+            return [key, localAccount];
+        }
+        const { value } = await connection.getAddressLookupTable(new PublicKey(key));
+        if (!value) {
+            throw new Error(`Address lookup table account ${key} not found`);
+        }
+        return [key, value];
+    })));
+    // Populate account metas required for execution of the transaction.
+    const accountMetas = [];
+    // First add the lookup table accounts used by the transaction. They are needed for on-chain validation.
+    accountMetas.push(...addressLookupTableKeys.map((key) => {
+        return { pubkey: new PublicKey(key), isSigner: false, isWritable: false };
+    }));
+    // Then add static account keys included into the message.
+    for (const [accountIndex, accountKey] of message.accountKeys.entries()) {
+        let accountKey_pubKey = new PublicKey(accountKey);
+        accountMetas.push({
+            pubkey: new PublicKey(accountKey),
+            isWritable: isStaticWritableIndex(message, accountIndex),
+            // NOTE: vaultPda and ephemeralSignerPdas cannot be marked as signers,
+            // because they are PDAs and hence won't have their signatures on the transaction.
+            isSigner: isSignerIndex(message, accountIndex) &&
+                !accountKey_pubKey.equals(vaultPda) &&
+                !ephemeralSignerPdas.some((k) => accountKey_pubKey.equals(k)),
+        });
+    }
+    // Then add accounts that will be loaded with address lookup tables.
+    for (const lookup of message.addressTableLookups) {
+        const lookupTableAccount = addressLookupTableAccounts.get(lookup.accountKey);
+        invariant(lookupTableAccount, `Address lookup table account ${lookup.accountKey} not found`);
+        for (const accountIndex of lookup.writableIndexes) {
+            const pubkey = lookupTableAccount.state.addresses[accountIndex];
+            invariant(pubkey, `Address lookup table account ${lookup.accountKey} does not contain address at index ${accountIndex}`);
+            accountMetas.push({
+                pubkey,
+                isWritable: true,
+                // Accounts in address lookup tables can not be signers.
+                isSigner: false,
+            });
+        }
+        for (const accountIndex of lookup.readonlyIndexes) {
+            const pubkey = lookupTableAccount.state.addresses[accountIndex];
+            invariant(pubkey, `Address lookup table account ${lookup.accountKey} does not contain address at index ${accountIndex}`);
+            accountMetas.push({
+                pubkey,
+                isWritable: false,
+                // Accounts in address lookup tables can not be signers.
+                isSigner: false,
+            });
+        }
+    }
+    return {
+        accountMetas,
+        lookupTableAccounts: [...addressLookupTableAccounts.values()],
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fortis-multisig-client",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Fortis Solana multisig generated client",
   "type": "module",
   "main": "dist/index.js",
@@ -29,4 +29,4 @@
     "@types/node": "^20.0.0",
     "typescript": "^5.6.2"
   }
-}
+}