Index.

ts

Demonstrates various operations related to identity creation, issuing credentials, generating

and verifying proofs, and handling authorization requests. Here's a summary of what each
major function does:

createIdentity: Creates a new identity on the Polygon blockchain, generating a DID

(Decentralized Identifier) and associated credentials.

createKYCAgeCredential: Creates a KYC (Know Your Customer) age credential request

with specific details like birthday and document type.

createKYCAgeCredentialRequest: Generates proof requests for age-based credentials

using different circuit IDs.

identityCreation: Demonstrates identity creation and logs the generated DID and
associated credential.

issueCredential: Issues a KYC age credential to a user and saves it to the data storage.

transitState: Simulates transitioning the state of the issuer on the blockchain, including
generating and publishing proofs.

generateProofs: Generates and verifies zero-knowledge proofs for various proof requests
using different circuit IDs.

handleAuthRequest: Handles an authorization request by generating a response that

includes proofs.

handleAuthRequestWithProfiles: Demonstrates handling an authorization request that

involves profiles, generating responses with proofs.

handleAuthRequestNoIssuerStateTransition: Handles an authorization request without

triggering an issuer state transition, showing the response generation process.

main: The main function that takes a choice parameter and executes the corresponding
function based on the choice.

WalletSetup.ts

Code provides utility functions for initializing various components needed for working with
decentralized identity and zero-knowledge proofs using the 0xPolygonID SDK. Here's a
summary of each function's purpose:

initDataStorage: Initializes various data storage components, such as credential and

identity storages, an in-memory merkle tree storage, and an Ethereum state storage.
initIdentityWallet: Initializes an identity wallet using private key management, a key
management service (KMS), and the previously initialized data storage.

initMemoryIdentityWallet: Combines the initialization of data storage, credential wallet, and

identity wallet for convenient setup.

initCredentialWallet: Initializes a credential wallet with resolvers for different types of

credential status.

initCircuitStorage: Initializes a circuit storage by loading circuit data (WASM, proving key,
verification key) from files in a specified folder.

initProofService: Initializes a proof service using an identity wallet, credential wallet, circuit
storage, state storage, and IPFS node URL.

initPackageManager: Initializes a package manager that handles the preparation and

verification of proofs using specified functions and parameters.

The code uses various components from the 0xPolygonID SDK, such as providers,
resolvers, key loaders, packers, and other configurations, to create an integrated
environment for working with decentralized identities and generating zero-knowledge proofs.
It sets up the necessary components and configurations to facilitate the creation, issuance,
verification, and management of identity-related information and cryptographic proofs.

Tthe two provided code sections are related to each other.

They work together to establish an environment for decentralized identity management and
zero-knowledge proofs using the 0xPolygonID SDK. There are common elements and
components used in both code sections. Let's take a closer look at these shared elements
and their purposes:

Shared Components:

initDataStorage: This function initializes data storage components used for managing
credentials, identities, merkle trees, and Ethereum state. It's used in both code sections to
provide a consistent data storage environment.

initCircuitStorage: This function initializes a circuit storage by loading circuit data (WASM,
proving key, verification key) from files. It's common in both code sections to set up the
circuits used for generating zero-knowledge proofs.

initProofService: This function initializes a proof service that interacts with identity wallets,
credential wallets, circuit storages, and state storages. It's used to generate and verify
zero-knowledge proofs and is shared between the two code sections.
CircuitId: This is an enum representing different circuit IDs, which are used to identify
specific zero-knowledge circuits. It's used for loading circuit data from storage and for
specifying which circuit to use for generating and verifying proofs.

KmsKeyType: This enum defines different key types for the key management service
(KMS). It's used to specify the type of key being used for cryptography and signing.

Configuration: Both code sections use environment variables (such as rpcUrl,

contractAddress, circuitsFolder) for configuring the Ethereum RPC URL, contract address,
and folder paths for circuit files.

Flow of Operations:

The two code sections follow a similar flow:

Initialization: They both initialize data storage, credential wallets, identity wallets, circuit
storages, and proof services. These components are critical for handling decentralized
identities and generating zero-knowledge proofs.

Identity Creation: Both sections have functions (createIdentity) to create decentralized

identities using specific methods, blockchains, and networks.

Credential Issuance: They demonstrate the issuance of credentials

(createKYCAgeCredential) and the saving of credentials to the data storage.

Proof Generation and Verification: Both sections generate and verify zero-knowledge
proofs using different types of circuits and requests (proofReqSig and proofReqMtp). They
showcase the process of generating proofs from credentials and verifying them against
specific circuits.

Authorization Handling: Both sections demonstrate the handling of authorization requests

using the AuthHandler component, involving the preparation and verification of proofs for
authentication.

Profile Management: One section specifically demonstrates working with profiles

associated with identities and credentials.

In summary, the shared components and similar flow of operations demonstrate how to set
up an environment for managing decentralized identities, issuing credentials, generating and
verifying zero-knowledge proofs, and handling authorization requests.
Step-by-step breakdown of the code flow for both of the provided code sections:

**Code Section 1:**

1. Import necessary modules and configure environment variables.

2. Initialize Ethereum connection and set contract address.
3. Define functions to initialize data storage, credential wallet, identity wallet, and circuit
storage.
4. Load circuit data and set up circuit storage.
5. Initialize proof service using identity wallet, credential wallet, state storage, and circuit
storage.
6. Create an identity wallet using the initialized components.
7. Create a profile for the identity.
8. Issue a credential (KYC Age Credential) and store it in the data storage.
9. Prepare an authorization request and generate a proof using the AuthHandler.
10. Verify the generated proof using the proof service.

**Code Section 2:**

1. Import necessary modules and configure environment variables.

2. Define functions to initialize data storage, credential wallet, identity wallet, and circuit
storage (similar to Code Section 1).
3. Load circuit data and set up circuit storage (similar to Code Section 1).
4. Initialize proof service using identity wallet, credential wallet, state storage, and circuit
storage (similar to Code Section 1).
5. Initialize Ethereum connection and set contract address.
6. Initialize data storage, credential wallet, and identity wallet.
7. Create an identity wallet using the initialized components.
8. Issue a credential (KYC Age Credential) and store it in the data storage.
9. Prepare an authorization request and generate a proof using the AuthHandler.
10. Verify the generated proof using the proof service.

**Common Flow:**

1. The flow begins with importing required modules and configuring environment variables,
such as Ethereum RPC URL and contract address.
2. Data storage components, credential wallets, and identity wallets are initialized.
3. Circuit data (WASM, proving key, verification key) is loaded and saved in the circuit
storage.
4. Proof service is set up using the initialized components.
5. An identity wallet is created using the KMS and data storage.
6. A credential (KYC Age Credential) is issued and stored in the data storage.
7. An authorization request is prepared, and a zero-knowledge proof is generated using the
AuthHandler.
8. The generated proof is verified using the proof service against specific circuits.

In both code sections, the focus is on establishing an environment for decentralized identity
management, issuing credentials, and generating/verifying zero-knowledge proofs for
authentication. The shared components and similar flow showcase the flexibility and
reusability of the provided code.