fortis-multisig-client 0.1.0 → 0.1.1

package/dist/generated/instructions/proposalAccountsClose.js

@@ -0,0 +1,76 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { combineCodec, fixDecoderSize, fixEncoderSize, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, transformEncoder, } from '@solana/kit';
+import { FORTIS_MULTISIG_PROGRAM_ADDRESS } from '../programs';
+import { getAccountMetaFactory } from '../shared';
+export const PROPOSAL_ACCOUNTS_CLOSE_DISCRIMINATOR = new Uint8Array([4]);
+export function getProposalAccountsCloseDiscriminatorBytes() {
+    return fixEncoderSize(getBytesEncoder(), 1).encode(PROPOSAL_ACCOUNTS_CLOSE_DISCRIMINATOR);
+}
+export function getProposalAccountsCloseInstructionDataEncoder() {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 1)]]), (value) => ({
+        ...value,
+        discriminator: PROPOSAL_ACCOUNTS_CLOSE_DISCRIMINATOR,
+    }));
+}
+export function getProposalAccountsCloseInstructionDataDecoder() {
+    return getStructDecoder([
+        ['discriminator', fixDecoderSize(getBytesDecoder(), 1)],
+    ]);
+}
+export function getProposalAccountsCloseInstructionDataCodec() {
+    return combineCodec(getProposalAccountsCloseInstructionDataEncoder(), getProposalAccountsCloseInstructionDataDecoder());
+}
+export function getProposalAccountsCloseInstruction(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? FORTIS_MULTISIG_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = {
+        multisig: { value: input.multisig ?? null, isWritable: false },
+        proposal: { value: input.proposal ?? null, isWritable: true },
+        transaction: { value: input.transaction ?? null, isWritable: true },
+        rentCollector: { value: input.rentCollector ?? null, isWritable: true },
+        systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    };
+    const accounts = originalAccounts;
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({
+        accounts: [
+            getAccountMeta(accounts.multisig),
+            getAccountMeta(accounts.proposal),
+            getAccountMeta(accounts.transaction),
+            getAccountMeta(accounts.rentCollector),
+            getAccountMeta(accounts.systemProgram),
+        ],
+        data: getProposalAccountsCloseInstructionDataEncoder().encode({}),
+        programAddress,
+    });
+}
+export function parseProposalAccountsCloseInstruction(instruction) {
+    if (instruction.accounts.length < 5) {
+        // TODO: Coded error.
+        throw new Error('Not enough accounts');
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+        const accountMeta = instruction.accounts[accountIndex];
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return {
+        programAddress: instruction.programAddress,
+        accounts: {
+            multisig: getNextAccount(),
+            proposal: getNextAccount(),
+            transaction: getNextAccount(),
+            rentCollector: getNextAccount(),
+            systemProgram: getNextAccount(),
+        },
+        data: getProposalAccountsCloseInstructionDataDecoder().decode(instruction.data),
+    };
+}

package/dist/generated/instructions/proposalApprove.d.ts

@@ -0,0 +1,47 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { type AccountMeta, type AccountSignerMeta, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlyAccount, type ReadonlyUint8Array, type WritableAccount, type WritableSignerAccount } from '@solana/kit';
+import { FORTIS_MULTISIG_PROGRAM_ADDRESS } from '../programs';
+import { type ProposalApproveArgs, type ProposalApproveArgsArgs } from '../types';
+export declare const PROPOSAL_APPROVE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getProposalApproveDiscriminatorBytes(): ReadonlyUint8Array;
+export type ProposalApproveInstruction<TProgram extends string = typeof FORTIS_MULTISIG_PROGRAM_ADDRESS, TAccountMultisig extends string | AccountMeta<string> = string, TAccountProposal extends string | AccountMeta<string> = string, TAccountMember extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountMultisig extends string ? ReadonlyAccount<TAccountMultisig> : TAccountMultisig,
+    TAccountProposal extends string ? WritableAccount<TAccountProposal> : TAccountProposal,
+    TAccountMember extends string ? WritableSignerAccount<TAccountMember> & AccountSignerMeta<TAccountMember> : TAccountMember,
+    ...TRemainingAccounts
+]>;
+export type ProposalApproveInstructionData = {
+    discriminator: ReadonlyUint8Array;
+    args: ProposalApproveArgs;
+};
+export type ProposalApproveInstructionDataArgs = {
+    args: ProposalApproveArgsArgs;
+};
+export declare function getProposalApproveInstructionDataEncoder(): FixedSizeEncoder<ProposalApproveInstructionDataArgs>;
+export declare function getProposalApproveInstructionDataDecoder(): FixedSizeDecoder<ProposalApproveInstructionData>;
+export declare function getProposalApproveInstructionDataCodec(): FixedSizeCodec<ProposalApproveInstructionDataArgs, ProposalApproveInstructionData>;
+export type ProposalApproveInput<TAccountMultisig extends string = string, TAccountProposal extends string = string, TAccountMember extends string = string> = {
+    multisig: Address<TAccountMultisig>;
+    proposal: Address<TAccountProposal>;
+    member: Address<TAccountMember>;
+    args: ProposalApproveInstructionDataArgs['args'];
+};
+export declare function getProposalApproveInstruction<TAccountMultisig extends string, TAccountProposal extends string, TAccountMember extends string, TProgramAddress extends Address = typeof FORTIS_MULTISIG_PROGRAM_ADDRESS>(input: ProposalApproveInput<TAccountMultisig, TAccountProposal, TAccountMember>, config?: {
+    programAddress?: TProgramAddress;
+}): ProposalApproveInstruction<TProgramAddress, TAccountMultisig, TAccountProposal, TAccountMember>;
+export type ParsedProposalApproveInstruction<TProgram extends string = typeof FORTIS_MULTISIG_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        multisig: TAccountMetas[0];
+        proposal: TAccountMetas[1];
+        member: TAccountMetas[2];
+    };
+    data: ProposalApproveInstructionData;
+};
+export declare function parseProposalApproveInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedProposalApproveInstruction<TProgram, TAccountMetas>;

package/dist/generated/instructions/proposalApprove.js

@@ -0,0 +1,74 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { combineCodec, fixDecoderSize, fixEncoderSize, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, transformEncoder, } from '@solana/kit';
+import { FORTIS_MULTISIG_PROGRAM_ADDRESS } from '../programs';
+import { getAccountMetaFactory } from '../shared';
+import { getProposalApproveArgsDecoder, getProposalApproveArgsEncoder, } from '../types';
+export const PROPOSAL_APPROVE_DISCRIMINATOR = new Uint8Array([2]);
+export function getProposalApproveDiscriminatorBytes() {
+    return fixEncoderSize(getBytesEncoder(), 1).encode(PROPOSAL_APPROVE_DISCRIMINATOR);
+}
+export function getProposalApproveInstructionDataEncoder() {
+    return transformEncoder(getStructEncoder([
+        ['discriminator', fixEncoderSize(getBytesEncoder(), 1)],
+        ['args', getProposalApproveArgsEncoder()],
+    ]), (value) => ({ ...value, discriminator: PROPOSAL_APPROVE_DISCRIMINATOR }));
+}
+export function getProposalApproveInstructionDataDecoder() {
+    return getStructDecoder([
+        ['discriminator', fixDecoderSize(getBytesDecoder(), 1)],
+        ['args', getProposalApproveArgsDecoder()],
+    ]);
+}
+export function getProposalApproveInstructionDataCodec() {
+    return combineCodec(getProposalApproveInstructionDataEncoder(), getProposalApproveInstructionDataDecoder());
+}
+export function getProposalApproveInstruction(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? FORTIS_MULTISIG_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = {
+        multisig: { value: input.multisig ?? null, isWritable: false },
+        proposal: { value: input.proposal ?? null, isWritable: true },
+        member: { value: input.member ?? null, isWritable: true },
+    };
+    const accounts = originalAccounts;
+    // Original args.
+    const args = { ...input };
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({
+        accounts: [
+            getAccountMeta(accounts.multisig),
+            getAccountMeta(accounts.proposal),
+            getAccountMeta(accounts.member),
+        ],
+        data: getProposalApproveInstructionDataEncoder().encode(args),
+        programAddress,
+    });
+}
+export function parseProposalApproveInstruction(instruction) {
+    if (instruction.accounts.length < 3) {
+        // TODO: Coded error.
+        throw new Error('Not enough accounts');
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+        const accountMeta = instruction.accounts[accountIndex];
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return {
+        programAddress: instruction.programAddress,
+        accounts: {
+            multisig: getNextAccount(),
+            proposal: getNextAccount(),
+            member: getNextAccount(),
+        },
+        data: getProposalApproveInstructionDataDecoder().decode(instruction.data),
+    };
+}

package/dist/generated/instructions/proposalCreate.d.ts

@@ -0,0 +1,57 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { type AccountMeta, type AccountSignerMeta, type Address, type Codec, type Decoder, type Encoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlyAccount, type ReadonlySignerAccount, type ReadonlyUint8Array, type WritableAccount } from '@solana/kit';
+import { FORTIS_MULTISIG_PROGRAM_ADDRESS } from '../programs';
+import { type ProposalCreateArgs, type ProposalCreateArgsArgs } from '../types';
+export declare const PROPOSAL_CREATE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getProposalCreateDiscriminatorBytes(): ReadonlyUint8Array;
+export type ProposalCreateInstruction<TProgram extends string = typeof FORTIS_MULTISIG_PROGRAM_ADDRESS, TAccountMultisig extends string | AccountMeta<string> = string, TAccountTransaction extends string | AccountMeta<string> = string, TAccountCreator extends string | AccountMeta<string> = string, TAccountProposal extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountMultisig extends string ? WritableAccount<TAccountMultisig> : TAccountMultisig,
+    TAccountTransaction extends string ? WritableAccount<TAccountTransaction> : TAccountTransaction,
+    TAccountCreator extends string ? ReadonlySignerAccount<TAccountCreator> & AccountSignerMeta<TAccountCreator> : TAccountCreator,
+    TAccountProposal extends string ? WritableAccount<TAccountProposal> : TAccountProposal,
+    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
+    ...TRemainingAccounts
+]>;
+export type ProposalCreateInstructionData = {
+    discriminator: ReadonlyUint8Array;
+    args: ProposalCreateArgs;
+};
+export type ProposalCreateInstructionDataArgs = {
+    args: ProposalCreateArgsArgs;
+};
+export declare function getProposalCreateInstructionDataEncoder(): Encoder<ProposalCreateInstructionDataArgs>;
+export declare function getProposalCreateInstructionDataDecoder(): Decoder<ProposalCreateInstructionData>;
+export declare function getProposalCreateInstructionDataCodec(): Codec<ProposalCreateInstructionDataArgs, ProposalCreateInstructionData>;
+export type ProposalCreateInput<TAccountMultisig extends string = string, TAccountTransaction extends string = string, TAccountCreator extends string = string, TAccountProposal extends string = string, TAccountSystemProgram extends string = string> = {
+    multisig: Address<TAccountMultisig>;
+    transaction: Address<TAccountTransaction>;
+    /** The member of the multisig that is creating the transaction. */
+    creator: Address<TAccountCreator>;
+    /** The proposal account associated with the transaction. */
+    proposal: Address<TAccountProposal>;
+    systemProgram: Address<TAccountSystemProgram>;
+    args: ProposalCreateInstructionDataArgs['args'];
+};
+export declare function getProposalCreateInstruction<TAccountMultisig extends string, TAccountTransaction extends string, TAccountCreator extends string, TAccountProposal extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof FORTIS_MULTISIG_PROGRAM_ADDRESS>(input: ProposalCreateInput<TAccountMultisig, TAccountTransaction, TAccountCreator, TAccountProposal, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): ProposalCreateInstruction<TProgramAddress, TAccountMultisig, TAccountTransaction, TAccountCreator, TAccountProposal, TAccountSystemProgram>;
+export type ParsedProposalCreateInstruction<TProgram extends string = typeof FORTIS_MULTISIG_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        multisig: TAccountMetas[0];
+        transaction: TAccountMetas[1];
+        /** The member of the multisig that is creating the transaction. */
+        creator: TAccountMetas[2];
+        /** The proposal account associated with the transaction. */
+        proposal: TAccountMetas[3];
+        systemProgram: TAccountMetas[4];
+    };
+    data: ProposalCreateInstructionData;
+};
+export declare function parseProposalCreateInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedProposalCreateInstruction<TProgram, TAccountMetas>;

package/dist/generated/instructions/proposalCreate.js

@@ -0,0 +1,80 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { combineCodec, fixDecoderSize, fixEncoderSize, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, transformEncoder, } from '@solana/kit';
+import { FORTIS_MULTISIG_PROGRAM_ADDRESS } from '../programs';
+import { getAccountMetaFactory } from '../shared';
+import { getProposalCreateArgsDecoder, getProposalCreateArgsEncoder, } from '../types';
+export const PROPOSAL_CREATE_DISCRIMINATOR = new Uint8Array([1]);
+export function getProposalCreateDiscriminatorBytes() {
+    return fixEncoderSize(getBytesEncoder(), 1).encode(PROPOSAL_CREATE_DISCRIMINATOR);
+}
+export function getProposalCreateInstructionDataEncoder() {
+    return transformEncoder(getStructEncoder([
+        ['discriminator', fixEncoderSize(getBytesEncoder(), 1)],
+        ['args', getProposalCreateArgsEncoder()],
+    ]), (value) => ({ ...value, discriminator: PROPOSAL_CREATE_DISCRIMINATOR }));
+}
+export function getProposalCreateInstructionDataDecoder() {
+    return getStructDecoder([
+        ['discriminator', fixDecoderSize(getBytesDecoder(), 1)],
+        ['args', getProposalCreateArgsDecoder()],
+    ]);
+}
+export function getProposalCreateInstructionDataCodec() {
+    return combineCodec(getProposalCreateInstructionDataEncoder(), getProposalCreateInstructionDataDecoder());
+}
+export function getProposalCreateInstruction(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? FORTIS_MULTISIG_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = {
+        multisig: { value: input.multisig ?? null, isWritable: true },
+        transaction: { value: input.transaction ?? null, isWritable: true },
+        creator: { value: input.creator ?? null, isWritable: false },
+        proposal: { value: input.proposal ?? null, isWritable: true },
+        systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    };
+    const accounts = originalAccounts;
+    // Original args.
+    const args = { ...input };
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({
+        accounts: [
+            getAccountMeta(accounts.multisig),
+            getAccountMeta(accounts.transaction),
+            getAccountMeta(accounts.creator),
+            getAccountMeta(accounts.proposal),
+            getAccountMeta(accounts.systemProgram),
+        ],
+        data: getProposalCreateInstructionDataEncoder().encode(args),
+        programAddress,
+    });
+}
+export function parseProposalCreateInstruction(instruction) {
+    if (instruction.accounts.length < 5) {
+        // TODO: Coded error.
+        throw new Error('Not enough accounts');
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+        const accountMeta = instruction.accounts[accountIndex];
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return {
+        programAddress: instruction.programAddress,
+        accounts: {
+            multisig: getNextAccount(),
+            transaction: getNextAccount(),
+            creator: getNextAccount(),
+            proposal: getNextAccount(),
+            systemProgram: getNextAccount(),
+        },
+        data: getProposalCreateInstructionDataDecoder().decode(instruction.data),
+    };
+}

package/dist/generated/instructions/proposalExecute.d.ts

@@ -0,0 +1,49 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { type AccountMeta, type AccountSignerMeta, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlyAccount, type ReadonlySignerAccount, type ReadonlyUint8Array, type WritableAccount } from '@solana/kit';
+import { FORTIS_MULTISIG_PROGRAM_ADDRESS } from '../programs';
+export declare const PROPOSAL_EXECUTE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getProposalExecuteDiscriminatorBytes(): ReadonlyUint8Array;
+export type ProposalExecuteInstruction<TProgram extends string = typeof FORTIS_MULTISIG_PROGRAM_ADDRESS, TAccountMultisig extends string | AccountMeta<string> = string, TAccountProposal extends string | AccountMeta<string> = string, TAccountTransaction extends string | AccountMeta<string> = string, TAccountMember extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountMultisig extends string ? ReadonlyAccount<TAccountMultisig> : TAccountMultisig,
+    TAccountProposal extends string ? WritableAccount<TAccountProposal> : TAccountProposal,
+    TAccountTransaction extends string ? ReadonlyAccount<TAccountTransaction> : TAccountTransaction,
+    TAccountMember extends string ? ReadonlySignerAccount<TAccountMember> & AccountSignerMeta<TAccountMember> : TAccountMember,
+    ...TRemainingAccounts
+]>;
+export type ProposalExecuteInstructionData = {
+    discriminator: ReadonlyUint8Array;
+};
+export type ProposalExecuteInstructionDataArgs = {};
+export declare function getProposalExecuteInstructionDataEncoder(): FixedSizeEncoder<ProposalExecuteInstructionDataArgs>;
+export declare function getProposalExecuteInstructionDataDecoder(): FixedSizeDecoder<ProposalExecuteInstructionData>;
+export declare function getProposalExecuteInstructionDataCodec(): FixedSizeCodec<ProposalExecuteInstructionDataArgs, ProposalExecuteInstructionData>;
+export type ProposalExecuteInput<TAccountMultisig extends string = string, TAccountProposal extends string = string, TAccountTransaction extends string = string, TAccountMember extends string = string> = {
+    multisig: Address<TAccountMultisig>;
+    /** The proposal account associated with the transaction. */
+    proposal: Address<TAccountProposal>;
+    /** The transaction to execute. */
+    transaction: Address<TAccountTransaction>;
+    member: Address<TAccountMember>;
+};
+export declare function getProposalExecuteInstruction<TAccountMultisig extends string, TAccountProposal extends string, TAccountTransaction extends string, TAccountMember extends string, TProgramAddress extends Address = typeof FORTIS_MULTISIG_PROGRAM_ADDRESS>(input: ProposalExecuteInput<TAccountMultisig, TAccountProposal, TAccountTransaction, TAccountMember>, config?: {
+    programAddress?: TProgramAddress;
+}): ProposalExecuteInstruction<TProgramAddress, TAccountMultisig, TAccountProposal, TAccountTransaction, TAccountMember>;
+export type ParsedProposalExecuteInstruction<TProgram extends string = typeof FORTIS_MULTISIG_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        multisig: TAccountMetas[0];
+        /** The proposal account associated with the transaction. */
+        proposal: TAccountMetas[1];
+        /** The transaction to execute. */
+        transaction: TAccountMetas[2];
+        member: TAccountMetas[3];
+    };
+    data: ProposalExecuteInstructionData;
+};
+export declare function parseProposalExecuteInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedProposalExecuteInstruction<TProgram, TAccountMetas>;

package/dist/generated/instructions/proposalExecute.js

@@ -0,0 +1,70 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { combineCodec, fixDecoderSize, fixEncoderSize, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, transformEncoder, } from '@solana/kit';
+import { FORTIS_MULTISIG_PROGRAM_ADDRESS } from '../programs';
+import { getAccountMetaFactory } from '../shared';
+export const PROPOSAL_EXECUTE_DISCRIMINATOR = new Uint8Array([3]);
+export function getProposalExecuteDiscriminatorBytes() {
+    return fixEncoderSize(getBytesEncoder(), 1).encode(PROPOSAL_EXECUTE_DISCRIMINATOR);
+}
+export function getProposalExecuteInstructionDataEncoder() {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 1)]]), (value) => ({ ...value, discriminator: PROPOSAL_EXECUTE_DISCRIMINATOR }));
+}
+export function getProposalExecuteInstructionDataDecoder() {
+    return getStructDecoder([
+        ['discriminator', fixDecoderSize(getBytesDecoder(), 1)],
+    ]);
+}
+export function getProposalExecuteInstructionDataCodec() {
+    return combineCodec(getProposalExecuteInstructionDataEncoder(), getProposalExecuteInstructionDataDecoder());
+}
+export function getProposalExecuteInstruction(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? FORTIS_MULTISIG_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = {
+        multisig: { value: input.multisig ?? null, isWritable: false },
+        proposal: { value: input.proposal ?? null, isWritable: true },
+        transaction: { value: input.transaction ?? null, isWritable: false },
+        member: { value: input.member ?? null, isWritable: false },
+    };
+    const accounts = originalAccounts;
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({
+        accounts: [
+            getAccountMeta(accounts.multisig),
+            getAccountMeta(accounts.proposal),
+            getAccountMeta(accounts.transaction),
+            getAccountMeta(accounts.member),
+        ],
+        data: getProposalExecuteInstructionDataEncoder().encode({}),
+        programAddress,
+    });
+}
+export function parseProposalExecuteInstruction(instruction) {
+    if (instruction.accounts.length < 4) {
+        // TODO: Coded error.
+        throw new Error('Not enough accounts');
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+        const accountMeta = instruction.accounts[accountIndex];
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return {
+        programAddress: instruction.programAddress,
+        accounts: {
+            multisig: getNextAccount(),
+            proposal: getNextAccount(),
+            transaction: getNextAccount(),
+            member: getNextAccount(),
+        },
+        data: getProposalExecuteInstructionDataDecoder().decode(instruction.data),
+    };
+}

package/dist/generated/programs/fortisMultisig.d.ts

@@ -0,0 +1,36 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { type Address, type ReadonlyUint8Array } from '@solana/kit';
+import { type ParsedMultisigCreateInstruction, type ParsedProposalAccountsCloseInstruction, type ParsedProposalApproveInstruction, type ParsedProposalCreateInstruction, type ParsedProposalExecuteInstruction } from '../instructions';
+export declare const FORTIS_MULTISIG_PROGRAM_ADDRESS: Address<"2Zwsw5UBArhtKwGV3mQpGMaaH4q8hVDwEyzVjMqTyvgi">;
+export declare enum FortisMultisigAccount {
+    Multisig = 0,
+    Proposal = 1,
+    VaultTransaction = 2
+}
+export declare enum FortisMultisigInstruction {
+    MultisigCreate = 0,
+    ProposalCreate = 1,
+    ProposalExecute = 2,
+    ProposalApprove = 3,
+    ProposalAccountsClose = 4
+}
+export declare function identifyFortisMultisigInstruction(instruction: {
+    data: ReadonlyUint8Array;
+} | ReadonlyUint8Array): FortisMultisigInstruction;
+export type ParsedFortisMultisigInstruction<TProgram extends string = '2Zwsw5UBArhtKwGV3mQpGMaaH4q8hVDwEyzVjMqTyvgi'> = ({
+    instructionType: FortisMultisigInstruction.MultisigCreate;
+} & ParsedMultisigCreateInstruction<TProgram>) | ({
+    instructionType: FortisMultisigInstruction.ProposalCreate;
+} & ParsedProposalCreateInstruction<TProgram>) | ({
+    instructionType: FortisMultisigInstruction.ProposalExecute;
+} & ParsedProposalExecuteInstruction<TProgram>) | ({
+    instructionType: FortisMultisigInstruction.ProposalApprove;
+} & ParsedProposalApproveInstruction<TProgram>) | ({
+    instructionType: FortisMultisigInstruction.ProposalAccountsClose;
+} & ParsedProposalAccountsCloseInstruction<TProgram>);

package/dist/generated/programs/fortisMultisig.js

@@ -0,0 +1,42 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { containsBytes, fixEncoderSize, getBytesEncoder, } from '@solana/kit';
+export const FORTIS_MULTISIG_PROGRAM_ADDRESS = '2Zwsw5UBArhtKwGV3mQpGMaaH4q8hVDwEyzVjMqTyvgi';
+export var FortisMultisigAccount;
+(function (FortisMultisigAccount) {
+    FortisMultisigAccount[FortisMultisigAccount["Multisig"] = 0] = "Multisig";
+    FortisMultisigAccount[FortisMultisigAccount["Proposal"] = 1] = "Proposal";
+    FortisMultisigAccount[FortisMultisigAccount["VaultTransaction"] = 2] = "VaultTransaction";
+})(FortisMultisigAccount || (FortisMultisigAccount = {}));
+export var FortisMultisigInstruction;
+(function (FortisMultisigInstruction) {
+    FortisMultisigInstruction[FortisMultisigInstruction["MultisigCreate"] = 0] = "MultisigCreate";
+    FortisMultisigInstruction[FortisMultisigInstruction["ProposalCreate"] = 1] = "ProposalCreate";
+    FortisMultisigInstruction[FortisMultisigInstruction["ProposalExecute"] = 2] = "ProposalExecute";
+    FortisMultisigInstruction[FortisMultisigInstruction["ProposalApprove"] = 3] = "ProposalApprove";
+    FortisMultisigInstruction[FortisMultisigInstruction["ProposalAccountsClose"] = 4] = "ProposalAccountsClose";
+})(FortisMultisigInstruction || (FortisMultisigInstruction = {}));
+export function identifyFortisMultisigInstruction(instruction) {
+    const data = 'data' in instruction ? instruction.data : instruction;
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 1).encode(new Uint8Array([0])), 0)) {
+        return FortisMultisigInstruction.MultisigCreate;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 1).encode(new Uint8Array([1])), 0)) {
+        return FortisMultisigInstruction.ProposalCreate;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 1).encode(new Uint8Array([2])), 0)) {
+        return FortisMultisigInstruction.ProposalExecute;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 1).encode(new Uint8Array([3])), 0)) {
+        return FortisMultisigInstruction.ProposalApprove;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 1).encode(new Uint8Array([4])), 0)) {
+        return FortisMultisigInstruction.ProposalAccountsClose;
+    }
+    throw new Error('The provided instruction could not be identified as a fortisMultisig instruction.');
+}

package/dist/generated/programs/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+export * from './fortisMultisig';

package/dist/generated/programs/index.js

@@ -0,0 +1,8 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+export * from './fortisMultisig';

package/dist/generated/shared/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { type AccountMeta, type AccountSignerMeta, type Address, type ProgramDerivedAddress, type TransactionSigner } from '@solana/kit';
+/**
+ * Asserts that the given value is not null or undefined.
+ * @internal
+ */
+export declare function expectSome<T>(value: T | null | undefined): T;
+/**
+ * Asserts that the given value is a PublicKey.
+ * @internal
+ */
+export declare function expectAddress<T extends string = string>(value: Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null | undefined): Address<T>;
+/**
+ * Asserts that the given value is a PDA.
+ * @internal
+ */
+export declare function expectProgramDerivedAddress<T extends string = string>(value: Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null | undefined): ProgramDerivedAddress<T>;
+/**
+ * Asserts that the given value is a TransactionSigner.
+ * @internal
+ */
+export declare function expectTransactionSigner<T extends string = string>(value: Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null | undefined): TransactionSigner<T>;
+/**
+ * Defines an instruction account to resolve.
+ * @internal
+ */
+export type ResolvedAccount<T extends string = string, U extends Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null = Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null> = {
+    isWritable: boolean;
+    value: U;
+};
+/**
+ * Defines an instruction that stores additional bytes on-chain.
+ * @internal
+ */
+export type InstructionWithByteDelta = {
+    byteDelta: number;
+};
+/**
+ * Get account metas and signers from resolved accounts.
+ * @internal
+ */
+export declare function getAccountMetaFactory(programAddress: Address, optionalAccountStrategy: 'omitted' | 'programId'): (account: ResolvedAccount) => AccountMeta | AccountSignerMeta | undefined;
+export declare function isTransactionSigner<TAddress extends string = string>(value: Address<TAddress> | ProgramDerivedAddress<TAddress> | TransactionSigner<TAddress>): value is TransactionSigner<TAddress>;