@docknetwork/wallet-sdk-wasm 1.4.0 → 1.5.6

package/src/services/dids/index.test.js

@@ -1,12 +1,10 @@
-import {assertRpcService, getPromiseError} from '../test-utils';
+import {assertRpcService} from '../test-utils';
 import {DIDServiceRPC} from './service-rpc';
 import {didService as service} from './service';
 import {validation} from './config';
 import {DIDKeyManager} from '@docknetwork/wallet-sdk-dids/src';
-import {TestFixtures} from '../../fixtures';
 import {getTestWallet} from '../../test/setup-test-state';
-import {dockService, getDock} from '../dock/service';
-import {DockDid} from '@docknetwork/credential-sdk/types';
+import {blockchainService} from '../blockchain/service';
 
 describe('DID Service', () => {
   beforeAll(async () => {
@@ -99,50 +97,11 @@ describe('DID Service', () => {
     spy.mockReset();
   });
 
-  it('expect to register did dock', async () => {
-    dockService.modules = {
-      did: {
-        dockOnly: {
-          rawTx: {
-            newOnchain: jest.fn(),
-          },
-        },
-      },
-    };
-
-    jest.spyOn(DockDid, 'fromQualifiedString').mockReturnValueOnce('');
-
-    const result = await service.registerDidDock(
-      TestFixtures.account1.getKeyring().toJson(''),
-    );
-    expect(result.dockDID).toBeDefined();
-    expect(result.keyPairWalletId).toBeDefined();
-  });
-
-  it('expect to fail to register did dock', async () => {
-    dockService.modules = {
-      did: {
-        dockOnly: {
-          rawTx: {
-            newOnchain: () => {
-              throw new Error('');
-            },
-          },
-        },
-      },
-    };
-
-    const error = await getPromiseError(() =>
-      service.registerDidDock(
-        TestFixtures.noBalanceAccount.getKeyring().toJson(''),
-      ),
-    );
-    expect(error.message).toBeDefined();
-  });
-
   it('expect to get did document', async () => {
     const document = 'document';
-    jest.spyOn(getDock().did, 'getDocument').mockResolvedValue(document);
+    jest
+      .spyOn(blockchainService.didModule, 'getDocument')
+      .mockResolvedValue(document);
 
     const result = await service.getDidDockDocument(
       'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi',

package/src/services/dids/service-rpc.ts

@@ -18,8 +18,8 @@ export class DIDServiceRPC extends RpcService {
   generateKeyDoc(params) {
     return this.call('generateKeyDoc', params);
   }
-  registerDidDock(keyPair) {
-    return this.call('registerDidDock', keyPair);
+  deriveKeyDoc(params) {
+    return this.call('deriveKeyDoc', params);
   }
   getDidDockDocument(did) {
     return this.call('getDidDockDocument', did);

package/src/services/dids/service.ts

@@ -9,7 +9,7 @@ import {
 import {keyringService} from '../keyring/service';
 import {utilCryptoService} from '../util-crypto/service';
 import assert from 'assert';
-import {dockService, getDock} from '../dock/service';
+import {blockchainService, getDock} from '../blockchain/service';
 
 import {
   DidKey,
@@ -28,27 +28,9 @@ import {
   EcdsaSecp256k1Signature2019,
 } from '@docknetwork/credential-sdk/vc/crypto';
 
-async function createDockDID({keyPair}) {
-  const dockDID = DockDid.random();
-  const dockController = dockDID.toString();
-  const publicKey = keyPair.publicKey();
-  const verRels = new VerificationRelationship();
-  const didKey = new DidKey(publicKey, verRels);
-
-  await dockService.modules.did.dockOnly.rawTx.newOnchain(
-    dockDID.did,
-    [didKey],
-    dockController === dockDID.toString()
-      ? []
-      : [DockDid.fromQualifiedString(dockController)],
-  );
-
-  return {did: dockDID.toString(), controller: dockController};
-}
-
 async function getSignerKeypair(privateKeyDoc) {
   const privateKey =
-    privateKeyDoc.keypair || keyDocToKeypair(privateKeyDoc, dockService.dock);
+    privateKeyDoc.keypair || keyDocToKeypair(privateKeyDoc, blockchainService.dock);
 
   if (!privateKey.signer && privateKey.sign) {
     privateKey.signer = () => ({sign: ({data}) => privateKey.sign(data)});
@@ -84,7 +66,7 @@ class DIDService {
     DIDService.prototype.keypairToDIDKeyDocument,
     DIDService.prototype.getDIDResolution,
     DIDService.prototype.generateKeyDoc,
-    DIDService.prototype.registerDidDock,
+    DIDService.prototype.deriveKeyDoc,
     DIDService.prototype.getDidDockDocument,
     DIDService.prototype.createSignedJWT,
   ];
@@ -120,6 +102,18 @@ class DIDService {
     return polkadotToKeydoc(keyring, params.controller);
   }
 
+  async deriveKeyDoc(params) {
+    validation.deriveKeyDoc(params);
+    const { pair, type = 'ed25519' } = params;
+
+    const keyring = keyringService.createFromPair({
+      pair,
+      type,
+    });
+
+    return polkadotToKeydoc(keyring, params.controller);
+  }
+
   async createSignedJWT({payload, privateKeyDoc, headerInput}) {
     const privateKey = await getSignerKeypair(privateKeyDoc);
     const {sign} =
@@ -142,21 +136,10 @@ class DIDService {
 
   async getDidDockDocument(did) {
     assert(!!did, 'DID is required');
-    const dock = getDock();
-    const result = await dock.did.getDocument(did);
+    const dock = blockchainService.dock;
+    const result = await blockchainService.didModule.getDocument(did);
     return result;
   }
-
-  async registerDidDock(keyPairJSON) {
-    assert(!!keyPairJSON, 'keyPair is required');
-    const keyPair = Ed25519Keypair.random();
-    const dockDID = await createDockDID({keyPair});
-
-    return {
-      dockDID,
-      keyPairWalletId: keyPairJSON.address,
-    };
-  }
 }
 
 export const didService = new DIDService();

package/src/services/edv/hmac.ts

@@ -1,5 +1,6 @@
 import * as base64url from 'base64url-universal';
 import crypto from '@docknetwork/universal-wallet/crypto';
+import {hexToU8a} from '@polkadot/util';
 
 export default class HMAC {
   key: CryptoKey;
@@ -37,6 +38,18 @@ export default class HMAC {
     return key;
   }
 
+  static async deriveKey(baseKey: string) {
+    const key = await crypto.subtle.importKey(
+      'raw',
+      hexToU8a(baseKey),
+      {name: 'HMAC', hash: {name: 'SHA-256'}},
+      true,
+      ['sign', 'verify'],
+    );
+
+    return key;
+  }
+
   static async exportKey(key: CryptoKey) {
     const rawKey = await crypto.subtle.exportKey('raw', key);
     return base64url.encode(Buffer.from(rawKey));

package/src/services/edv/index.test.js

@@ -20,5 +20,27 @@ describe('EDVService', () => {
         expect(keys.verificationKey).toBeDefined();
       });
     });
+
+    describe('deriveKeys', () => {
+      it('should derive EDV keys', async () => {
+        const testMasterKey = '0O+9vxwb3Zo/9AVcQfVeQ59wvgcYUVH/mTye6islspM=';
+        const derivedTestAgreementKey =
+          '{"id":"did:key:z6Mkt1paLGw6VqRCTmqjpbiP9fxLVHJb8k97zERL6TcWr9Ru#z6LSojEubzYtAGCBE7Mwwks7J3Gttsrd1c9EXcDuNjthwVQj","controller":"did:key:z6Mkt1paLGw6VqRCTmqjpbiP9fxLVHJb8k97zERL6TcWr9Ru","type":"X25519KeyAgreementKey2020","publicKeyMultibase":"z6LSojEubzYtAGCBE7Mwwks7J3Gttsrd1c9EXcDuNjthwVQj","privateKeyMultibase":"z3weoV5H5DppQ7pjABoopaiDFN6zH3SokESte2Jte87YNXgg"}';
+        const derivedTestHmacKey = 'AAkACzAAmgwPDgWQAMAAAAAOYAAAAA';
+        const derivedTestVerificationKey =
+          '{"id":"did:key:z6Mkt1paLGw6VqRCTmqjpbiP9fxLVHJb8k97zERL6TcWr9Ru#z6Mkt1paLGw6VqRCTmqjpbiP9fxLVHJb8k97zERL6TcWr9Ru","controller":"did:key:z6Mkt1paLGw6VqRCTmqjpbiP9fxLVHJb8k97zERL6TcWr9Ru","type":"Ed25519VerificationKey2018","publicKeyBase58":"EZZXk2gfAHvjMH1392kYJaQLfi2jirtmJDWQGBeVvveX","privateKeyBase58":"5BHUEjDDbDzQKnveM9qXXXmRqwTtmBvumTY2xZXN61x8dvZHgzsDaTpkVqkE4LSoMLcV6yDRhxcv7mMTzdaJ21pX"}';
+        const {agreementKey, hmacKey, verificationKey} =
+          await service.deriveKeys(testMasterKey);
+
+        expect(hmacKey).toBeDefined();
+        expect(hmacKey).toBe(derivedTestHmacKey);
+        expect(verificationKey).toBeDefined();
+        expect(JSON.stringify(verificationKey)).toBe(
+          derivedTestVerificationKey,
+        );
+        expect(agreementKey).toBeDefined();
+        expect(JSON.stringify(agreementKey)).toBe(derivedTestAgreementKey);
+      });
+    });
   });
 });

package/src/services/edv/service-rpc.js

@@ -15,6 +15,10 @@ export class EDVServiceRpc extends RpcService {
     return this.call('generateKeys');
   }
 
+  deriveKeys() {
+    return this.call('deriveKeys');
+  }
+
   find(params: any) {
     return this.call('find', params);
   }

package/src/services/edv/service.ts

@@ -3,11 +3,14 @@ import {InitializeEDVParams, serviceName} from './configs';
 import EDVHTTPStorageInterface from '@docknetwork/universal-wallet/storage/edv-http-storage';
 import HMAC from './hmac';
 import {Ed25519VerificationKey2018} from '@digitalbazaar/ed25519-verification-key-2018';
+import {Ed25519VerificationKey2020} from '@digitalbazaar/ed25519-verification-key-2020';
 import {X25519KeyAgreementKey2020} from '@digitalbazaar/x25519-key-agreement-key-2020';
 import {getKeypairFromDoc} from '@docknetwork/universal-wallet/methods/keypairs';
 import {logger} from '@docknetwork/wallet-sdk-data-store/src/logger';
 import {didService} from '@docknetwork/wallet-sdk-wasm/src/services/dids/service';
 import {keyringService} from '@docknetwork/wallet-sdk-wasm/src/services/keyring';
+import {ed25519PairFromSeed} from '@polkadot/util-crypto';
+import base64url from 'base64url-universal';
 
 /**
  * EDVService
@@ -19,6 +22,7 @@ export class EDVService {
 
   rpcMethods = [
     EDVService.prototype.generateKeys,
+    EDVService.prototype.deriveKeys,
     EDVService.prototype.initialize,
     EDVService.prototype.find,
     EDVService.prototype.update,
@@ -109,6 +113,24 @@ export class EDVService {
     return {verificationKey, agreementKey, hmacKey};
   }
 
+  async deriveKeys(masterKey: any) {
+    await keyringService.initialize({
+      ss58Format: 22,
+    });
+    const pair = ed25519PairFromSeed(base64url.decode(masterKey));
+
+    const keyPair = await didService.deriveKeyDoc({ pair });
+
+    const verificationKey = await Ed25519VerificationKey2018.from(keyPair);
+
+    const verificationKey2020 = await Ed25519VerificationKey2020.fromEd25519VerificationKey2018({ keyPair });
+    const agreementKey = await X25519KeyAgreementKey2020.fromEd25519VerificationKey2020({ keyPair: verificationKey2020 });
+
+    const hmacKey = await HMAC.exportKey(await HMAC.deriveKey(masterKey));
+
+    return { verificationKey, agreementKey, hmacKey };
+  }
+
   find(params: any) {
     return this.storageInterface.find(params);
   }

package/src/services/example/service.ts

@@ -4,7 +4,9 @@ import {SumParams, validation} from './configs';
 export class ExampleService {
   rpcMethods = [ExampleService.prototype.sum];
 
-  constructor() {}
+  constructor() {
+    this.name = 'example';
+  }
 
   sum(params: SumParams) {
     validation.sum(params);

package/src/services/index.js

@@ -1,5 +1,5 @@
 import {keyringService} from './keyring/service';
-import {dockService} from './dock/service';
+import {blockchainService} from './blockchain/service';
 import {substrateService} from './substrate/service';
 import {walletService} from './wallet/service';
 import {polkadotService} from './polkadot/service';
@@ -14,7 +14,7 @@ import {edvService} from './edv/service';
 
 export default [
   keyringService,
-  dockService,
+  blockchainService,
   substrateService,
   walletService,
   polkadotService,

package/src/services/keyring/configs.ts

@@ -47,6 +47,21 @@ export const validation = {
       assert(typeof meta === 'object', 'invalid meta');
     }
   },
+  createFromPair(params: CreateFromPairParams) {
+    const {pair, meta, type} = params;
+
+    assert(typeof pair === 'object', 'invalid pair');
+    assert(pair.publicKey instanceof Uint8Array, 'invalid publicKey');
+    assert(pair.secretKey instanceof Uint8Array, 'invalid secretKey');
+
+    if (type) {
+      assertKeyType(type);
+    }
+
+    if (meta) {
+      assert(typeof meta === 'object', 'invalid meta');
+    }
+  },
 
   signData(params: SignDataParams) {
     assert(!!params.keyPair, 'invalid keypair');
@@ -65,6 +80,12 @@ export type GetKeyringParams = {
   derivePath?: string,
 };
 
+export type CreateFromPairParams = {
+  pair: any,
+  meta?: any,
+  type?: string,
+}
+
 export type AddressFromUriParams = GetKeyringParams;
 
 export type AddFromJsonParams = {

package/src/services/keyring/service.ts

@@ -5,6 +5,7 @@ import {
   AddFromJsonParams,
   AddFromMnemonicParams,
   CreateFromUriParams,
+  CreateFromPairParams,
   InitializeParams,
   serviceName,
   validation,
@@ -86,6 +87,18 @@ export class KeyringService {
     );
   }
 
+  createFromPair(params: CreateFromPairParams): KeyringPair {
+    validation.createFromPair(params);
+
+    const {pair, meta, type} = params;
+
+    return this.keyring.createFromPair(
+      pair,
+      meta,
+      type,
+    );
+  }
+
   getKeyringPairJSON(params: CreateFromUriParams): KeyringPair {
     return this.getKeyringPair(params).toJson();
   }

package/src/services/pex/service.ts

@@ -18,30 +18,41 @@ const pex: PEX = new PEX();
  * This is a temporary workaround until the issue is fixed in the @sphereon/pex library
  **/
 export function removeOptionalAttribute(presentationDefinition) {
-  presentationDefinition.input_descriptors.forEach(inputDescriptor => {
+  // Deep clone the presentationDefinition to avoid mutating the original
+  const clonedPresentationDefinition = JSON.parse(
+    JSON.stringify(presentationDefinition),
+  );
+
+  clonedPresentationDefinition.input_descriptors.forEach(inputDescriptor => {
     if (!inputDescriptor.constraints?.fields?.length) {
       return;
     }
+
     // Filter the optional fields
-    // If we include those fields, it might exclude few credentials from the resulsts
-    // e.g: Expiration date as optional, a credenntial without expiration date should be included
     inputDescriptor.constraints.fields =
       inputDescriptor.constraints.fields.filter(
         field => field.optional !== true,
       );
 
-    // Removes the optinal attributes from the fields
-    // It applies in case optional: false
-    // The field is required, but pex doesn't support the attribute
-    inputDescriptor.constraints.fields.forEach(field => {
-      if (field.optional !== undefined) {
-        delete field.optional;
-      }
-    });
-
-    // There is a case where ALL fields are optional
-    // If we remove all fields, it will cause an error with PEX
-    // So, we add a placeholder field to avoid the error
+    inputDescriptor.constraints.fields = inputDescriptor.constraints.fields.map(
+      field => {
+        const updatedField = {...field};
+
+        // Remove the optional attribute if it exists
+        if (updatedField.optional !== undefined) {
+          delete updatedField.optional;
+        }
+
+        // Remove the did format attribute if it exists
+        if (updatedField.filter?.format === 'did') {
+          delete updatedField.filter.format;
+        }
+
+        return updatedField;
+      },
+    );
+
+    // Handle case where all fields are optional
     if (inputDescriptor.constraints.fields.length === 0) {
       inputDescriptor.constraints.fields.push({
         path: ['$.id'],
@@ -49,11 +60,11 @@ export function removeOptionalAttribute(presentationDefinition) {
     }
   });
 
-  if (!presentationDefinition.id) {
-    presentationDefinition.id = 'id';
+  if (!clonedPresentationDefinition.id) {
+    clonedPresentationDefinition.id = 'id';
   }
 
-  return presentationDefinition;
+  return clonedPresentationDefinition;
 }
 
 class PEXService {

package/src/services/pex/tests/pex-service.test.js

@@ -371,6 +371,114 @@ describe('Pex Examples', () => {
     expect(results.verifiableCredential).toBeTruthy();
   });
 
+  it('should handle DID format filter', () => {
+    const presentationDefinition = {
+      id: 'df3d2615-7955-4f9d-b2df-ef5c6202bdaf',
+      input_descriptors: [
+        {
+          id: 'Credential 1',
+          name: 'Validate Test Credential',
+          purpose: 'verify Test credential',
+          constraints: {
+            fields: [
+              {
+                path: [
+                  '$.issuer.id',
+                  '$.issuer',
+                  '$.vc.issuer.id',
+                  '$.vc.issuer',
+                  '$.iss',
+                ],
+                filter: {
+                  const:
+                    'did:dock:5HPb8aoNXNQv5XxbupZRorHyc7CdBUYWFFxeczHxqVgeGPjT',
+                  format: 'did',
+                },
+                optional: false,
+                predicate: 'required',
+              },
+            ],
+          },
+        },
+      ],
+    };
+
+    const credentials = [
+      {
+        '@context': [
+          'https://www.w3.org/2018/credentials/v1',
+          'https://ld.dock.io/credentials/extensions-v1',
+          'https://ld.dock.io/security/bbs23/v1',
+          {
+            age: 'dk:age',
+            dk: 'https://ld.dock.io/credentials#',
+            grade: 'dk:grade',
+            graduated: 'dk:graduated',
+          },
+        ],
+        credentialStatus: {
+          id: 'dock:accumulator:0xfa7403ff3a3f3546a1fe443bf08a094492e08fa8c358c8abdda334598f68b52c',
+          type: 'DockVBAccumulator2022',
+          revocationCheck: 'membership',
+          revocationId: '17',
+        },
+        id: 'https://creds-testnet.dock.io/74c3a74fbad2fea4f7bb991092165a29de9fc7fb556ee71074755f7804bfaf0e',
+        type: ['VerifiableCredential', 'UniversityDegree'],
+        credentialSubject: {
+          graduated: true,
+          grade: 12,
+          age: 31,
+        },
+        issuanceDate: '2024-11-29T11:39:01.959Z',
+        issuer: {
+          name: 'Test',
+          description: '  ',
+          logo: 'https://img.dock.io/b1026229cdb6a2fbd59605ba7228db0a',
+          id: 'did:dock:5HPb8aoNXNQv5XxbupZRorHyc7CdBUYWFFxeczHxqVgeGPjT',
+        },
+        credentialSchema: {
+          id: 'https://schema.dock.io/Test-V2-1731009346611.json',
+          type: 'JsonSchemaValidator2018',
+          details:
+            '{"jsonSchema":{"$id":"https://schema.dock.io/Test-V2-1731009346611.json","$schema":"http://json-schema.org/draft-07/schema#","additionalProperties":true,"description":"","name":"test University Degree","properties":{"@context":{"type":"string"},"credentialSchema":{"properties":{"details":{"type":"string"},"id":{"type":"string"},"type":{"type":"string"},"version":{"type":"string"}},"type":"object"},"credentialStatus":{"properties":{"id":{"type":"string"},"revocationCheck":{"type":"string"},"revocationId":{"type":"string"},"type":{"type":"string"}},"type":"object"},"credentialSubject":{"properties":{"age":{"description":"","title":"Age","type":"number"},"grade":{"title":"Grade","type":"number"},"graduated":{"default":false,"title":"Graduated","type":"boolean"}},"required":["graduated","age"],"type":"object"},"cryptoVersion":{"type":"string"},"id":{"type":"string"},"issuanceDate":{"format":"date-time","type":"string"},"issuer":{"properties":{"description":{"type":"string"},"id":{"type":"string"},"logo":{"type":"string"},"name":{"type":"string"}},"type":"object"},"name":{"type":"string"},"proof":{"properties":{"@context":{"items":[{"properties":{"proof":{"properties":{"@container":{"type":"string"},"@id":{"type":"string"},"@type":{"type":"string"}},"type":"object"},"sec":{"type":"string"}},"type":"object"},{"type":"string"}],"type":"array"},"created":{"format":"date-time","type":"string"},"proofPurpose":{"type":"string"},"type":{"type":"string"},"verificationMethod":{"type":"string"}},"type":"object"},"type":{"type":"string"}},"type":"object"},"parsingOptions":{"defaultDecimalPlaces":4,"defaultMinimumDate":-17592186044415,"defaultMinimumInteger":-4294967295,"useDefaults":true}}',
+          version: '0.4.0',
+        },
+        name: 'Test University Degree',
+        cryptoVersion: '0.6.0',
+        proof: {
+          '@context': [
+            {
+              sec: 'https://w3id.org/security#',
+              proof: {
+                '@id': 'sec:proof',
+                '@type': '@id',
+                '@container': '@graph',
+              },
+            },
+            'https://ld.dock.io/security/bbs23/v1',
+          ],
+          type: 'Bls12381BBSSignatureDock2023',
+          created: '2024-11-29T11:39:15Z',
+          verificationMethod:
+            'did:dock:5HPb8aoNXNQv5XxbupZRorHyc7CdBUYWFFxeczHxqVgeGPjT#keys-2',
+          proofPurpose: 'assertionMethod',
+          proofValue:
+            'z2e9knFyNq7RPasmUbAASyQ5uALQHHdQsVTXQuLvQTRao6RNbkcyjTcAVBVpMTAZvdm2rW8qZFTCr8ATA1HMuAbZGJD2EM9gtyPFzXHfRUssKuo',
+        },
+        $$accum__witness$$:
+          '{"blockNo":9950875,"witness":"0x975eb3fa6bb302f0679103f187aa6cdb6732739eda6b0254b9a37573a684a5a1c27230f9b1a7a9b472db547b5a180ac7"}',
+      },
+    ];
+
+    const results = pexService.filterCredentials({
+      credentials,
+      presentationDefinition,
+    });
+
+    expect(results.verifiableCredential).toBeTruthy();
+    expect(results.verifiableCredential.length).toBe(1);
+  });
+
   describe('removeOptionalAttribute', () => {
     const getFieldsWithOptionalAttributes = template => {
       return template.input_descriptors[0].constraints.fields.filter(
@@ -410,8 +518,12 @@ describe('Pex Examples', () => {
       let result = removeOptionalAttribute(template);
       expect(getFieldsWithOptionalAttributes(result)).toBe(0);
       expect(result.input_descriptors[0].constraints.fields.length).toBe(1);
+      expect(result).not.toBe(template); // Ensure immutability
+      expect(template.input_descriptors[0].constraints.fields.length).toBe(2); // Original remains unchanged
+    });
 
-      template = {
+    it('should handle fields with unsupported formats', () => {
+      let template = {
         id: 'income_test',
         input_descriptors: [
           {
@@ -422,6 +534,9 @@ describe('Pex Examples', () => {
               fields: [
                 {
                   path: ['$.credentialSubject.id'],
+                  filter: {
+                    format: 'did',
+                  },
                 },
                 {
                   path: ['$.type[*]'],
@@ -438,11 +553,17 @@ describe('Pex Examples', () => {
 
       expect(getFieldsWithOptionalAttributes(template)).toBe(1);
 
-      result = removeOptionalAttribute(template);
+      let result = removeOptionalAttribute(template);
       expect(getFieldsWithOptionalAttributes(result)).toBe(0);
       expect(result.input_descriptors[0].constraints.fields.length).toBe(1);
+      expect(
+        result.input_descriptors[0].constraints.fields[0].filter?.format,
+      ).toBeUndefined();
+      expect(result).not.toBe(template); // Ensure immutability
+    });
 
-      template = {
+    it('should handle templates with no optional attributes', () => {
+      let template = {
         id: 'income_test',
         input_descriptors: [
           {
@@ -461,11 +582,16 @@ describe('Pex Examples', () => {
       };
 
       expect(getFieldsWithOptionalAttributes(template)).toBe(0);
-      result = removeOptionalAttribute(template);
+
+      let result = removeOptionalAttribute(template);
       expect(getFieldsWithOptionalAttributes(result)).toBe(0);
       expect(result.input_descriptors[0].constraints.fields.length).toBe(1);
+      // Ensure immutability
+      expect(result).not.toBe(template);
+    });
 
-      template = {
+    it('should handle templates where all fields are optional', () => {
+      let template = {
         id: 'income_test',
         input_descriptors: [
           {
@@ -485,9 +611,40 @@ describe('Pex Examples', () => {
       };
 
       expect(getFieldsWithOptionalAttributes(template)).toBe(1);
-      result = removeOptionalAttribute(template);
+
+      let result = removeOptionalAttribute(template);
       expect(getFieldsWithOptionalAttributes(result)).toBe(0);
       expect(result.input_descriptors[0].constraints.fields.length).toBe(1);
+      expect(result.input_descriptors[0].constraints.fields[0].path).toEqual([
+        '$.id',
+      ]);
+      expect(result).not.toBe(template); // Ensure immutability
+    });
+
+    it('should add a placeholder field if all fields are removed', () => {
+      let template = {
+        id: 'income_test',
+        input_descriptors: [
+          {
+            id: 'Credential 1',
+            constraints: {
+              fields: [
+                {
+                  path: ['$.type[*]'],
+                  optional: true,
+                },
+              ],
+            },
+          },
+        ],
+      };
+
+      let result = removeOptionalAttribute(template);
+      expect(result.input_descriptors[0].constraints.fields.length).toBe(1);
+      expect(result.input_descriptors[0].constraints.fields[0].path).toEqual([
+        '$.id',
+      ]);
+      expect(result).not.toBe(template); // Ensure immutability
     });
   });
 });