@thru/passkey 0.2.35 → 0.2.37

package/src/server/submit.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it, vi } from 'vitest';
 import type { AccountContext } from '@thru/programs/passkey-manager';
+import { encodeSignature } from '@thru/sdk/helpers';
 import type { ThruClient } from './types';
 
 const passkeyManagerMocks = vi.hoisted(() => ({
@@ -29,9 +30,11 @@ const signaturePayload = {
 };
 
 function createClient() {
+  const signatureBytes = new Uint8Array(64).fill(7);
+  const rawTransaction = new Uint8Array(64).fill(9);
   const transaction = {
     sign: vi.fn(async () => {}),
-    toWire: vi.fn(() => new Uint8Array([9, 9, 9])),
+    toWire: vi.fn(() => rawTransaction),
   };
   const client = {
     transactions: {
@@ -46,15 +49,26 @@ function createClient() {
           },
         };
       }),
+      sendAndTrack: vi.fn(async function* () {
+        yield {
+          status: 2,
+          signature: { value: signatureBytes },
+          executionResult: {
+            userErrorCode: 0n,
+            vmError: 0,
+            executionResult: 0n,
+          },
+        };
+      }),
     },
   } as unknown as ThruClient;
 
-  return { client, transaction };
+  return { client, transaction, rawTransaction, signatureBytes };
 }
 
 describe('passkey submit', () => {
   it('builds and signs a passkey transaction with explicit header overrides', async () => {
-    const { client, transaction } = createClient();
+    const { client, rawTransaction, transaction } = createClient();
 
     const result = await buildPasskeyTransaction({
       client,
@@ -95,11 +109,11 @@ describe('passkey submit', () => {
       })
     );
     expect(transaction.sign).toHaveBeenCalledWith(new Uint8Array(32).fill(2));
-    expect(result.rawTransaction).toEqual(new Uint8Array([9, 9, 9]));
+    expect(result.rawTransaction).toEqual(rawTransaction);
   });
 
-  it('keeps submitPasskeyTransaction as a send and track convenience wrapper', async () => {
-    const { client } = createClient();
+  it('submits and tracks passkey transactions through one streaming RPC', async () => {
+    const { client, rawTransaction, signatureBytes } = createClient();
 
     await expect(submitPasskeyTransaction({
       client,
@@ -111,11 +125,15 @@ describe('passkey submit', () => {
       instructionData: new Uint8Array([3, 4]),
       ...signaturePayload,
     })).resolves.toEqual({
-      signature: 'tx-signature',
+      signature: encodeSignature(signatureBytes),
       status: 'finalized',
       errorCode: 0n,
     });
 
-    expect(client.transactions.send).toHaveBeenCalledWith(new Uint8Array([9, 9, 9]));
+    expect(client.transactions.sendAndTrack).toHaveBeenCalledWith(rawTransaction, {
+      timeoutMs: 5000,
+    });
+    expect(client.transactions.send).not.toHaveBeenCalled();
+    expect(client.transactions.track).not.toHaveBeenCalled();
   });
 });

package/src/server/submit.ts

@@ -5,7 +5,7 @@ import {
   hexToBytes,
 } from '@thru/programs/passkey-manager';
 import type { AccountContext } from '@thru/programs/passkey-manager';
-import { trackTransaction, withSerializedFeePayer } from './utils';
+import { sendAndTrackTransaction, withSerializedFeePayer } from './utils';
 import type {
   BuiltPasskeyTransaction,
   PasskeySignaturePayload,
@@ -103,7 +103,6 @@ export async function submitPasskeyTransaction(opts: {
 } & PasskeySignaturePayload): Promise<TransactionResult> {
   return withSerializedFeePayer(opts.adminPublicKey, async () => {
     const { rawTransaction } = await buildPasskeyTransaction(opts);
-    const signature = await opts.client.transactions.send(rawTransaction);
-    return trackTransaction(opts.client, signature);
+    return sendAndTrackTransaction(opts.client, rawTransaction);
   });
 }

package/src/server/types.ts

@@ -11,6 +11,13 @@ export interface BuiltPasskeyTransaction {
   rawTransaction: Uint8Array;
 }
 
+export interface TransactionExecutionResultLike {
+  userErrorCode?: bigint | number | null;
+  vmError?: bigint | number | null;
+  executionResult?: bigint | number | null;
+  consumedComputeUnits?: number;
+}
+
 export interface ThruClient {
   accounts: {
     get: (address: string) => Promise<{ data?: { data?: Uint8Array } }>;
@@ -44,13 +51,18 @@ export interface ThruClient {
       signature: string,
       opts: { timeoutMs: number }
     ) => AsyncIterable<{
-      executionResult?: {
-        userErrorCode: bigint;
-        vmError?: bigint | number | null;
-        executionResult?: bigint | number | null;
-      };
+      executionResult?: TransactionExecutionResultLike;
       statusCode?: number;
     }>;
+    sendAndTrack: (
+      transaction: Uint8Array,
+      opts: { timeoutMs: number }
+    ) => AsyncIterable<{
+      status?: number;
+      signature?: { value: Uint8Array };
+      consensusStatus?: number;
+      executionResult?: TransactionExecutionResultLike;
+    }>;
   };
 }
 

package/src/server/utils.test.ts

@@ -1,6 +1,7 @@
 import { beforeEach, describe, expect, it } from 'vitest';
+import { encodeSignature } from '@thru/sdk/helpers';
 import type { ThruClient } from './types';
-import { trackTransaction } from './utils';
+import { sendAndTrackTransaction, trackTransaction } from './utils';
 
 const feePayerQueueSymbol = Symbol.for('thru.sharedFeePayerQueues');
 
@@ -49,3 +50,76 @@ describe('trackTransaction', () => {
     });
   });
 });
+
+describe('sendAndTrackTransaction', () => {
+  beforeEach(() => {
+    clearFeePayerQueues();
+  });
+
+  const rawTransaction = new Uint8Array(64).fill(9);
+
+  it('returns execution results from the send-and-track stream', async () => {
+    const signatureBytes = new Uint8Array(64).fill(3);
+    const client = {
+      transactions: {
+        sendAndTrack: async function* () {
+          yield {
+            status: 2,
+            signature: { value: signatureBytes },
+            executionResult: {
+              userErrorCode: 0n,
+              vmError: 0,
+              executionResult: 0n,
+            },
+          };
+        },
+      },
+    } as ThruClient;
+
+    await expect(
+      sendAndTrackTransaction(client, rawTransaction)
+    ).resolves.toEqual({
+      signature: encodeSignature(signatureBytes),
+      status: 'finalized',
+      errorCode: 0n,
+    });
+  });
+
+  it('preserves an accepted transaction as a timeout if the stream closes early', async () => {
+    const signatureBytes = new Uint8Array(64).fill(4);
+    const client = {
+      transactions: {
+        sendAndTrack: async function* () {
+          yield {
+            status: 2,
+            signature: { value: signatureBytes },
+          };
+          throw new Error('stream closed');
+        },
+      },
+    } as ThruClient;
+
+    await expect(
+      sendAndTrackTransaction(client, rawTransaction)
+    ).resolves.toEqual({
+      signature: encodeSignature(signatureBytes),
+      status: 'timeout',
+    });
+  });
+
+  it('rejects malformed raw transactions before submitting them', async () => {
+    const client = {
+      transactions: {
+        sendAndTrack: async function* () {
+          yield {
+            status: 2,
+          };
+        },
+      },
+    } as ThruClient;
+
+    await expect(
+      sendAndTrackTransaction(client, new Uint8Array([1, 2, 3]))
+    ).rejects.toThrow('Raw transaction too short to contain a signature: 3 bytes');
+  });
+});

package/src/server/utils.ts

@@ -1,7 +1,14 @@
-import { encodeAddress } from '@thru/sdk/helpers';
-import type { ThruClient, TransactionResult } from './types';
+import { encodeAddress, encodeSignature } from '@thru/sdk/helpers';
+import type {
+  ThruClient,
+  TransactionExecutionResultLike,
+  TransactionResult,
+} from './types';
 
 const feePayerQueueSymbol = Symbol.for('thru.sharedFeePayerQueues');
+const SUBMISSION_STATUS_ACCEPTED = 2;
+const CONSENSUS_STATUS_FINALIZED = 3;
+const CONSENSUS_STATUS_CLUSTER_EXECUTED = 5;
 
 function getFeePayerQueues(): Map<string, Promise<void>> {
   const globalQueues = globalThis as typeof globalThis & {
@@ -53,26 +60,10 @@ export async function trackTransaction(
   try {
     for await (const update of client.transactions.track(signature, { timeoutMs })) {
       if (update.executionResult) {
-        const vmError =
-          update.executionResult.vmError !== undefined && update.executionResult.vmError !== null
-            ? BigInt(update.executionResult.vmError)
-            : 0n;
-        const userErrorCode = update.executionResult.userErrorCode;
-        const executionError =
-          update.executionResult.executionResult !== undefined &&
-          update.executionResult.executionResult !== null
-            ? BigInt(update.executionResult.executionResult)
-            : 0n;
-        const success = vmError === 0n && executionError === 0n && userErrorCode === 0n;
-
-        return {
-          signature,
-          status: success ? 'finalized' : 'failed',
-          errorCode: vmError !== 0n ? vmError : executionError !== 0n ? executionError : userErrorCode,
-        };
+        return executionResultToTransactionResult(signature, update.executionResult);
       }
 
-      if (update.statusCode === 3) {
+      if (isFinalConsensusStatus(update.statusCode)) {
         finalizedSeen = true;
       }
     }
@@ -103,10 +94,106 @@ export async function trackTransaction(
   };
 }
 
+export async function sendAndTrackTransaction(
+  client: ThruClient,
+  rawTransaction: Uint8Array,
+  timeoutMs: number = 5000
+): Promise<TransactionResult> {
+  let signature = signatureFromRawTransaction(rawTransaction);
+  let accepted = false;
+  let finalizedSeen = false;
+
+  try {
+    for await (const update of client.transactions.sendAndTrack(rawTransaction, { timeoutMs })) {
+      if (update.signature?.value) {
+        signature = encodeSignature(update.signature.value);
+      }
+      if (update.status === SUBMISSION_STATUS_ACCEPTED) {
+        accepted = true;
+      }
+      if (isFinalConsensusStatus(update.consensusStatus)) {
+        finalizedSeen = true;
+      }
+      if (update.executionResult) {
+        return executionResultToTransactionResult(signature, update.executionResult);
+      }
+    }
+  } catch (error) {
+    if (finalizedSeen && signature) {
+      return {
+        signature,
+        status: 'finalized_without_execution',
+      };
+    }
+
+    if (accepted && signature) {
+      return {
+        signature,
+        status: 'timeout',
+      };
+    }
+
+    throw error;
+  }
+
+  if (finalizedSeen && signature) {
+    return {
+      signature,
+      status: 'finalized_without_execution',
+    };
+  }
+
+  if (accepted && signature) {
+    return {
+      signature,
+      status: 'timeout',
+    };
+  }
+
+  throw new Error('SendAndTrackTxn did not accept the transaction');
+}
+
 export function toThruAddress(bytes: Uint8Array): string {
   return encodeAddress(bytes);
 }
 
+function executionResultToTransactionResult(
+  signature: string,
+  executionResult: TransactionExecutionResultLike
+): TransactionResult {
+  const vmError =
+    executionResult.vmError !== undefined && executionResult.vmError !== null
+      ? BigInt(executionResult.vmError)
+      : 0n;
+  const userErrorCode =
+    executionResult.userErrorCode !== undefined && executionResult.userErrorCode !== null
+      ? BigInt(executionResult.userErrorCode)
+      : 0n;
+  const executionError =
+    executionResult.executionResult !== undefined &&
+    executionResult.executionResult !== null
+      ? BigInt(executionResult.executionResult)
+      : 0n;
+  const success = vmError === 0n && executionError === 0n && userErrorCode === 0n;
+
+  return {
+    signature,
+    status: success ? 'finalized' : 'failed',
+    errorCode: vmError !== 0n ? vmError : executionError !== 0n ? executionError : userErrorCode,
+  };
+}
+
+function isFinalConsensusStatus(status?: number): boolean {
+  return status === CONSENSUS_STATUS_FINALIZED || status === CONSENSUS_STATUS_CLUSTER_EXECUTED;
+}
+
+function signatureFromRawTransaction(rawTransaction: Uint8Array): string {
+  if (rawTransaction.length < 64) {
+    throw new Error(`Raw transaction too short to contain a signature: ${rawTransaction.length} bytes`);
+  }
+  return encodeSignature(rawTransaction.slice(rawTransaction.length - 64));
+}
+
 export async function withSerializedFeePayer<T>(
   feePayerPublicKey: Uint8Array,
   work: () => Promise<T>

package/dist/chunk-NFK5D7EI.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/auth/add-device.ts"],"sourcesContent":["/* Add-passkey-to-account transaction builder, lifted from\n   `web/wallet-auth-manager/app/page.tsx` (`runValidateThen`,\n   `handleSubmitAddPasskey`) so the wallet's `/embedded` post-connect\n   step can reuse the exact same flow.\n\n   Builds the on-chain transaction:\n     VALIDATE(existingAuthority -> ADD_AUTHORITY(newPasskey))\n     or VALIDATE(existingAuthority -> multicall[ADD_AUTHORITY, REGISTER_CREDENTIAL])\n   asks the caller's existing passkey to sign the challenge, then asks\n   the caller's wallet signer to sign the assembled transaction, sends\n   it, and returns the result. */\n\nimport {\n  type Authority,\n  type AuthorityRecord,\n  buildAccountContext,\n  createAuthorityRecord,\n  createCredentialLookupSeed,\n  createValidateChallenge,\n  decodeAddress,\n  deriveWalletAddress,\n  encodeAddAuthorityInstruction,\n  encodeLegacyAddAuthorityInstruction,\n  encodeRegisterCredentialInstruction,\n  encodeValidateInstruction,\n  parseWalletAuthorities,\n  type ParsedAuthority,\n  type WalletSigner,\n} from \"@thru/programs/passkey-manager\";\nimport {\n  MULTICALL_PROGRAM_PUBKEY,\n  buildMulticallInstruction,\n} from \"@thru/programs/multicall\";\n\n/** Minimal shape required from a passkey signer. Both web's\n    `signWithDiscoverablePasskey`/`signWithPasskey` and mobile's\n    counterparts conform. */\nexport interface PasskeyChallengeSigner {\n  signChallenge: (challenge: Uint8Array) => Promise<{\n    signatureR: Uint8Array;\n    signatureS: Uint8Array;\n    authenticatorData: Uint8Array;\n    clientDataJSON: Uint8Array;\n  }>;\n}\n\n/** Minimal shape required from a Thru chain client. Loosely-typed\n    because @thru/sdk's DTS emit is currently broken in this\n    repo. The caller passes the real Thru and we narrow operationally. */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyThruClient = any;\n\nexport interface AddDeviceParams {\n  /** Loosely-typed Thru chain client (`@thru/sdk/client`). */\n  thru: AnyThruClient;\n  /** Wallet (the on-chain WalletAccount) to attach the passkey to. */\n  walletAddress: string;\n  /** Index of the existing authority that approves this change. Must\n      currently be a passkey authority. */\n  authIdx: number;\n  /** New passkey to attach. tag = 1 (passkey). */\n  newAuthority: Authority;\n  newAuthorityRecord?: AuthorityRecord;\n  /** Optional credential-lookup registration so the new passkey is\n      discoverable on subsequent sign-ins. */\n  credentialId?: Uint8Array;\n  walletName?: string;\n  /** Existing-passkey challenge signer (web or mobile). */\n  passkey: PasskeyChallengeSigner;\n  /** Wallet transaction signer that returns base64(signed bytes). */\n  walletSigner: WalletSigner;\n  /** Passkey program address (base58). */\n  programAddress: string;\n  /** Sign-and-send executor (lifted from passkey-transaction.ts in the\n      wallet-auth-manager - wallet apps own this because it depends on\n      the `Thru` client's transaction builder). */\n  executor: TxExecutor;\n  /** Optional status callback so UIs can show progress. */\n  onStatus?: (message: string) => void;\n}\n\nexport interface TxExecutorParams {\n  thru: AnyThruClient;\n  walletSigner: WalletSigner;\n  instructionData: Uint8Array;\n  readWriteAddresses: string[];\n  readOnlyAddresses: string[];\n  label: string;\n}\n\nexport interface TxExecutorResult {\n  signature: string;\n  /** Loosely-typed because @thru/sdk types aren't available. */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  execution: any;\n}\n\nexport type TxExecutor = (\n  params: TxExecutorParams,\n) => Promise<TxExecutorResult>;\n\nexport interface AddDeviceResult extends TxExecutorResult {\n  /** The new passkey's authority index after the transaction lands. */\n  newAuthorityIdx: number;\n}\n\nexport interface AddAuthorityParams\n  extends Omit<AddDeviceParams, \"newAuthority\" | \"newAuthorityRecord\" | \"credentialId\" | \"walletName\"> {\n  /** Complete authority record to append. */\n  authorityRecord: AuthorityRecord;\n}\n\n/**\n * Run VALIDATE + ADD_AUTHORITY [+ REGISTER_CREDENTIAL] to attach a new\n * passkey to an on-chain WalletAccount.\n */\nexport async function addDeviceToAccount(\n  params: AddDeviceParams,\n): Promise<AddDeviceResult> {\n  return addAuthorityToAccount({\n    ...params,\n    authorityRecord:\n      params.newAuthorityRecord ?? createAuthorityRecord(params.newAuthority),\n  });\n}\n\n/**\n * Run VALIDATE + ADD_AUTHORITY to attach a complete authority record to an\n * on-chain WalletAccount.\n */\nexport async function addAuthorityToAccount(\n  params: AddAuthorityParams & Pick<AddDeviceParams, \"credentialId\" | \"walletName\">,\n): Promise<AddDeviceResult> {\n  const status = params.onStatus ?? (() => {});\n\n  const walletAccount = await params.thru.accounts.get(params.walletAddress);\n  const walletData: Uint8Array | undefined = walletAccount?.data?.data;\n  if (!walletData) {\n    throw new Error(\"Wallet account data missing\");\n  }\n\n  const parsed = parseWalletAuthorities(walletData);\n  const authorizing: ParsedAuthority | undefined =\n    parsed.authorities[params.authIdx];\n  if (!authorizing) {\n    throw new Error(\"Authorization index out of bounds\");\n  }\n  if (authorizing.kind !== \"passkey\") {\n    throw new Error(\n      \"addDeviceToAccount currently requires a passkey authority for VALIDATE\",\n    );\n  }\n\n  /* The new authority will land at the next free slot. */\n  const newAuthorityIdx = parsed.authorities.length;\n\n  let readWriteAccounts: Uint8Array[] = [];\n  let lookupSeed: Uint8Array | undefined;\n  let lookupAddressBytes: Uint8Array | undefined;\n  let lookupProof: Uint8Array | undefined;\n\n  if (params.credentialId) {\n    lookupSeed = await createCredentialLookupSeed(params.credentialId);\n    lookupAddressBytes = await deriveWalletAddress(\n      lookupSeed,\n      params.programAddress,\n    );\n\n    status(\"Fetching state proof for credential lookup...\");\n    const proofResult = await params.thru.proofs.generate({\n      proofType: 1 /* StateProofType.CREATING */,\n      address: lookupAddressBytes,\n    });\n    lookupProof = proofResult.proof;\n    readWriteAccounts = [lookupAddressBytes];\n  }\n\n  const ctx = buildAccountContext({\n    walletAddress: params.walletAddress,\n    readWriteAccounts,\n    readOnlyAccounts: params.credentialId ? [MULTICALL_PROGRAM_PUBKEY] : [],\n    programAddress: params.programAddress,\n  });\n\n  const passkeyProgramPubkey = decodeAddress(params.programAddress);\n  const encodeAuthorityInstruction =\n    parsed.layout === \"legacyAuthority\"\n      ? encodeLegacyAddAuthorityInstruction\n      : encodeAddAuthorityInstruction;\n  const addAuthorityInstruction = encodeAuthorityInstruction({\n    walletAccountIdx: ctx.walletAccountIdx,\n    authorityRecord: params.authorityRecord,\n  });\n\n  let targetProgramIdx = ctx.getAccountIndex(passkeyProgramPubkey);\n  let targetInstructionData = addAuthorityInstruction;\n\n  if (params.credentialId) {\n    if (!lookupSeed || !lookupAddressBytes || !lookupProof) {\n      throw new Error(\"Credential lookup proof data missing\");\n    }\n\n    const registerCredentialInstruction = encodeRegisterCredentialInstruction({\n      walletAccountIdx: ctx.walletAccountIdx,\n      lookupAccountIdx: ctx.getAccountIndex(lookupAddressBytes),\n      seed: lookupSeed,\n      stateProof: lookupProof,\n    });\n\n    targetProgramIdx = ctx.getAccountIndex(MULTICALL_PROGRAM_PUBKEY);\n    targetInstructionData = buildMulticallInstruction([\n      {\n        programIdx: ctx.getAccountIndex(passkeyProgramPubkey),\n        instructionData: addAuthorityInstruction,\n      },\n      {\n        programIdx: ctx.getAccountIndex(passkeyProgramPubkey),\n        instructionData: registerCredentialInstruction,\n      },\n    ]);\n  }\n\n  /* Build the VALIDATE challenge over the target CPI and ask the caller's passkey to sign. */\n  const challenge = await createValidateChallenge(\n    parsed.nonce,\n    ctx.accountAddresses,\n    ctx.walletAccountIdx,\n    params.authIdx,\n    {\n      programIdx: targetProgramIdx,\n      instructionData: targetInstructionData,\n    },\n  );\n\n  status(\"Waiting for passkey approval...\");\n  const signature = await params.passkey.signChallenge(challenge);\n\n  const validateInstruction = encodeValidateInstruction({\n    walletAccountIdx: ctx.walletAccountIdx,\n    authIdx: params.authIdx,\n    targetInstruction: {\n      programIdx: targetProgramIdx,\n      instructionData: targetInstructionData,\n    },\n    signatureR: signature.signatureR,\n    signatureS: signature.signatureS,\n    authenticatorData: signature.authenticatorData,\n    clientDataJSON: signature.clientDataJSON,\n  });\n\n  status(\"Sending transaction...\");\n  const result = await params.executor({\n    thru: params.thru,\n    walletSigner: params.walletSigner,\n    instructionData: validateInstruction,\n    readWriteAddresses: ctx.readWriteAddresses,\n    readOnlyAddresses: ctx.readOnlyAddresses,\n    label: params.credentialId\n      ? \"VALIDATE -> MULTICALL(ADD_AUTHORITY, REGISTER_CREDENTIAL)\"\n      : \"VALIDATE -> ADD_AUTHORITY\",\n  });\n\n  return { ...result, newAuthorityIdx };\n}\n"],"mappings":"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","names":[]}