@aztec/accounts 0.0.0-test.0

package/dest/utils/ssh_agent.js

@@ -0,0 +1,153 @@
+import { Buffer } from 'buffer';
+import net from 'net';
+const SSH_AGENT_IDENTITIES_REQUEST = 11;
+const SSH_AGENT_IDENTITIES_RESPONSE = 12;
+const SSH_AGENT_SIGN_REQUEST = 13;
+const SSH_AGENT_SIGN_RESPONSE = 14;
+/**
+ * Connect to the SSH agent via a TCP socket using the standard env variable
+ */ export function connectToAgent() {
+    const socketPath = process.env.SSH_AUTH_SOCK;
+    if (!socketPath) {
+        throw new Error('SSH_AUTH_SOCK is not set');
+    }
+    return net.connect(socketPath);
+}
+/**
+ * Retrieve the identities stored in the SSH agent.
+ */ export function getIdentities() {
+    return new Promise((resolve, reject)=>{
+        const stream = connectToAgent();
+        stream.on('connect', ()=>{
+            const request = Buffer.concat([
+                Buffer.from([
+                    0,
+                    0,
+                    0,
+                    5 + 4
+                ]),
+                Buffer.from([
+                    SSH_AGENT_IDENTITIES_REQUEST
+                ]),
+                Buffer.from([
+                    0,
+                    0,
+                    0,
+                    0
+                ])
+            ]);
+            stream.write(request);
+        });
+        stream.on('data', (data)=>{
+            const responseType = data[4];
+            if (responseType === SSH_AGENT_IDENTITIES_RESPONSE) {
+                let offset = 5;
+                const numKeys = data.readUInt32BE(offset);
+                offset += 4;
+                const keys = [];
+                for(let i = 0; i < numKeys; i++){
+                    const keyLength = data.readUInt32BE(offset);
+                    offset += 4;
+                    const key = data.subarray(offset, offset + keyLength);
+                    offset += keyLength;
+                    const commentLength = data.readUInt32BE(offset);
+                    offset += 4;
+                    const comment = data.subarray(offset, offset + commentLength);
+                    offset += commentLength;
+                    let keyOffset = 0;
+                    const typeLen = key.readUInt32BE(keyOffset);
+                    keyOffset += 4;
+                    const type = key.subarray(keyOffset, keyOffset + typeLen);
+                    keys.push({
+                        type: type.toString('ascii'),
+                        publicKey: key.toString('base64'),
+                        comment: comment.toString('utf8')
+                    });
+                }
+                stream.end();
+                resolve(keys);
+            } else {
+                stream.end();
+                reject(`Unexpected response type: ${responseType}`);
+            }
+        });
+    });
+}
+/**
+ * Sign data using a key stored in the SSH agent. The private signing key is identified by its corresponding public key.
+ */ export function signWithAgent(keyType, curveName, publicKey, data) {
+    return new Promise((resolve, reject)=>{
+        const stream = connectToAgent();
+        stream.on('connect', ()=>{
+            // Construct the key blob
+            const keyBlob = Buffer.concat([
+                Buffer.from([
+                    0,
+                    0,
+                    0,
+                    keyType.length
+                ]),
+                keyType,
+                Buffer.from([
+                    0,
+                    0,
+                    0,
+                    curveName.length
+                ]),
+                curveName,
+                Buffer.from([
+                    0,
+                    0,
+                    0,
+                    publicKey.length + 1,
+                    4
+                ]),
+                publicKey
+            ]);
+            const request = Buffer.concat([
+                Buffer.from([
+                    0,
+                    0,
+                    0,
+                    5 + keyBlob.length + 4 + data.length + 4
+                ]),
+                Buffer.from([
+                    SSH_AGENT_SIGN_REQUEST
+                ]),
+                Buffer.from([
+                    0,
+                    0,
+                    0,
+                    keyBlob.length
+                ]),
+                keyBlob,
+                Buffer.from([
+                    0,
+                    0,
+                    0,
+                    data.length
+                ]),
+                data,
+                Buffer.from([
+                    0,
+                    0,
+                    0,
+                    0
+                ])
+            ]);
+            stream.write(request);
+        });
+        stream.on('data', (data)=>{
+            const type = data[4];
+            if (type === SSH_AGENT_SIGN_RESPONSE) {
+                const signatureLength = data.readUInt32BE(5);
+                const signature = data.subarray(9, 9 + signatureLength);
+                stream.end();
+                resolve(signature);
+            } else {
+                stream.end();
+                reject(`Unexpected response type: ${type}`);
+            }
+        });
+    });
+}

package/package.json

@@ -0,0 +1,106 @@
+{
+  "name": "@aztec/accounts",
+  "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/accounts",
+  "description": "Implementation of sample account contracts for Aztec Network",
+  "version": "0.0.0-test.0",
+  "type": "module",
+  "exports": {
+    "./dapp": "./dest/dapp/index.js",
+    "./defaults": "./dest/defaults/index.js",
+    "./ecdsa": "./dest/ecdsa/index.js",
+    "./ecdsa/lazy": "./dest/ecdsa/lazy.js",
+    "./schnorr": "./dest/schnorr/index.js",
+    "./schnorr/lazy": "./dest/schnorr/lazy.js",
+    "./single_key": "./dest/single_key/index.js",
+    "./single_key/lazy": "./dest/single_key/lazy.js",
+    "./testing": "./dest/testing/index.js",
+    "./testing/lazy": "./dest/testing/lazy.js",
+    "./utils": "./dest/utils/index.js"
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/defaults/index.ts",
+      "./src/ecdsa/index.ts",
+      "./src/schnorr/index.ts",
+      "./src/single_key/index.ts",
+      "./src/testing/index.ts"
+    ],
+    "name": "Accounts",
+    "tsconfig": "./tsconfig.json"
+  },
+  "scripts": {
+    "build": "yarn clean && yarn generate && tsc -b",
+    "generate": "yarn generate:noir-contracts",
+    "generate:noir-contracts": "./scripts/copy-contracts.sh",
+    "build:dev": "tsc -b --watch",
+    "build:ts": "tsc -b",
+    "clean": "rm -rf ./dest .tsbuildinfo ./artifacts",
+    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
+    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
+  },
+  "inherits": [
+    "../package.common.json",
+    "./package.local.json"
+  ],
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec/aztec.js": "0.0.0-test.0",
+    "@aztec/entrypoints": "0.0.0-test.0",
+    "@aztec/ethereum": "0.0.0-test.0",
+    "@aztec/foundation": "0.0.0-test.0",
+    "@aztec/stdlib": "0.0.0-test.0",
+    "tslib": "^2.4.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.5.0",
+    "@types/jest": "^29.5.0",
+    "@types/node": "^18.7.23",
+    "jest": "^29.5.0",
+    "jest-mock-extended": "^3.0.3",
+    "ts-loader": "^9.4.4",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*",
+    "artifacts"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/dapp/dapp_interface.ts

@@ -0,0 +1,38 @@
+import {
+  type AccountWallet,
+  type AuthWitnessProvider,
+  AztecAddress,
+  CompleteAddress,
+  type NodeInfo,
+} from '@aztec/aztec.js';
+import { DefaultDappEntrypoint } from '@aztec/entrypoints/dapp';
+
+import { DefaultAccountInterface } from '../defaults/account_interface.js';
+
+/**
+ * Default implementation for an account interface that uses a dapp entrypoint.
+ */
+export class DefaultDappInterface extends DefaultAccountInterface {
+  constructor(
+    authWitnessProvider: AuthWitnessProvider,
+    userAddress: CompleteAddress,
+    dappAddress: AztecAddress,
+    nodeInfo: Pick<NodeInfo, 'l1ChainId' | 'protocolVersion'>,
+  ) {
+    super(authWitnessProvider, userAddress, nodeInfo);
+    this.entrypoint = new DefaultDappEntrypoint(
+      userAddress.address,
+      authWitnessProvider,
+      dappAddress,
+      nodeInfo.l1ChainId,
+      nodeInfo.protocolVersion,
+    );
+  }
+
+  static createFromUserWallet(wallet: AccountWallet, dappAddress: AztecAddress): DefaultDappInterface {
+    return new DefaultDappInterface(wallet, wallet.getCompleteAddress(), dappAddress, {
+      l1ChainId: wallet.getChainId().toNumber(),
+      protocolVersion: wallet.getVersion().toNumber(),
+    });
+  }
+}

package/src/dapp/index.ts

@@ -0,0 +1 @@
+export * from './dapp_interface.js';

package/src/defaults/account_contract.ts

@@ -0,0 +1,21 @@
+import type { AccountContract, AccountInterface, AuthWitnessProvider } from '@aztec/aztec.js/account';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import type { CompleteAddress, NodeInfo } from '@aztec/stdlib/contract';
+
+import { DefaultAccountInterface } from '../defaults/account_interface.js';
+
+/**
+ * Base class for implementing an account contract. Requires that the account uses the
+ * default entrypoint method signature.
+ */
+export abstract class DefaultAccountContract implements AccountContract {
+  abstract getAuthWitnessProvider(address: CompleteAddress): AuthWitnessProvider;
+  abstract getDeploymentArgs(): Promise<any[] | undefined>;
+  abstract getContractArtifact(): Promise<ContractArtifact>;
+
+  constructor() {}
+
+  getInterface(address: CompleteAddress, nodeInfo: NodeInfo): AccountInterface {
+    return new DefaultAccountInterface(this.getAuthWitnessProvider(address), address, nodeInfo);
+  }
+}

package/src/defaults/account_interface.ts

@@ -0,0 +1,59 @@
+import type { AccountInterface, AuthWitnessProvider } from '@aztec/aztec.js/account';
+import type { EntrypointInterface, ExecutionRequestInit } from '@aztec/aztec.js/entrypoint';
+import { DefaultAccountEntrypoint } from '@aztec/entrypoints/account';
+import { Fr } from '@aztec/foundation/fields';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { CompleteAddress } from '@aztec/stdlib/contract';
+import type { NodeInfo } from '@aztec/stdlib/contract';
+import type { TxExecutionRequest } from '@aztec/stdlib/tx';
+
+/**
+ * Default implementation for an account interface. Requires that the account uses the default
+ * entrypoint signature, which accept an AppPayload and a FeePayload as defined in noir-libs/aztec-noir/src/entrypoint module
+ */
+export class DefaultAccountInterface implements AccountInterface {
+  protected entrypoint: EntrypointInterface;
+
+  private chainId: Fr;
+  private version: Fr;
+
+  constructor(
+    private authWitnessProvider: AuthWitnessProvider,
+    private address: CompleteAddress,
+    nodeInfo: Pick<NodeInfo, 'l1ChainId' | 'protocolVersion'>,
+  ) {
+    this.entrypoint = new DefaultAccountEntrypoint(
+      address.address,
+      authWitnessProvider,
+      nodeInfo.l1ChainId,
+      nodeInfo.protocolVersion,
+    );
+    this.chainId = new Fr(nodeInfo.l1ChainId);
+    this.version = new Fr(nodeInfo.protocolVersion);
+  }
+
+  createTxExecutionRequest(execution: ExecutionRequestInit): Promise<TxExecutionRequest> {
+    return this.entrypoint.createTxExecutionRequest(execution);
+  }
+
+  createAuthWit(messageHash: Fr): Promise<AuthWitness> {
+    return this.authWitnessProvider.createAuthWit(messageHash);
+  }
+
+  getCompleteAddress(): CompleteAddress {
+    return this.address;
+  }
+
+  getAddress(): AztecAddress {
+    return this.address.address;
+  }
+
+  getChainId(): Fr {
+    return this.chainId;
+  }
+
+  getVersion(): Fr {
+    return this.version;
+  }
+}

package/src/defaults/index.ts

@@ -0,0 +1,10 @@
+/**
+ * The `@aztec/accounts/defaults` export provides the base class {@link DefaultAccountContract} for implementing account contracts that use the default entrypoint payload module.
+ *
+ * Read more in {@link https://docs.aztec.network/developers/tutorials/codealong/contract_tutorials/write_accounts_contract | Writing an account contract}.
+ *
+ * @packageDocumentation
+ */
+
+export * from './account_interface.js';
+export * from './account_contract.js';

package/src/ecdsa/ecdsa_k/account_contract.ts

@@ -0,0 +1,39 @@
+import type { AuthWitnessProvider } from '@aztec/aztec.js/account';
+import { Ecdsa } from '@aztec/foundation/crypto';
+import type { Fr } from '@aztec/foundation/fields';
+import { AuthWitness } from '@aztec/stdlib/auth-witness';
+import { CompleteAddress } from '@aztec/stdlib/contract';
+
+import { DefaultAccountContract } from '../../defaults/account_contract.js';
+
+/**
+ * Account contract that authenticates transactions using ECDSA signatures
+ * verified against a secp256k1 public key stored in an immutable encrypted note.
+ * This abstract version does not provide a way to retrieve the artifact, as it
+ * can be implemented with or without lazy loading.
+ */
+export abstract class EcdsaKBaseAccountContract extends DefaultAccountContract {
+  constructor(private signingPrivateKey: Buffer) {
+    super();
+  }
+
+  async getDeploymentArgs() {
+    const signingPublicKey = await new Ecdsa().computePublicKey(this.signingPrivateKey);
+    return [signingPublicKey.subarray(0, 32), signingPublicKey.subarray(32, 64)];
+  }
+
+  getAuthWitnessProvider(_address: CompleteAddress): AuthWitnessProvider {
+    return new EcdsaKAuthWitnessProvider(this.signingPrivateKey);
+  }
+}
+
+/** Creates auth witnesses using ECDSA signatures. */
+class EcdsaKAuthWitnessProvider implements AuthWitnessProvider {
+  constructor(private signingPrivateKey: Buffer) {}
+
+  async createAuthWit(messageHash: Fr): Promise<AuthWitness> {
+    const ecdsa = new Ecdsa();
+    const signature = await ecdsa.constructSignature(messageHash.toBuffer(), this.signingPrivateKey);
+    return Promise.resolve(new AuthWitness(messageHash, [...signature.r, ...signature.s]));
+  }
+}

package/src/ecdsa/ecdsa_k/index.ts

@@ -0,0 +1,63 @@
+/**
+ * The `@aztec/accounts/ecdsa` export provides an ECDSA account contract implementation, that uses an ECDSA private key for authentication, and a Grumpkin key for encryption.
+ * Consider using this account type when working with integrations with Ethereum wallets.
+ *
+ * @packageDocumentation
+ */
+import { AccountManager, type Salt } from '@aztec/aztec.js/account';
+import { type AccountWallet, getWallet } from '@aztec/aztec.js/wallet';
+import { Fr } from '@aztec/foundation/fields';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
+
+import EcdsaKAccountContractJson from '../../../artifacts/EcdsaKAccount.json' assert { type: 'json' };
+import { EcdsaKBaseAccountContract } from './account_contract.js';
+
+export const EcdsaKAccountContractArtifact: ContractArtifact = loadContractArtifact(
+  EcdsaKAccountContractJson as NoirCompiledContract,
+);
+
+/**
+ * Account contract that authenticates transactions using ECDSA signatures
+ * verified against a secp256k1 public key stored in an immutable encrypted note.
+ * Eagerly loads the contract artifact
+ */
+export class EcdsaKAccountContract extends EcdsaKBaseAccountContract {
+  constructor(signingPrivateKey: Buffer) {
+    super(signingPrivateKey);
+  }
+
+  override getContractArtifact(): Promise<ContractArtifact> {
+    return Promise.resolve(EcdsaKAccountContractArtifact);
+  }
+}
+/**
+ * Creates an Account that relies on an ECDSA signing key for authentication.
+ * @param pxe - An PXE server instance.
+ * @param secretKey - Secret key used to derive all the keystore keys.
+ * @param signingPrivateKey - Secp256k1 key used for signing transactions.
+ * @param salt - Deployment salt.
+ * @returns An account manager initialized with the account contract and its deployment params
+ */
+export function getEcdsaKAccount(
+  pxe: PXE,
+  secretKey: Fr,
+  signingPrivateKey: Buffer,
+  salt?: Salt,
+): Promise<AccountManager> {
+  return AccountManager.create(pxe, secretKey, new EcdsaKAccountContract(signingPrivateKey), salt);
+}
+
+/**
+ * Gets a wallet for an already registered account using ECDSA signatures.
+ * @param pxe - An PXE server instance.
+ * @param address - Address for the account.
+ * @param signingPrivateKey - ECDSA key used for signing transactions.
+ * @returns A wallet for this account that can be used to interact with a contract instance.
+ */
+export function getEcdsaKWallet(pxe: PXE, address: AztecAddress, signingPrivateKey: Buffer): Promise<AccountWallet> {
+  return getWallet(pxe, address, new EcdsaKAccountContract(signingPrivateKey));
+}

package/src/ecdsa/ecdsa_k/lazy.ts

@@ -0,0 +1,71 @@
+/**
+ * The `@aztec/accounts/ecdsa` export provides an ECDSA account contract implementation, that uses an ECDSA private key for authentication, and a Grumpkin key for encryption.
+ * Consider using this account type when working with integrations with Ethereum wallets.
+ *
+ * @packageDocumentation
+ */
+import { AccountManager, type Salt } from '@aztec/aztec.js/account';
+import { type AccountWallet, getWallet } from '@aztec/aztec.js/wallet';
+import { Fr } from '@aztec/foundation/fields';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+
+import { EcdsaKBaseAccountContract } from './account_contract.js';
+
+/**
+ * Lazily loads the contract artifact
+ * @returns The contract artifact for the ecdsa K account contract
+ */
+export async function getEcdsaKAccountContractArtifact() {
+  // Cannot assert this import as it's incompatible with browsers
+  // https://caniuse.com/mdn-javascript_statements_import_import_assertions_type_json
+  // Use the new "with" syntax once supported by firefox
+  // https://caniuse.com/mdn-javascript_statements_import_import_attributes_type_json
+  // In the meantime, this lazy import is INCOMPATIBLE WITH NODEJS
+  const { default: ecdsaKAccountContractJson } = await import('../../../artifacts/EcdsaKAccount.json');
+  return loadContractArtifact(ecdsaKAccountContractJson);
+}
+
+/**
+ * Account contract that authenticates transactions using ECDSA signatures
+ * verified against a secp256k1 public key stored in an immutable encrypted note.
+ * Lazily loads the contract artifact
+ */
+export class EcdsaKAccountContract extends EcdsaKBaseAccountContract {
+  constructor(signingPrivateKey: Buffer) {
+    super(signingPrivateKey);
+  }
+
+  override getContractArtifact(): Promise<ContractArtifact> {
+    return getEcdsaKAccountContractArtifact();
+  }
+}
+/**
+ * Creates an Account that relies on an ECDSA signing key for authentication.
+ * @param pxe - An PXE server instance.
+ * @param secretKey - Secret key used to derive all the keystore keys.
+ * @param signingPrivateKey - Secp256k1 key used for signing transactions.
+ * @param salt - Deployment salt.
+ * @returns An account manager initialized with the account contract and its deployment params
+ */
+export function getEcdsaKAccount(
+  pxe: PXE,
+  secretKey: Fr,
+  signingPrivateKey: Buffer,
+  salt?: Salt,
+): Promise<AccountManager> {
+  return AccountManager.create(pxe, secretKey, new EcdsaKAccountContract(signingPrivateKey), salt);
+}
+
+/**
+ * Gets a wallet for an already registered account using ECDSA signatures.
+ * @param pxe - An PXE server instance.
+ * @param address - Address for the account.
+ * @param signingPrivateKey - ECDSA key used for signing transactions.
+ * @returns A wallet for this account that can be used to interact with a contract instance.
+ */
+export function getEcdsaKWallet(pxe: PXE, address: AztecAddress, signingPrivateKey: Buffer): Promise<AccountWallet> {
+  return getWallet(pxe, address, new EcdsaKAccountContract(signingPrivateKey));
+}

package/src/ecdsa/index.ts

@@ -0,0 +1,2 @@
+export * from './ecdsa_k/index.js';
+export * from './ssh_ecdsa_r/index.js';

package/src/ecdsa/lazy.ts

@@ -0,0 +1,2 @@
+export * from './ecdsa_k/lazy.js';
+export * from './ssh_ecdsa_r/lazy.js';

package/src/ecdsa/ssh_ecdsa_r/account_contract.ts

@@ -0,0 +1,89 @@
+import type { AuthWitnessProvider } from '@aztec/aztec.js/account';
+import { EcdsaSignature } from '@aztec/foundation/crypto';
+import type { Fr } from '@aztec/foundation/fields';
+import { AuthWitness } from '@aztec/stdlib/auth-witness';
+import { CompleteAddress } from '@aztec/stdlib/contract';
+
+import { DefaultAccountContract } from '../../defaults/account_contract.js';
+import { signWithAgent } from '../../utils/ssh_agent.js';
+
+const secp256r1N = 115792089210356248762697446949407573529996955224135760342422259061068512044369n;
+/**
+ * Account contract that authenticates transactions using ECDSA signatures
+ * verified against a secp256r1 public key stored in an immutable encrypted note.
+ * Since this implementation relays signatures to an SSH agent, we provide the
+ * public key here not for signature verification, but to identify actual identity
+ * that will be used to sign authwitnesses.
+ * This abstract version does not provide a way to retrieve the artifact, as it
+ * can be implemented with or without lazy loading.
+ */
+export abstract class EcdsaRSSHBaseAccountContract extends DefaultAccountContract {
+  constructor(private signingPublicKey: Buffer) {
+    super();
+  }
+
+  getDeploymentArgs() {
+    return Promise.resolve([this.signingPublicKey.subarray(0, 32), this.signingPublicKey.subarray(32, 64)]);
+  }
+
+  getAuthWitnessProvider(_address: CompleteAddress): AuthWitnessProvider {
+    return new SSHEcdsaRAuthWitnessProvider(this.signingPublicKey);
+  }
+}
+
+/** Creates auth witnesses using ECDSA signatures. */
+class SSHEcdsaRAuthWitnessProvider implements AuthWitnessProvider {
+  constructor(private signingPublicKey: Buffer) {}
+
+  #parseECDSASignature(data: Buffer) {
+    // Extract ECDSA signature components
+    let offset = 0;
+    const sigTypeLen = data.readUInt32BE(offset);
+    offset += 4;
+    const sigType = data.subarray(offset, offset + sigTypeLen).toString();
+    offset += sigTypeLen;
+
+    if (sigType !== 'ecdsa-sha2-nistp256') {
+      throw new Error(`Unexpected signature type: ${sigType}`);
+    }
+
+    offset += 4;
+    const rLen = data.readUInt32BE(offset);
+    offset += 4;
+    let r = data.subarray(offset, offset + rLen);
+    offset += rLen;
+
+    const sLen = data.readUInt32BE(offset);
+    offset += 4;
+    let s = data.subarray(offset, offset + sLen);
+
+    // R and S are encoded using ASN.1 DER format, which may include a leading zero byte to avoid interpreting the value as negative
+    if (r.length > 32) {
+      r = Buffer.from(Uint8Array.prototype.slice.call(r, 1));
+    }
+
+    if (s.length > 32) {
+      s = Buffer.from(Uint8Array.prototype.slice.call(s, 1));
+    }
+
+    const maybeHighS = BigInt(`0x${s.toString('hex')}`);
+
+    // ECDSA signatures must have a low S value so they can be used as a nullifier. BB forces a value of 27 for v, so
+    // only one PublicKey can verify the signature (and not its negated counterpart) https://ethereum.stackexchange.com/a/55728
+    if (maybeHighS > secp256r1N / 2n + 1n) {
+      s = Buffer.from((secp256r1N - maybeHighS).toString(16), 'hex');
+    }
+
+    return new EcdsaSignature(r, s, Buffer.from([0]));
+  }
+
+  async createAuthWit(messageHash: Fr): Promise<AuthWitness> {
+    // Key type and curve name
+    const keyType = Buffer.from('ecdsa-sha2-nistp256');
+    const curveName = Buffer.from('nistp256');
+    const data = await signWithAgent(keyType, curveName, this.signingPublicKey, messageHash.toBuffer());
+    const signature = this.#parseECDSASignature(data);
+
+    return new AuthWitness(messageHash, [...signature.r, ...signature.s]);
+  }
+}