A transaction can have everything it needs to be signed and still fail because its builder never connects those pieces.

While reviewing Helius SDK, I reproduced that failure with a simple SOL transfer. One account paid the fee, another account sent the SOL, and I supplied both signers to createSmartTransaction. The builder still failed with a missing signature.

The source account was correctly marked as requiring a signature. Its signer was present in the input array. What was missing was the connection between that signer and the instruction account.

I reported the behavior in issue #385 and submitted PR #383, which merged on November 6, 2026, UTC. The fix attaches the supplied signers before building the transaction messages.

The fee payer and the sender can be different accounts

Helius SDK provides tools for applications built on Solana. Its smart transaction builder estimates compute requirements and priority fees, builds a transaction, and returns the signed result. The reviewed implementation accepts instructions and a separate signers array. Reviewed builder

For the reproduction, the accounts had two different jobs:

AccountJobWhy it must sign
Payer APay the transaction feeAuthorize payment of the fee
Source BSend SOL to AAuthorize movement of B's SOL

This separation is useful when an application sponsors transaction fees for a user. The application can pay the fee while the user authorizes the transfer. It also provides a small test case: two required signatures, with no swap math or token extensions involved.

An instruction account can carry an address and a role saying that it must sign. A signer object also provides the operation that produces a signature. Those are different pieces of information. Declaring that B must sign does not, by itself, give the builder B's signing operation.

The failing input supplied that operation through signers: [payer, source], but kept the instruction accounts as ordinary address-and-role metadata.

Reproduce the plain-metadata path

I reproduced the problem against SDK version 3.3.0 at commit 9d2fc5521d4345623635e6b0b62ebbb421855114. The test used real Ed25519 signers and controlled RPC responses. Ed25519 is the signature scheme used by these Solana accounts. Environment and reproduction

The regression first built a normal SOL transfer instruction, then removed its embedded signer fields while retaining every account's address and role. This excerpt omits the signer and RPC-fixture setup:

ts
const transfer = getTransferSolInstruction({
  source,
  destination: payer.address,
  amount: 1n,
});

const plainInstruction: Instruction = {
  ...transfer,
  accounts: transfer.accounts.map(({ address, role }) => ({
    address,
    role,
  })),
};

const result = await create({
  instructions: [plainInstruction],
  signers: [payer, source],
  version: 0,
});

Here, create is the real smart transaction builder wired to the test's controlled dependencies. With no explicit feePayer, the builder uses the first supplied signer, A. B remains a required signer on the transfer instruction. Regression fixture

Removing the embedded field is deliberate. Otherwise, the instruction can already carry B's signer and hide the failure in the separate input array. The test keeps the signing requirement intact and checks whether the builder actually uses the signer supplied through its public argument.

This input shape can arise when an application constructs instruction metadata separately from its signers, or converts instructions between representations. A fee-sponsored transfer or a transaction creating a new keypair-backed account can need a signer distinct from the fee payer. Those are integration scenarios where the same condition matters; the recorded reproduction is the SOL transfer above. A standard builder that already embeds the required signer does not exercise this failure path.

Where the extra signer disappeared

Before the fix, the builder resolved the fee-payer signer from the inputs. It then filtered the user instructions and appended them to the messages without attaching the other supplied signers.

The fee payer was connected through setTransactionMessageFeePayerSigner. B's address and required-signer role reached the message, but B's signer object stayed in the original array. Later, signTransactionMessageWithSigners had no attached signer for B.

The failure stage depends on the transaction format. Legacy and v0 transactions sign a draft to request a priority-fee estimate, so the missing signer can stop construction there. The reviewed v1 path requests the estimate using account keys instead of a signed draft; it still needs B when signing the final message. Draft estimation and final signing paths

The same inputs supply payer A and source B. Before the fix, only A's signer is connected and construction fails because B's signature is missing. After the fix, B's signer is attached to the required instruction account and both signatures are produced.

The required account was present in both cases. The fix connects the supplied signing operation to that account before message construction.

This is why I followed the signer beyond the function's input. Seeing B in signers and seeing B marked as a signer in the instruction looked consistent. The path connecting those two representations was absent.

Attach signers before building either message

My patch used Solana Kit's addSignersToInstruction helper on the user instructions before building the estimation draft and final message. This lets matching account addresses receive the supplied signers while preserving signers already attached to instructions. It also leaves the caller's instruction metadata unchanged. Patch and regression tests

The merged implementation prepares the available signers, then applies the helper:

ts
const seen = new Set<string>();
const ixSigners = [feePayerSigner, ...signers].filter(
  (s) => !seen.has(s.address) && !!seen.add(s.address)
);

const userIxs = instructions
  .filter((ix) => !isComputeBudgetIx(ix))
  .map((ix) => addSignersToInstruction(ixSigners, ix));

The address deduplication was an important addition from maintainer 0xIchigo during review. Two distinct signer objects can represent the same key. Passing both to Kit's attachment helper can throw even though they have the same address. The maintainer made the fee-payer signer take precedence, retained one supplied signer per address, and added tests for the duplicate-object cases.

The maintainer also updated the new test's relative imports to include .js, matching the repository's intervening NodeNext changes. These review additions are part of the final fix, rather than work I should attribute entirely to my initial patch. Maintainer review

Check the signatures that the builder produces

I wanted the regression to check the resulting transaction, not just whether an array contained two entries.

For the plain-metadata transfer, the test requires signature entries for exactly A and B. It then verifies each Ed25519 signature against the transaction's actual message bytes. Legacy and v0 tests also decode the signed draft passed to the priority-fee estimator and verify its signatures. The v1 test verifies the final transaction without expecting a signed estimation draft.

The suite also checks the surrounding behavior:

CaseRequired result
Plain instruction metadata with A and B suppliedBoth required signatures are valid
An instruction that already carries its signerIts signing behavior is preserved
An explicit fee payer supplied as an address or signer objectThe selected payer is respected
An unused signer in the input arrayIt does not become an extra transaction signer
A genuinely missing required signerConstruction still fails
Two supplied signer objects for the same addressThe merged implementation accepts them without an attachment conflict

The tests also check that attaching signers does not add signer fields to the caller's original account metadata. The builder derives its working instructions without changing the input objects. Final regression suite

At review-ready commit 7b327ea, my validation report recorded 716 passing tests, along with formatting, lint, type checking, ESM/CJS builds, tree-shaking and bundle checks. The new regression suite failed against the original implementation and passed with the fix. The maintainer subsequently added the two duplicate-address cases before merging. Review-ready validation

These checks used local fixtures and real signature verification. They demonstrate the construction failure and its correction without submitting a transaction to a chain.

Follow the signer all the way to the message

The useful question from this fix is small: when an API accepts a signer, where does that signer become available to the operation that needs it?

For this builder, an account address and a required-signer role were insufficient. The signer object also had to reach the instruction before the message was signed. Testing a separate fee payer exposed that missing connection, and verifying the resulting signatures showed that the fix completed it.

✳

Thanks for reading. Keep following your curiosity.

NEXT NOTE ↗

I Tried Anthropic's Memory Ideas. My Answers Did Not Improve.