@thru/passkey 0.2.15 → 0.2.17

package/src/server/create-wallet.ts

@@ -9,13 +9,18 @@ import {
   encodeCreateInstruction,
   encodeRegisterCredentialInstruction,
 } from '@thru/passkey-manager';
-import { toThruAddress, getStateProof, trackTransaction } from './utils';
+import {
+  toThruAddress,
+  getStateProof,
+  trackTransaction,
+  withSerializedFeePayer,
+} from './utils';
 import type { ThruClient } from './types';
 
 export async function createPasskeyWallet(opts: {
   client: ThruClient;
   adminPublicKey: Uint8Array;
-  adminPrivateKey: string;
+  adminPrivateKey: Uint8Array;
   adminAddress: string;
   pubkeyX: Uint8Array;
   pubkeyY: Uint8Array;
@@ -27,15 +32,17 @@ export async function createPasskeyWallet(opts: {
   const walletBytes = await deriveWalletAddress(seed, PASSKEY_MANAGER_PROGRAM_ADDRESS);
   const walletAddress = toThruAddress(walletBytes);
 
-  let walletExists = false;
-  try {
-    await opts.client.accounts.get(walletAddress);
-    walletExists = true;
-  } catch {
-    walletExists = false;
-  }
+  await withSerializedFeePayer(opts.adminPublicKey, async () => {
+    let walletExists = false;
+    try {
+      await opts.client.accounts.get(walletAddress);
+      walletExists = true;
+    } catch {
+      walletExists = false;
+    }
+
+    if (walletExists) return;
 
-  if (!walletExists) {
     const stateProof = await getStateProof(opts.client, walletAddress);
     const accountCtx = buildAccountContext({
       walletAddress,
@@ -61,8 +68,8 @@ export async function createPasskeyWallet(opts: {
       program: PASSKEY_MANAGER_PROGRAM_ADDRESS,
       instructionData: createIx,
       accounts: {
-        readWrite: [walletAddress],
-        readOnly: [],
+        readWrite: accountCtx.readWriteAddresses,
+        readOnly: accountCtx.readOnlyAddresses,
       },
       header: { fee: 0n },
     });
@@ -72,10 +79,12 @@ export async function createPasskeyWallet(opts: {
     const result = await trackTransaction(opts.client, signature, 60000);
     if (result.status !== 'finalized') {
       throw new Error(
-        `Wallet creation failed with error code: ${result.errorCode ?? 'unknown'}`
+        `Wallet creation failed with status: ${result.status}${
+          result.errorCode !== undefined ? ` (error code: ${result.errorCode})` : ''
+        }`
       );
     }
-  }
+  });
 
   let credentialLookupAddress: string | undefined;
   if (opts.credentialId) {
@@ -85,21 +94,24 @@ export async function createPasskeyWallet(opts: {
       walletName,
       PASSKEY_MANAGER_PROGRAM_ADDRESS
     );
+    const lookupAddress = toThruAddress(lookupAddressBytes);
 
-    credentialLookupAddress = toThruAddress(lookupAddressBytes);
+    credentialLookupAddress = lookupAddress;
 
-    let lookupExists = false;
     try {
-      await opts.client.accounts.get(credentialLookupAddress);
-      lookupExists = true;
-    } catch {
-      lookupExists = false;
-    }
+      await withSerializedFeePayer(opts.adminPublicKey, async () => {
+        let lookupExists = false;
+        try {
+          await opts.client.accounts.get(lookupAddress);
+          lookupExists = true;
+        } catch {
+          lookupExists = false;
+        }
+
+        if (lookupExists) return;
 
-    if (!lookupExists) {
-      try {
         const credSeed = await createCredentialLookupSeed(credentialIdBytes, walletName);
-        const stateProof = await getStateProof(opts.client, credentialLookupAddress);
+        const stateProof = await getStateProof(opts.client, lookupAddress);
         const accountCtx = buildAccountContext({
           walletAddress,
           readWriteAccounts: [lookupAddressBytes],
@@ -120,8 +132,8 @@ export async function createPasskeyWallet(opts: {
           program: PASSKEY_MANAGER_PROGRAM_ADDRESS,
           instructionData: registerIx,
           accounts: {
-            readWrite: [walletAddress, credentialLookupAddress],
-            readOnly: [],
+            readWrite: accountCtx.readWriteAddresses,
+            readOnly: accountCtx.readOnlyAddresses,
           },
           header: { fee: 0n },
         });
@@ -136,9 +148,9 @@ export async function createPasskeyWallet(opts: {
             }`
           );
         }
-      } catch (error) {
-        console.warn('Credential registration failed (non-fatal):', error);
-      }
+      });
+    } catch (error) {
+      console.warn('Credential registration failed (non-fatal):', error);
     }
   }
 

package/src/server/handlers.ts

@@ -10,7 +10,7 @@ import type {
 export function createPasskeyHandlers<P>(opts: {
   buildContext: (params: P) => Promise<PasskeyContextResult>;
   adminPublicKey: Uint8Array;
-  adminPrivateKey: string;
+  adminPrivateKey: Uint8Array;
   client: ThruClient;
   challengeTtlMs?: number;
 }) {

package/src/server/submit.ts

@@ -5,7 +5,7 @@ import {
   hexToBytes,
 } from '@thru/passkey-manager';
 import type { AccountContext } from '@thru/passkey-manager';
-import { trackTransaction } from './utils';
+import { trackTransaction, withSerializedFeePayer } from './utils';
 import type {
   PasskeySignaturePayload,
   ThruClient,
@@ -15,33 +15,35 @@ import type {
 export async function submitPasskeyTransaction(opts: {
   client: ThruClient;
   adminPublicKey: Uint8Array;
-  adminPrivateKey: string;
+  adminPrivateKey: Uint8Array;
   walletAddress: string;
   accountCtx: AccountContext;
   invokeIx: Uint8Array;
 } & PasskeySignaturePayload): Promise<TransactionResult> {
-  const validateIx = encodeValidateInstruction({
-    walletAccountIdx: opts.accountCtx.walletAccountIdx,
-    authIdx: 0,
-    signatureR: hexToBytes(opts.signatureR),
-    signatureS: hexToBytes(opts.signatureS),
-    authenticatorData: Buffer.from(opts.authenticatorData, 'base64'),
-    clientDataJSON: Buffer.from(opts.clientDataJSON, 'base64'),
-  });
+  return withSerializedFeePayer(opts.adminPublicKey, async () => {
+    const validateIx = encodeValidateInstruction({
+      walletAccountIdx: opts.accountCtx.walletAccountIdx,
+      authIdx: 0,
+      signatureR: hexToBytes(opts.signatureR),
+      signatureS: hexToBytes(opts.signatureS),
+      authenticatorData: Buffer.from(opts.authenticatorData, 'base64'),
+      clientDataJSON: Buffer.from(opts.clientDataJSON, 'base64'),
+    });
 
-  const instructionData = concatenateInstructions([validateIx, opts.invokeIx]);
-  const transaction = await opts.client.transactions.build({
-    feePayer: { publicKey: opts.adminPublicKey },
-    program: PASSKEY_MANAGER_PROGRAM_ADDRESS,
-    instructionData,
-    accounts: {
-      readWrite: opts.accountCtx.readWriteAddresses,
-      readOnly: opts.accountCtx.readOnlyAddresses,
-    },
-    header: { fee: 0n },
-  });
+    const instructionData = concatenateInstructions([validateIx, opts.invokeIx]);
+    const transaction = await opts.client.transactions.build({
+      feePayer: { publicKey: opts.adminPublicKey },
+      program: PASSKEY_MANAGER_PROGRAM_ADDRESS,
+      instructionData,
+      accounts: {
+        readWrite: opts.accountCtx.readWriteAddresses,
+        readOnly: opts.accountCtx.readOnlyAddresses,
+      },
+      header: { fee: 0n },
+    });
 
-  await transaction.sign(opts.adminPrivateKey);
-  const signature = await opts.client.transactions.send(transaction.toWire());
-  return trackTransaction(opts.client, signature);
+    await transaction.sign(opts.adminPrivateKey);
+    const signature = await opts.client.transactions.send(transaction.toWire());
+    return trackTransaction(opts.client, signature);
+  });
 }

package/src/server/types.ts

@@ -25,7 +25,7 @@ export interface ThruClient {
       };
       header: { fee: bigint };
     }) => Promise<{
-      sign: (privateKey: string) => Promise<unknown>;
+      sign: (privateKey: Uint8Array) => Promise<unknown>;
       toWire: () => Uint8Array;
     }>;
     send: (transaction: Uint8Array) => Promise<string>;
@@ -35,6 +35,8 @@ export interface ThruClient {
     ) => AsyncIterable<{
       executionResult?: {
         userErrorCode: bigint;
+        vmError?: bigint | number | null;
+        executionResult?: bigint | number | null;
       };
       statusCode?: number;
     }>;
@@ -55,7 +57,7 @@ export interface PasskeyChallengeSubmitPayload extends PasskeySignaturePayload {
 
 export interface TransactionResult {
   signature: string;
-  status: 'finalized' | 'failed' | 'timeout';
+  status: 'finalized' | 'failed' | 'timeout' | 'finalized_without_execution';
   errorCode?: bigint;
 }
 

package/src/server/utils.test.ts

@@ -0,0 +1,51 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import type { ThruClient } from './types';
+import { trackTransaction } from './utils';
+
+const feePayerQueueSymbol = Symbol.for('thru.sharedFeePayerQueues');
+
+function clearFeePayerQueues(): void {
+  const globalQueues = globalThis as typeof globalThis & {
+    [feePayerQueueSymbol]?: Map<string, Promise<void>>;
+  };
+
+  globalQueues[feePayerQueueSymbol]?.clear();
+  delete globalQueues[feePayerQueueSymbol];
+}
+
+describe('trackTransaction', () => {
+  beforeEach(() => {
+    clearFeePayerQueues();
+  });
+
+  it('returns a distinct status when finalized arrives without an execution payload', async () => {
+    const client = {
+      transactions: {
+        track: async function* () {
+          yield { statusCode: 3 };
+        },
+      },
+    } as ThruClient;
+
+    await expect(trackTransaction(client, 'sig-1')).resolves.toEqual({
+      signature: 'sig-1',
+      status: 'finalized_without_execution',
+    });
+  });
+
+  it('preserves finalized status if the tracking stream errors afterward', async () => {
+    const client = {
+      transactions: {
+        track: async function* () {
+          yield { statusCode: 3 };
+          throw new Error('stream closed');
+        },
+      },
+    } as ThruClient;
+
+    await expect(trackTransaction(client, 'sig-2')).resolves.toEqual({
+      signature: 'sig-2',
+      status: 'finalized_without_execution',
+    });
+  });
+});

package/src/server/utils.ts

@@ -1,6 +1,20 @@
 import { encodeAddress } from '@thru/helpers';
 import type { ThruClient, TransactionResult } from './types';
 
+const feePayerQueueSymbol = Symbol.for('thru.sharedFeePayerQueues');
+
+function getFeePayerQueues(): Map<string, Promise<void>> {
+  const globalQueues = globalThis as typeof globalThis & {
+    [feePayerQueueSymbol]?: Map<string, Promise<void>>;
+  };
+
+  if (!globalQueues[feePayerQueueSymbol]) {
+    globalQueues[feePayerQueueSymbol] = new Map<string, Promise<void>>();
+  }
+
+  return globalQueues[feePayerQueueSymbol];
+}
+
 export async function getStateProof(
   client: ThruClient,
   address: string,
@@ -34,24 +48,49 @@ export async function trackTransaction(
   signature: string,
   timeoutMs: number = 5000
 ): Promise<TransactionResult> {
+  let finalizedSeen = false;
+
   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: update.executionResult.userErrorCode === 0n ? 'finalized' : 'failed',
-          errorCode: update.executionResult.userErrorCode,
+          status: success ? 'finalized' : 'failed',
+          errorCode: vmError !== 0n ? vmError : executionError !== 0n ? executionError : userErrorCode,
         };
       }
 
       if (update.statusCode === 3) {
-        return {
-          signature,
-          status: 'finalized',
-        };
+        finalizedSeen = true;
       }
     }
+
+    if (finalizedSeen) {
+      return {
+        signature,
+        status: 'finalized_without_execution',
+      };
+    }
   } catch {
+    if (finalizedSeen) {
+      return {
+        signature,
+        status: 'finalized_without_execution',
+      };
+    }
+
     return {
       signature,
       status: 'timeout',
@@ -67,3 +106,29 @@ export async function trackTransaction(
 export function toThruAddress(bytes: Uint8Array): string {
   return encodeAddress(bytes);
 }
+
+export async function withSerializedFeePayer<T>(
+  feePayerPublicKey: Uint8Array,
+  work: () => Promise<T>
+): Promise<T> {
+  const queueKey = toThruAddress(feePayerPublicKey);
+  const feePayerQueues = getFeePayerQueues();
+  const previous = feePayerQueues.get(queueKey) ?? Promise.resolve();
+  let release!: () => void;
+  const current = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  const tail = previous.then(() => current);
+  feePayerQueues.set(queueKey, tail);
+
+  await previous;
+
+  try {
+    return await work();
+  } finally {
+    release();
+    if (feePayerQueues.get(queueKey) === tail) {
+      feePayerQueues.delete(queueKey);
+    }
+  }
+}