Tokenized Asset Servicing

What This Template Does

This project demonstrates the integration of Chainlink Runtime Environment (CRE) with LogTrigger and HTTP abilities to enable seamless off-chain data orchestration for tokenized assets. The project tokenizes various real-world assets (RWAs) using Ethereum Solidity smart contracts and leverages Chainlink CRE, AWS DynamoDB, and Lambda functions to track the full lifecycle of these tokenized assets.

Tokenization and Lifecycle Management

The core of this project is an Ethereum-based Solidity smart contract that facilitates the tokenization of diverse asset classes, including invoices, Treasury bills (T-bills), loans, and carbon credits. Users interact with the contract via specialized functions to manage asset operations, such as:

• Register: Onboard a new asset into the system.
• Verify: Validate asset authenticity and compliance.
• Transfer: Execute peer-to-peer asset transfers.
• Redeem: Liquidate or burn tokens to redeem underlying value.

To support generalized use cases, regulators, auditors, and investors require robust monitoring and auditing capabilities for these tokenized assets and their associated operations. While on-chain data is immutable and verifiable via the blockchain, querying it directly is inefficient and lacks user-friendly interfaces due to the opaque nature of raw transaction logs.

This project addresses these challenges by employing Chainlink CRE to bridge on-chain events with off-chain storage and retrieval:

• LogTrigger captures events emitted by the tokenization platform contract.
• Extracted event data is parsed, normalized, and encapsulated into a structured HTTP payload.
• The HTTP Ability dispatches this payload as a RESTful API request to an AWS Lambda function.
• The Lambda function persists the processed data into an AWS DynamoDB NoSQL database.

This architecture decouples on-chain immutability from off-chain accessibility, providing stakeholders with near-real-time visibility into asset lifecycles without compromising blockchain integrity.

Flow Diagram

sequenceDiagram
    participant Contract as Smart Contract<br/>(Ethereum Sepolia)
    participant CRE as Chainlink CRE<br/>(LogTrigger/HTTPTrigger)
    participant Lambda as AWS Lambda
    participant DynamoDB as AWS DynamoDB

    Note over Contract,DynamoDB: Asset Registration Flow
    Contract->>Contract: Emit AssetRegistered event
    Contract-->>CRE: Event Log (LogTrigger)
    CRE->>CRE: Parse event data
    CRE->>Lambda: POST /function-url (HTTP Ability)
    Lambda->>DynamoDB: PutItem (AssetId, Name, Issuer, Supply)

    Note over Contract,DynamoDB: Asset Verification Flow
    Contract->>Contract: Emit AssetVerified event
    Contract-->>CRE: Event Log (LogTrigger)
    CRE->>Lambda: POST verification data
    Lambda->>DynamoDB: UpdateItem (Add Verified: true)

    Note over Contract,DynamoDB: UID Update Flow (Bidirectional)
    CRE->>CRE: Receive HTTP Trigger
    CRE->>Contract: updateAssetMetadata(assetId, uid)

Prerequisites

Before proceeding, ensure the following are set up:

Tools:

• CRE CLI
• git
• Node.js (v18+ recommended)
• Bun

Blockchain:

• Ethereum Sepolia testnet access (e.g., via Alchemy or Infura RPC endpoint)
• Sepolia test tokens (ETH) for gas

AWS:

• AWS account (Free Tier eligible) with IAM roles for DynamoDB and Lambda

Getting Started

git clone https://github.com/smartcontractkit/cre-templates.git
cd cre-templates/starter-templates/tokenized-asset-servicing/

local-simulation:
  rpcs:
    - chain-name: ethereum-testnet-sepolia
      url: <YOUR_RPC_URL>

npm install

npx tsx ./1_deploy.ts

cd ../asset-log-trigger-workflow
cp config.json.example config.json

cd asset-log-trigger-workflow
bun install

cd ..
cp .env.example .env

Usage Examples

npx tsx ./2_registerNewAsset.ts

cd ../asset-log-trigger-workflow
cre workflow simulate asset-log-trigger-workflow --broadcast --target local-simulation

npx tsx ./3_verifyAsset.ts

cre workflow simulate asset-log-trigger-workflow --broadcast --target local-simulation

{ "assetId": 1, "uid": "bca71bc9-d08e-48ef-8ad1-acefe95505a9" }

npx tsx ./4_readUid.ts

npx tsx ./5_mint.ts

npx tsx ./6_redeem.ts

Troubleshooting

AWS Lambda Internal Server Error on Invocation: Verify that the Lambda execution role has the necessary IAM permissions for DynamoDB operations (e.g., dynamodb:PutItem, dynamodb:UpdateItem). Check CloudWatch Logs for detailed error traces.

Chainlink CRE Fails to Detect Events: Transactions may emit multiple events in sequence; ensure the LogTrigger targets the correct event index. Use Etherscan to inspect raw logs and correlate with CRE configuration.

Solidity Compilation Errors: These often stem from version incompatibilities in OpenZeppelin contracts. Use OpenZeppelin v5.x for ERC-1155 implementations.

Security Considerations

1. This is a demo project - Not production-ready
2. Lambda function security - In production, use proper authentication for Function URLs
3. IAM permissions - Follow least-privilege principles for production deployments
4. Secrets hygiene – Keep real secrets out of version control; use secure secret managers for .env values.