@thru/programs 0.2.22 → 0.2.24

package/src/passkey-manager/challenge.ts

@@ -1,38 +1,78 @@
+import type { TargetInstructionParams } from './types';
+import { buildTargetInstructionBytes } from './target-instruction';
+
 /**
  * Create challenge for VALIDATE instruction.
- * SHA256(nonce || account_0 || account_1 || ... || trailing_instruction_bytes)
+ * SHA256(domain || nonce || wallet_account_idx || auth_idx || account_count ||
+ *        account_0 || account_1 || ... || target_instruction)
  */
+export const VALIDATE_CHALLENGE_DOMAIN = 'thru.passkey.validate';
+
+function writeU64LE(target: Uint8Array, offset: number, value: bigint): void {
+  let remaining = value;
+  for (let i = 0; i < 8; i++) {
+    target[offset + i] = Number(remaining & 0xffn);
+    remaining >>= 8n;
+  }
+}
+
 export async function createValidateChallenge(
   nonce: bigint,
   accountAddresses: string[],
-  trailingInstructionData: Uint8Array
+  walletAccountIdx: number,
+  authIdx: number,
+  targetInstruction: TargetInstructionParams
 ): Promise<Uint8Array> {
+  const targetInstructionBytes = buildTargetInstructionBytes(targetInstruction);
   const encoder = new TextEncoder();
+  const domainBytes = encoder.encode(VALIDATE_CHALLENGE_DOMAIN);
   const accountBytes = accountAddresses.map((address) => {
-    return encoder.encode(address);
+    const bytes = encoder.encode(address);
+    if (bytes.length !== 46) {
+      throw new Error('accountAddresses must contain ta addresses');
+    }
+    return bytes;
   });
+  if (walletAccountIdx < 0 || walletAccountIdx > 0xffff) {
+    throw new Error('walletAccountIdx must be 0-65535');
+  }
+  if (authIdx < 0 || authIdx > 0xff) throw new Error('authIdx must be 0-255');
+  if (accountBytes.length > 0xffff) throw new Error('accountAddresses length must be 0-65535');
 
   const totalSize =
-    accountBytes.reduce((sum, bytes) => sum + bytes.length, 8) +
-    trailingInstructionData.length;
+    domainBytes.length +
+    8 +
+    2 +
+    1 +
+    2 +
+    accountBytes.reduce((sum, bytes) => sum + bytes.length, 0) +
+    targetInstructionBytes.length;
   const challengeData = new Uint8Array(totalSize);
 
   let offset = 0;
+  challengeData.set(domainBytes, offset);
+  offset += domainBytes.length;
 
-  // Write nonce as little-endian u64
-  let v = nonce;
-  for (let i = 0; i < 8; i++) {
-    challengeData[offset + i] = Number(v & 0xffn);
-    v >>= 8n;
-  }
+  writeU64LE(challengeData, offset, nonce);
   offset += 8;
 
+  challengeData[offset] = walletAccountIdx & 0xff;
+  challengeData[offset + 1] = (walletAccountIdx >> 8) & 0xff;
+  offset += 2;
+
+  challengeData[offset] = authIdx & 0xff;
+  offset += 1;
+
+  challengeData[offset] = accountBytes.length & 0xff;
+  challengeData[offset + 1] = (accountBytes.length >> 8) & 0xff;
+  offset += 2;
+
   for (const bytes of accountBytes) {
     challengeData.set(bytes, offset);
     offset += bytes.length;
   }
 
-  challengeData.set(trailingInstructionData, offset);
+  challengeData.set(targetInstructionBytes, offset);
 
   const hashBuffer = await crypto.subtle.digest('SHA-256', challengeData);
   return new Uint8Array(hashBuffer);

package/src/passkey-manager/constants.ts

@@ -5,7 +5,6 @@ export const PASSKEY_MANAGER_PROGRAM_ADDRESS =
 export const INSTRUCTION_CREATE = 0x00;
 export const INSTRUCTION_VALIDATE = 0x01;
 export const INSTRUCTION_TRANSFER = 0x02;
-export const INSTRUCTION_INVOKE = 0x03;
 export const INSTRUCTION_ADD_AUTHORITY = 0x04;
 export const INSTRUCTION_REMOVE_AUTHORITY = 0x05;
 export const INSTRUCTION_REGISTER_CREDENTIAL = 0x06;

package/src/passkey-manager/index.ts

@@ -4,7 +4,6 @@ export {
   INSTRUCTION_CREATE,
   INSTRUCTION_VALIDATE,
   INSTRUCTION_TRANSFER,
-  INSTRUCTION_INVOKE,
   INSTRUCTION_ADD_AUTHORITY,
   INSTRUCTION_REMOVE_AUTHORITY,
   INSTRUCTION_REGISTER_CREDENTIAL,
@@ -17,7 +16,10 @@ export type {
   Authority,
   CreateInstructionParams,
   TransferInstructionParams,
+  TargetInstructionParams,
   ValidateInstructionParams,
+  AddAuthorityInstructionParams,
+  RemoveAuthorityInstructionParams,
   RegisterCredentialInstructionParams,
   AccountContext,
   WalletSigner,
@@ -32,14 +34,12 @@ export type {
 export { encodeCreateInstruction } from './instructions/create';
 export { encodeValidateInstruction } from './instructions/validate';
 export { encodeTransferInstruction } from './instructions/transfer';
-export { encodeInvokeInstruction } from './instructions/invoke';
 export { encodeAddAuthorityInstruction } from './instructions/add-authority';
 export { encodeRemoveAuthorityInstruction } from './instructions/remove-authority';
 export { encodeRegisterCredentialInstruction } from './instructions/register-credential';
-export { concatenateInstructions } from './instructions/shared';
 
 // Challenge
-export { createValidateChallenge } from './challenge';
+export { createValidateChallenge, VALIDATE_CHALLENGE_DOMAIN } from './challenge';
 
 // Seeds & derivation
 export { createWalletSeed, deriveWalletAddress, createCredentialLookupSeed, deriveCredentialLookupAddress } from './seeds';

package/src/passkey-manager/instructions/add-authority.ts

@@ -1,14 +1,20 @@
-import type { Authority } from '../types';
+import type { AddAuthorityInstructionParams } from '../types';
 import {
   AddAuthorityArgsBuilder,
   PasskeyInstructionBuilder,
 } from '../abi/thru/program/passkey_manager/types';
 import { buildAuthority } from './create';
 
-export function encodeAddAuthorityInstruction(params: { authority: Authority }): Uint8Array {
+export function encodeAddAuthorityInstruction(params: AddAuthorityInstructionParams): Uint8Array {
+  const { walletAccountIdx } = params;
+  if (walletAccountIdx < 0 || walletAccountIdx > 0xffff) {
+    throw new Error('walletAccountIdx must be 0-65535');
+  }
+
   const authorityBytes = buildAuthority(params.authority);
 
   const argsPayload = new AddAuthorityArgsBuilder()
+    .set_wallet_account_idx(walletAccountIdx)
     .set_authority(authorityBytes)
     .build();
 

package/src/passkey-manager/instructions/remove-authority.ts

@@ -2,12 +2,19 @@ import {
   RemoveAuthorityArgsBuilder,
   PasskeyInstructionBuilder,
 } from '../abi/thru/program/passkey_manager/types';
+import type { RemoveAuthorityInstructionParams } from '../types';
 
-export function encodeRemoveAuthorityInstruction(params: { authIdx: number }): Uint8Array {
-  const { authIdx } = params;
+export function encodeRemoveAuthorityInstruction(
+  params: RemoveAuthorityInstructionParams
+): Uint8Array {
+  const { walletAccountIdx, authIdx } = params;
+  if (walletAccountIdx < 0 || walletAccountIdx > 0xffff) {
+    throw new Error('walletAccountIdx must be 0-65535');
+  }
   if (authIdx < 0 || authIdx > 0xff) throw new Error('authIdx must be 0-255');
 
   const argsPayload = new RemoveAuthorityArgsBuilder()
+    .set_wallet_account_idx(walletAccountIdx)
     .set_auth_idx(authIdx)
     .build();
 

package/src/passkey-manager/instructions/validate.ts

@@ -1,12 +1,33 @@
 import type { ValidateInstructionParams } from '../types';
-import {
-  ValidateArgsBuilder,
-  PasskeyInstructionBuilder,
-} from '../abi/thru/program/passkey_manager/types';
+import { PasskeyInstructionBuilder } from '../abi/thru/program/passkey_manager/types';
+import { buildTargetInstructionBytes } from '../target-instruction';
+
+const U8_SIZE = Uint8Array.BYTES_PER_ELEMENT;
+const U16_SIZE = Uint16Array.BYTES_PER_ELEMENT;
+const P256_COORDINATE_SIZE = 32;
+const VALIDATE_FIXED_PREFIX_SIZE =
+  U16_SIZE +
+  U8_SIZE +
+  P256_COORDINATE_SIZE +
+  P256_COORDINATE_SIZE +
+  U16_SIZE +
+  U16_SIZE;
+
+function writeU16LE(target: Uint8Array, offset: number, value: number): void {
+  target[offset] = value & 0xff;
+  target[offset + 1] = (value >> 8) & 0xff;
+}
 
 export function encodeValidateInstruction(params: ValidateInstructionParams): Uint8Array {
-  const { walletAccountIdx, authIdx, signatureR, signatureS, authenticatorData, clientDataJSON } =
-    params;
+  const {
+    walletAccountIdx,
+    authIdx,
+    targetInstruction,
+    signatureR,
+    signatureS,
+    authenticatorData,
+    clientDataJSON,
+  } = params;
 
   if (walletAccountIdx < 0 || walletAccountIdx > 0xffff) {
     throw new Error('walletAccountIdx must be 0-65535');
@@ -14,15 +35,40 @@ export function encodeValidateInstruction(params: ValidateInstructionParams): Ui
   if (authIdx < 0 || authIdx > 0xff) throw new Error('authIdx must be 0-255');
   if (signatureR.length !== 32) throw new Error('signatureR must be 32 bytes');
   if (signatureS.length !== 32) throw new Error('signatureS must be 32 bytes');
+  if (authenticatorData.length > 0xffff) {
+    throw new Error('authenticatorData length must be 0-65535');
+  }
+  if (clientDataJSON.length > 0xffff) {
+    throw new Error('clientDataJSON length must be 0-65535');
+  }
 
-  const argsPayload = new ValidateArgsBuilder()
-    .set_wallet_account_idx(walletAccountIdx)
-    .set_auth_idx(authIdx)
-    .set_signature_r(signatureR)
-    .set_signature_s(signatureS)
-    .authenticator_data().write(authenticatorData).finish()
-    .client_data().write(clientDataJSON).finish()
-    .build();
+  const targetInstructionBytes = buildTargetInstructionBytes(targetInstruction);
+
+  const argsPayload = new Uint8Array(
+    VALIDATE_FIXED_PREFIX_SIZE +
+      authenticatorData.length +
+      clientDataJSON.length +
+      targetInstructionBytes.length
+  );
+  let offset = 0;
+
+  writeU16LE(argsPayload, offset, walletAccountIdx);
+  offset += 2;
+  argsPayload[offset] = authIdx;
+  offset += 1;
+  argsPayload.set(signatureR, offset);
+  offset += signatureR.length;
+  argsPayload.set(signatureS, offset);
+  offset += signatureS.length;
+  writeU16LE(argsPayload, offset, authenticatorData.length);
+  offset += 2;
+  writeU16LE(argsPayload, offset, clientDataJSON.length);
+  offset += 2;
+  argsPayload.set(authenticatorData, offset);
+  offset += authenticatorData.length;
+  argsPayload.set(clientDataJSON, offset);
+  offset += clientDataJSON.length;
+  argsPayload.set(targetInstructionBytes, offset);
 
   return new PasskeyInstructionBuilder()
     .payload()

package/src/passkey-manager/target-instruction.ts

@@ -0,0 +1,29 @@
+import {
+  InstructionData,
+  InstructionDataBuilder,
+} from './abi/thru/common/primitives/types';
+import type { TargetInstructionParams } from './types';
+
+export function buildTargetInstructionBytes({
+  programIdx,
+  instructionData,
+}: TargetInstructionParams): Uint8Array {
+  if (!Number.isInteger(programIdx) || programIdx < 0 || programIdx > 0xffff) {
+    throw new Error('programIdx must be 0-65535');
+  }
+  if (!(instructionData instanceof Uint8Array)) {
+    throw new Error('instructionData must be a Uint8Array');
+  }
+
+  const builder = new InstructionDataBuilder();
+  builder.set_program_idx(programIdx);
+  builder.data().write(instructionData).finish();
+
+  const buffer = builder.build();
+  const view = InstructionData.from_array(buffer);
+  if (!view) {
+    throw new Error('generated InstructionData failed validation');
+  }
+
+  return buffer;
+}

package/src/passkey-manager/types.ts

@@ -77,15 +77,31 @@ export interface TransferInstructionParams {
   amount: bigint;
 }
 
+export interface TargetInstructionParams {
+  programIdx: number;
+  instructionData: Uint8Array;
+}
+
 export interface ValidateInstructionParams {
   walletAccountIdx: number;
   authIdx: number;
+  targetInstruction: TargetInstructionParams;
   signatureR: Uint8Array;
   signatureS: Uint8Array;
   authenticatorData: Uint8Array;
   clientDataJSON: Uint8Array;
 }
 
+export interface AddAuthorityInstructionParams {
+  walletAccountIdx: number;
+  authority: Authority;
+}
+
+export interface RemoveAuthorityInstructionParams {
+  walletAccountIdx: number;
+  authIdx: number;
+}
+
 export interface AccountContext {
   readWriteAddresses: string[];
   readOnlyAddresses: string[];

package/src/passkey-manager/validate.test.ts

@@ -0,0 +1,173 @@
+import { createHash } from 'node:crypto';
+import { describe, expect, it } from 'vitest';
+import { encodeAddress } from '@thru/sdk/helpers';
+import { createValidateChallenge } from './challenge';
+import { encodeAddAuthorityInstruction } from './instructions/add-authority';
+import { encodeRemoveAuthorityInstruction } from './instructions/remove-authority';
+import { encodeValidateInstruction } from './instructions/validate';
+import {
+  MULTICALL_PROGRAM_ADDRESS,
+  MULTICALL_PROGRAM_PUBKEY,
+  buildMulticallInstruction,
+} from '../multicall';
+import {
+  InstructionData,
+  InstructionDataBuilder,
+} from './abi/thru/common/primitives/types';
+
+function bytes(value: number, len: number): Uint8Array {
+  return new Uint8Array(len).fill(value);
+}
+
+function u16le(value: number): Uint8Array {
+  return new Uint8Array([value & 0xff, (value >> 8) & 0xff]);
+}
+
+function u64le(value: bigint): Uint8Array {
+  const out = new Uint8Array(8);
+  let v = value;
+  for (let i = 0; i < 8; i++) {
+    out[i] = Number(v & 0xffn);
+    v >>= 8n;
+  }
+  return out;
+}
+
+function concat(parts: Uint8Array[]): Uint8Array {
+  const out = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+
+function buildInstructionDataFixture(
+  programIdx: number,
+  instructionData: Uint8Array
+): Uint8Array {
+  const builder = new InstructionDataBuilder();
+  builder.set_program_idx(programIdx);
+  builder.data().write(instructionData).finish();
+  return builder.build();
+}
+
+describe('passkey manager validate helpers', () => {
+  it('creates the validate challenge preimage', async () => {
+    const accountAddresses = [
+      encodeAddress(bytes(0x01, 32)),
+      encodeAddress(bytes(0x02, 32)),
+      encodeAddress(bytes(0x03, 32)),
+    ];
+    const programIdx = 9;
+    const instructionData = new Uint8Array([0xaa, 0xbb, 0xcc]);
+    const targetInstructionBytes = buildInstructionDataFixture(programIdx, instructionData);
+    const text = new TextEncoder();
+
+    const expectedPreimage = concat([
+      text.encode('thru.passkey.validate'),
+      u64le(9n),
+      u16le(4),
+      new Uint8Array([2]),
+      u16le(accountAddresses.length),
+      ...accountAddresses.map((address) => text.encode(address)),
+      targetInstructionBytes,
+    ]);
+    const expected = new Uint8Array(
+      createHash('sha256').update(expectedPreimage).digest()
+    );
+
+    await expect(
+      createValidateChallenge(
+        9n,
+        accountAddresses,
+        4,
+        2,
+        {
+          programIdx,
+          instructionData,
+        }
+      )
+    ).resolves.toEqual(expected);
+  });
+
+  it('encodes VALIDATE with a well-known InstructionData target', () => {
+    const programIdx = 0x0706;
+    const instructionData = new Uint8Array([0xaa, 0xbb]);
+    const authenticatorData = new Uint8Array([0xcc]);
+    const clientDataJSON = new Uint8Array([0xdd, 0xee]);
+
+    const encoded = encodeValidateInstruction({
+      walletAccountIdx: 0x1234,
+      authIdx: 5,
+      targetInstruction: {
+        programIdx,
+        instructionData,
+      },
+      signatureR: bytes(0x11, 32),
+      signatureS: bytes(0x22, 32),
+      authenticatorData,
+      clientDataJSON,
+    });
+
+    expect(encoded[0]).toBe(0x01);
+    expect(encoded.slice(1, 3)).toEqual(u16le(0x1234));
+    expect(encoded[3]).toBe(5);
+    expect(encoded.slice(4, 36)).toEqual(bytes(0x11, 32));
+    expect(encoded.slice(36, 68)).toEqual(bytes(0x22, 32));
+    expect(encoded.slice(68, 70)).toEqual(u16le(authenticatorData.length));
+    expect(encoded.slice(70, 72)).toEqual(u16le(clientDataJSON.length));
+    expect(encoded.slice(72, 73)).toEqual(authenticatorData);
+    expect(encoded.slice(73, 75)).toEqual(clientDataJSON);
+    const targetInstructionBytes = encoded.slice(75);
+    expect(targetInstructionBytes).toEqual(
+      buildInstructionDataFixture(programIdx, instructionData)
+    );
+    const targetInstructionView = InstructionData.from_array(targetInstructionBytes);
+    expect(targetInstructionView?.get_program_idx()).toBe(programIdx);
+    expect(targetInstructionView?.get_data()).toEqual(Array.from(instructionData));
+    expect(encoded.length).toBe(87);
+  });
+
+  it('encodes wallet indexes in add/remove authority instructions', () => {
+    const add = encodeAddAuthorityInstruction({
+      walletAccountIdx: 0x1234,
+      authority: {
+        tag: 1,
+        pubkeyX: bytes(0x01, 32),
+        pubkeyY: bytes(0x02, 32),
+      },
+    });
+    expect(add[0]).toBe(0x04);
+    expect(add.slice(1, 3)).toEqual(u16le(0x1234));
+    expect(add[3]).toBe(1);
+    expect(add.length).toBe(68);
+
+    const remove = encodeRemoveAuthorityInstruction({
+      walletAccountIdx: 0x1234,
+      authIdx: 9,
+    });
+    expect(remove).toEqual(new Uint8Array([0x05, 0x34, 0x12, 0x09]));
+  });
+
+  it('encodes multicall instructions with the known program address', () => {
+    expect(MULTICALL_PROGRAM_ADDRESS).toBe(
+      'taAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJ'
+    );
+    expect(MULTICALL_PROGRAM_PUBKEY[31]).toBe(9);
+
+    const encoded = buildMulticallInstruction([
+      { programIdx: 2, instructionData: new Uint8Array([0xaa]) },
+      { programIdx: 5, instructionData: new Uint8Array([0xbb, 0xcc]) },
+    ]);
+
+    expect(encoded).toEqual(
+      new Uint8Array([
+        0x02, 0x00,
+        0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaa,
+        0x05, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbb, 0xcc,
+      ])
+    );
+  });
+});

package/tsup.config.ts

@@ -4,6 +4,7 @@ export default defineConfig({
   entry: {
     'token/index': 'src/token/index.ts',
     'passkey-manager/index': 'src/passkey-manager/index.ts',
+    'multicall/index': 'src/multicall/index.ts',
   },
   format: ['cjs', 'esm'],
   dts: true,

package/src/passkey-manager/instructions/invoke.ts

@@ -1,25 +0,0 @@
-import {
-  InvokeArgsBuilder,
-  PasskeyInstructionBuilder,
-} from '../abi/thru/program/passkey_manager/types';
-
-export function encodeInvokeInstruction(
-  programPubkey: Uint8Array,
-  instruction: Uint8Array
-): Uint8Array {
-  if (programPubkey.length !== 32) {
-    throw new Error('Program pubkey must be 32 bytes');
-  }
-
-  const argsPayload = new InvokeArgsBuilder()
-    .set_program_pubkey(programPubkey)
-    .instr().write(instruction).finish()
-    .build();
-
-  return new PasskeyInstructionBuilder()
-    .payload()
-    .select('invoke')
-    .writePayload(argsPayload)
-    .finish()
-    .build();
-}

package/src/passkey-manager/instructions/shared.ts

@@ -1,12 +0,0 @@
-export function concatenateInstructions(instructions: Uint8Array[]): Uint8Array {
-  const totalLength = instructions.reduce((sum, instr) => sum + instr.length, 0);
-  const result = new Uint8Array(totalLength);
-
-  let offset = 0;
-  for (const instr of instructions) {
-    result.set(instr, offset);
-    offset += instr.length;
-  }
-
-  return result;
-}