AWS Web3 Blog

OpenAssets: Building a transfer agent on AWS for tokenized securities

Tokenized securities are finding their place in institutional financial markets. Issuing a token is the straightforward part. The harder engineering problem is everything a transfer agent does around it: keeping the authoritative record of ownership, enforcing compliance on every transfer, and producing records that can be made available to examiners on demand.

Transfer agents keep the official record of who owns a security, process transfers, and issue and cancel shares. Much of that work still runs on batch systems built for paper certificates and multi-day settlement. When those systems handle on-chain activity, they reconcile it back into the books after the fact. That approach strains when issuance, transfer, and settlement post in near real time on infrastructure that operates around the clock.

OpenAgent, OpenAssets’ affiliate SEC-registered transfer agent, is built for tokenized securities and runs on AWS. It does not add a blockchain layer on top of an old system. Instead, it builds the transfer agent record directly from blockchain events. It maintains the securityholder register, enforces compliance controls on the server rather than in the user interface, and keeps an append-only ledger from which positions can be rebuilt as of any recorded point in time.

This post covers what OpenAgent does and how it is built. It follows a raw blockchain event through wallet resolution and share accounting to a rebuilt securityholder file and the reports that come out of it.

What OpenAgent does

OpenAgent covers the transfer agent’s work across the life of a tokenized security, from issuance to redemption, in four areas:

  • Ownership administration: Processes mint, transfer, and burn events and maintains the official securityholder register.
  • Compliance controls: Enforces issuer-configured eligibility rules, including Know Your Customer (KYC), Anti-Money Laundering (AML), sanctions, and accreditation status, per-security allowlists, holds, and lockups, on the server rather than in the user interface.
  • Regulatory reporting and recordkeeping: Produces the records SEC rules require transfer agents to keep, including the Master Securityholder File (MSHF) and Control Book, along with a Transaction Journal. It separates routine from non-routine items and measures routine turnaround against Rule 17Ad-2. That rule requires at least 90% of routine items to be turned around within three business days of receipt.
  • Append-only ledger: Records every state-changing action in an append-only event log with full metadata, so balances can be rebuilt as of any recorded point in time.

OpenAgent supports tokenized equities, fund shares, alternative assets (private credit, real estate, commodities), debt instruments, and other regulated securities that require a transfer agent.

The engineering problem: Making on-chain activity operationally usable

Putting a security token on a blockchain does not, by itself, produce a transfer-agent record. Four gaps separate the two. A token transfer carries a wallet address but no investor name or tax ID. A contract event may express quantities in base units rather than shares. Treasury movements have different share-accounting consequences from investor-to-investor transfers. Finally, an event that can’t be matched to a known security or account still must remain visible for investigation rather than silently dropped.

The following diagram shows the OpenAgent architecture on AWS. Issuer, investor, and KYC data from the OpenAssets platform and normalized events from a blockchain indexing layer flow into a single containerized service. That service combines on-chain transaction evidence with off-chain regulated records to produce the MSHF, Control Book, and Transaction Journal. A separate signed container supply chain builds, signs, and deploys the service image. The numbered labels in the diagram match the four responsibilities that follow.

Architecture diagram of OpenAgent on AWS. Data from the OpenAssets platform passes through AWS Network Firewall and an Application Load Balancer, which uses an AWS Certificate Manager certificate, to an OpenAgent container on Amazon Elastic Container Service (Amazon ECS). Normalized chain events stored in MongoDB feed the same service. The service sends logs and metrics to Amazon CloudWatch, uses Amazon Simple Storage Service (Amazon S3), Amazon Simple Email Service (Amazon SES), and AWS Secrets Manager, exposes the OpenAgent Ledger API, and produces the MSHF, Control Book, and Journal together with MongoDB records. A separate signed container supply chain runs from a release tag through AWS CodeBuild, Amazon Elastic Container Registry (Amazon ECR), and AWS Signer to Amazon ECS.

Figure 1: AWS architecture diagram for OpenAgent

OpenAgent separates this into four responsibilities:

  1. Ingest and normalize: Receive issuer, investor, security, wallet, and KYC metadata from the OpenAssets platform, and consume normalized blockchain events from the indexing layer.
  2. Resolve and classify: Match token contracts and wallet addresses to off-chain security and account records and classify each event as mint, transfer, or burn.
  3. Record and reconcile: Create operational items, append journal entries, update control-book share fields, reconstruct the MSHF, and compare independently derived totals.
  4. Operate and evidence: Enforce API permissions and issuer scope, generate exports and turnaround reports, retain supporting documents, and notify stakeholders.

Walkthrough: From a blockchain log to a securityholder record

Take an ERC-20 or ERC-3643 Transfer event with a raw quantity of 1250000, for a security configured with six decimal places. The operational quantity is 1.25. If the sender is the security’s treasury wallet and the recipient is an investor, that single event affects both the investor’s position and treasury/outstanding-share accounting.

1. Preserve the blockchain identity of the event

The normalized chain-event record stores the transaction hash, log index, chain and block identifiers, timestamp, event type, token address, sender, recipient, raw quantity, and signer metadata. OpenAgent enforces a unique index over (txHash, logIndex).

The log index matters because a single blockchain transaction can emit more than one event. A transaction hash alone isn’t a sufficient event ID.

Each event moves through an explicit state: pending, matched, unmatched, or ignored. Native-currency transfers are marked ignored because they don’t map to security-token items. Events for unknown token contracts are marked unmatched with a reason, rather than disappearing from the queue.

2. Process events in chain order under a lease

When enabled, the worker checks for work every five seconds. Before reading a batch, it acquires a MongoDB-backed lease with a 60-second expiry, so multiple worker instances don’t process the same queue at the same time. It then reads up to 100 pending events per batch, ordered by block number and log index, so share accounting is applied in the same sequence the chain recorded it.

This is a deliberately small, inspectable worker rather than an opaque reconciliation batch. A failed event moves to unmatched with error context, letting the next event proceed while preserving evidence for operations review.

3. Match the security and normalize token units

OpenAgent matches an event to a security using the chain ID and a case-insensitive token address, then applies the security’s configured decimal places before creating any accounting records.

The normalization helper works on the integer’s string representation and stores the result as MongoDB Decimal128. The raw token quantity never passes through JavaScript floating-point math, where rounding errors could change a share count. For this example, 1250000 becomes 1.25.

4. Resolve wallets without putting PII on-chain

Wallet addresses are normalized to lowercase and resolved against watched-address records, which point to OpenAgent accounts, which in turn point to an investor or issuer. Names, contact details, tax data, registration type, and KYC status all remain in off-chain records.

The link between the two layers is an address association maintained by OpenAgent, not a claim that personally identifiable information (PII) is encoded in, or cryptographically recoverable from, the token itself. This is consistent with the approach described in the SEC Division of Trading and Markets’ staff FAQ on crypto asset activities and distributed ledger technology (Question 11). Under that approach, blockchain data supplies transaction provenance, and the transfer agent’s own systems supply the non-public identity context.

5. Create the operational item and append the journal entry

The processor maps events as follows:

Blockchain event OpenAgent item Journal event
Mint mint issuance
Transfer transfer transfer
Burn burn burn

For a matched event, OpenAgent creates a settled, chain-indexed item containing the security, resolved accounts, normalized quantity, transaction hash, wallet addresses, signer data, and block timestamp. It then appends a journal entry with actor and role metadata referencing that item.

The journal model rejects update and delete operations at the application level. That gives the service an append-only operational path, while the blockchain transaction hash preserves a link back to the public or permissioned ledger. To be clear about what this is and isn’t: it’s an application-level control, not a claim of cryptographic immutability over the MongoDB collection itself.

6. Update share accounting according to wallet role

Mint, transfer, and burn events affect share counts differently, depending on which wallets are involved. OpenAgent distinguishes the issuer’s treasury wallets, including multisignature treasury wallets, from investor wallets:

  • A mint increases issued shares. A mint into treasury also increases treasury shares by the same amount, so the mint itself leaves outstanding shares unchanged. Outstanding shares rise when those shares are transferred from treasury to an investor.
  • A transfer out of treasury decreases treasury shares, and a transfer into treasury increases them. A transfer between two investor wallets doesn’t change issued or treasury shares.

A burn increases canceled shares and adjusts treasury shares according to the wallet setup. After a relevant change, the service recomputes:

outstanding shares = issued shares – treasury shares – canceled shares

In the preceding example, treasury shares fall by 1.25, so outstanding shares rise by 1.25. The chain event is marked matched only after the related item, journal entry, and share-accounting update have all been applied successfully.

Reconstructing the MSHF instead of copying a token balance

The MSHF endpoint doesn’t treat a single database balance field as unquestioned truth. It reconstructs positions from settled mint, transfer, and burn items.

For each security and normalized wallet address, the aggregation applies two deltas:

recipient delta = +quantity
sender delta = -quantity
shares held = sum(all deltas for the security and wallet)

The pipeline excludes the zero address, non-positive balances, treasury destinations where appropriate, and multisignature burn addresses. Deltas are grouped by wallet before joining to accounts and investors. Joining first could multiply a balance if an address appears in more than one matching account record.

Only after the wallet position is calculated does OpenAgent join off-chain account, investor, KYC, contact, registration, and lost-holder fields. The result combines blockchain provenance (chain, contract, wallet, transaction hash) with the identity fields transfer-agent operations require.

Access to GET /api/v1/reports/mshf requires an authenticated role with report permission. Issuer administrators are additionally scoped to their own issuer ID before the aggregation runs. A missing or invalid issuer scope fails closed.

Control-book reconciliation as a separate calculation

The control-book endpoint starts from each security’s authorization and persisted share-accounting fields: authorized, issued, outstanding, treasury, canceled, and reserved shares. It independently derives an MSHF total from settled item deltas and calculates:

record difference = MSHF total – outstanding shares

It also queries the OpenAgent ledger API for the token contract’s on-chain total supply, returning that value alongside the report. A discrepancy is surfaced for investigation, not silently reconciled away.

A simplified response from GET /api/v1/reports/control-book?securityId=...:

{
  "security": {
    "tokenAddress": "0x...",
    "chainId": "...",
    "blockchain": "..."
  },
  "shareAccounting": {
    "cumulativeIssuedShares": 1000000,
    "outstandingShares": 875000,
    "treasuryShares": 100000,
    "canceledRetiredShares": 25000
  },
  "reconciliation": {
    "mshfTotal": 875000,
    "recordDifference": 0,
    "onChainTokenTotalSupply": "975000"
  }
}

The numbers here are illustrative, but the fields and reconciliation path reflect the actual implementation.

Turning operational events into regulatory evidence

OpenAgent stores each transfer-agent item with receipt, classification, completion, and due dates. A monthly worker evaluates active securities and upserts a report for the current period, measuring routine transfers against a three-business-day threshold and dividend-reinvestment items against a ten-business-day threshold. The report records category totals, the number completed within threshold, compliance percentages, and whether a failure notice is required.

If two consecutive monthly reports for a security require a failure notice, the workflow creates or reactivates an incident and a transfer-agent restriction flag, and appends incident timeline context. It then notifies stakeholders through Amazon Simple Email Service (Amazon SES). Email messages are rendered from version-controlled EJS templates and sent with the SendEmailCommand of the AWS SDK for JavaScript.

MSHF, control-book, journal, turnaround, and incident data can all be exported. Generated exports and supporting evidence files are written to Amazon Simple Storage Service (Amazon S3), with download access granted through an expiring presigned GetObject URL rather than a public bucket.

Why OpenAgent runs on AWS

Each AWS service in OpenAgent’s design handles a specific job in the application.

Container runtime and traffic routing: OpenAgent builds a multi-stage Node.js container. The runtime image contains only compiled production code and production dependencies, runs as a non-root user, and strips package-manager executables not needed at runtime. Amazon Elastic Container Service (Amazon ECS) runs that image, with an Application Load Balancer routing API traffic to the service’s target group. AWS Certificate Manager (ACM) provisions and renews the TLS certificate the load balancer uses, so API traffic is encrypted in transit.

Object, message, and secret boundaries:

  • Amazon S3 stores generated regulatory exports and evidence documents. The application stores bucket/key metadata and generates expiring download URLs on demand.
  • Amazon SES sends account, authentication, affected-user, and consecutive-SLA-breach notifications from application-owned templates.
  • AWS Secrets Manager stores issuer integration credentials. The application database holds only the secret’s ID, never the plaintext credential.
  • AWS Systems Manager Parameter Store supplies environment configuration to the build and deployment flow, matching the service’s environment-validation contract.

Network and operational visibility:

  • AWS Network Firewall filters inbound traffic before it reaches the load balancer.
  • Amazon CloudWatch collects logs and metrics from the ECS tasks, so processing failures are visible to operations.

A signed container supply chain: Pull requests run unit tests, end-to-end tests, linting, formatting, spelling, dependency checks, and container scanning. Release tags trigger the ECS deployment workflow, which runs in AWS CodeBuild and:

  1. Retrieves the environment contract and private package-manager configuration from Parameter Store.
  2. Builds the image from an approved Node.js 24 base image in Amazon Elastic Container Registry (Amazon ECR), using a BuildKit secret mount so private registry configuration never lands in an image layer.
  3. Runs a Trivy image scan for configured vulnerability severities.
  4. Pushes a temporary image tag to ECR and resolves its content digest.
  5. Signs that digest with the Notation CLI and AWS Signer plugin.
  6. Applies the deployment tag, removes the temporary unsigned tag, and emits the ECS image-definition artifact.

Signing the digest (rather than a mutable, human-readable tag) ties the signature to the actual image content.

Design lessons for builders

Three implementation lessons have mattered most in building this system.

First, on-chain does not mean identity-complete. A usable securityholder record needs a controlled, auditable link between wallets and investor identity, with personal data kept off-chain. Second, reconciliation should compare independently, not copy a single number forward. OpenAgent keeps six views separate: the chain event, operational item, append-only journal, persisted control-book fields, reconstructed MSHF total, and on-chain token supply. When they disagree, the difference shows instead of being hidden.

Third, unmatched is a first-class state. A transfer-agent system shouldn’t discard an unknown token event or hide a processing error. Keeping the event, the reason it failed to match, and the timestamps is what makes operational review possible.

Conclusion

Tokenized securities still need what a transfer agent has always provided: an accurate securityholder register, reconciled share counts, and records built to support regulatory examination. OpenAgent builds those records directly from blockchain events, keeps investor identity off-chain behind an auditable wallet association, and lets independent calculations check one another so every discrepancy stays visible.

On AWS, Amazon ECS runs the service, Amazon S3 and Amazon SES handle evidence and notifications, AWS Secrets Manager keeps issuer credentials out of the database, and the release pipeline signs each image by its content digest.


About the authors

Surendra Kalidindi

Surendra is the COO & CTO at OpenAssets, specializing in digital asset infrastructure, blockchain, and P2P technologies. Previously, he served as Global Head of Digital Assets Technology at VanEck and Vice President of Trading Systems at Neuberger Berman. He champions global financial inclusion through tokenization and next-generation market infrastructure.

Sarvesh Naidu

Sarvesh is an Engineering Manager at OpenAssets, where he leads engineering teams building secure, scalable platforms for tokenization and digital asset lifecycle management. With deep expertise in enterprise architecture, distributed systems, and cloud-native engineering, he focuses on translating complex regulatory and business requirements into robust technical solutions that accelerate institutional blockchain adoption.

Nikhil Nayab

Leads product management at OpenAssets, where he focuses on products that bridge traditional finance and digital assets. His experience spans retail and wholesale financial services, with a focus on translating complex financial workflows, institutional requirements, and regulatory constraints into practical technology platforms.

Thomas Charpié

Thomas Charpié

Thomas is an FSI Specialist for Capital Markets at Amazon Web Services, where he works with wealth managers, exchanges, market infrastructure providers, and digital-asset platforms. He leads AWS’s tokenization efforts across Capital Markets and helps wealth management firms bring AI into advisor and client workflows.