Complete guide to building enterprise asset tokenization solutions with real-world ROI examples and step-by-step implementation

How do I build an asset tokenization platform that delivers measurable ROI?

Asset tokenization transforms physical and digital assets into blockchain-based tokens, enabling fractional ownership, enhanced liquidity, and automated compliance. Organizations implementing asset tokenization report 40-60% reduction in settlement times and 15-25% increase in asset liquidity.

Real-World Impact

Real estate tokenization projects have enabled $2.3 billion in previously illiquid assets to be traded, with transaction costs reduced by up to 80% compared to traditional methods.

Who needs asset tokenization solutions?

Real Estate Companies

Enable fractional property ownership and reduce barriers to entry for investors

Challenge: High minimum investments exclude small investors
Solution: Tokenize properties for fractional ownership starting at $1,000
ROI: 35% increase in investor participation, 60% faster transaction settlement

Investment Funds

Streamline fund distribution and automate compliance

Challenge: Manual compliance and limited liquidity
Solution: Automated regulatory compliance and secondary markets
ROI: 70% reduction in compliance costs, 24/7 trading capability

Supply Chain Leaders

Enhance traceability and ownership transfer

Challenge: Complex ownership chains and fraud prevention
Solution: Immutable ownership records and automated transfers
ROI: 45% reduction in fraud, 30% faster ownership verification

Art & Collectibles Markets

Democratize high-value asset ownership

Challenge: Limited liquidity and high transaction costs
Solution: Fractional ownership and reduced intermediary fees
ROI: 50% increase in market participation, 25% cost savings

What makes asset tokenization profitable for businesses?

Asset tokenization converts traditional assets into digital tokens on a blockchain, creating programmable ownership rights that enable fractional investment, automated compliance, and global accessibility. This technology addresses critical business challenges while creating new revenue streams.

Measurable Business Impact

Increased Liquidity: 15-25% improvement in asset tradability
Reduced Costs: 40-80% lower transaction fees vs traditional methods
Faster Settlement: 24-48 hours instead of 30-90 days
Global Access: 24/7 trading removes geographic limitations
Compliance Automation: 70% reduction in manual regulatory processes

Blockchain-Powered Features

Immutable Records: Permanent ownership history prevents fraud
Smart Contracts: Automatic execution of terms and conditions
Fractional Ownership: Divide assets into affordable investment units
Programmable Logic: Built-in compliance and transfer restrictions
Transparent Auditing: Real-time visibility into all transactions

Revenue Generation Models

Transaction Fees: 0.1-1% on all token transfers
Management Fees: 1-2% annual fees on tokenized assets
Platform Licensing: Revenue from white-label solutions
Liquidity Provision: Earn from market-making activities
Compliance Services: Charge for regulatory technology

Which industries benefit most from asset tokenization?

Proven Success Stories

Companies implementing asset tokenization see average ROI of 300-500% within 18 months, with payback periods as short as 6 months for high-volume use cases.

Real Estate Tokenization

Market Size: $3.7 trillion addressable market

Enable fractional ownership starting at $100-$1,000 minimums
Reduce property transaction costs by 60-80%
Create secondary markets for previously illiquid assets
Success Metric: 35% increase in investor participation

Supply Chain Asset Management

Market Size: $1.2 trillion in tracked assets globally

Enhance product traceability and authenticity verification
Automate ownership transfers between supply chain partners
Reduce documentation costs by 45%
Success Metric: 50% reduction in counterfeit goods

Investment Fund Tokenization

Market Size: $18 trillion in fund assets under management

Streamline fund distribution and investor onboarding
Enable 24/7 secondary trading of fund shares
Automate compliance and reporting requirements
Success Metric: 70% reduction in operational costs

Art and Collectibles Markets

Market Size: $68 billion annual art market

Democratize access to high-value collectibles
Provide instant liquidity for traditionally illiquid assets
Enable portfolio diversification across multiple artworks
Success Metric: 50% increase in market participation

How do I implement asset tokenization step-by-step?

Building a production-ready asset tokenization platform requires careful planning, proper infrastructure setup, and robust smart contract development. This implementation guide provides a proven path to deployment with real-world examples and ROI calculations.

Implementation Timeline

Complete asset tokenization platforms typically require 8-12 weeks for full deployment, with basic functionality available in 4-6 weeks. Factor this timeline into your project planning and budget allocation.

Set up your blockchain infrastructure

Create a secure, scalable foundation for your tokenization platform that can handle enterprise-grade transaction volumes and regulatory requirements.

Create an Application

Business Impact: Proper infrastructure setup reduces deployment time by 40% and ensures 99.9% uptime for mission-critical applications.

To create an application on SettleMint:

Select the application launcher in the top right of the dashboard (four boxes)
Click Add an application
Create a blockchain application with a descriptive name that reflects your tokenization use case

Cost Consideration: Infrastructure setup typically costs $5,000-$15,000 but eliminates $50,000+ in custom development expenses.

Deploy enterprise-grade blockchain network

Configure a high-performance blockchain network optimized for asset tokenization workloads, ensuring compliance with financial regulations and enterprise security standards.

Deploy a Network or Node

Performance Requirements: Asset tokenization platforms typically require 1,000+ TPS (transactions per second) capacity to handle peak trading volumes during market hours.

Click Start Here → Add a Blockchain Network
Select Hyperledger Besu for enterprise-grade features
Configure deployment settings:
- Type: Shared (for cost optimization) or Dedicated (for maximum security)
- Cloud Provider: Google Cloud (recommended for global reach)
- Region: Select closest to your primary user base
- Resource Pack: Medium or Large for production workloads

Cost Impact: Medium resource pack costs ~$500/month but handles 10x transaction volume vs Small pack.

Enable multi-signature wallet support for high-value transfers
Configure role-based access controls for different user types
Set up automated backup and disaster recovery
Implement transaction monitoring and alerting

Compliance Note: Financial services require SOC 2 Type II compliance, which is included in Dedicated deployments.

Configure gas optimization for reduced transaction costs
Set up load balancing for high-availability access
Enable caching for faster query responses
Implement batch processing for bulk operations

ROI Metric: Optimized networks reduce transaction costs by 30-50% compared to default configurations.

Configure Besu

Network Success

Deployment Time: Network deployment typically takes 15-30 minutes. Monitor the status until both node and network show Running status.

Set up decentralized asset storage

Deploy IPFS storage infrastructure to securely store asset metadata, legal documents, and media files while maintaining regulatory compliance and data integrity.

IPFS Storage

Storage Requirements: Asset tokenization platforms typically store 100GB-1TB of asset metadata, legal documents, and multimedia content per year.

Storage Cost Optimization

IPFS storage costs 90% less than traditional cloud storage while providing better decentralization and censorship resistance for regulatory compliance.

Implementation Steps:

Click Storage → Add storage
Select IPFS for decentralized document storage
Create instance named Token-Asset-Storage
Choose same deployment plan as your network for consistency

Business Benefits:

Data Integrity: Cryptographic hashing prevents document tampering
Global Access: 24/7 availability regardless of geographic location
Regulatory Compliance: Immutable audit trail for financial regulators
Cost Savings: 90% reduction in storage costs vs centralized solutions

Configure secure transaction signing

Generate cryptographic keys for secure transaction signing, enabling automated asset transfers while maintaining enterprise-grade security standards.

Create a Key

Security Considerations: Asset tokenization requires multi-layered key management with hardware security modules (HSMs) for high-value asset protection.

Key Generation Process:

Navigate to Private Keys section
Select Accessible EC DSA P256 for enterprise-grade encryption
Create descriptive key name (e.g., "AssetTokenization-MainSigner")
Associate with your deployed blockchain node

Enterprise Security Features:

Hardware Security Modules: For keys managing >$1M in assets
Multi-signature Requirements: For transfers above defined thresholds
Key Rotation: Automated quarterly key updates
Access Logging: Complete audit trail of key usage

Deploy production-ready smart contracts

Implement secure, audited smart contracts that handle asset tokenization, fractional ownership, compliance automation, and governance functions with enterprise-grade reliability.

Smart Contract ROI

Pre-built asset tokenization smart contracts reduce development costs by 80-90% and deployment time from 6+ months to 2-4 weeks, delivering faster time-to-market and reduced risk.

Create smart contract development environment

Set up an integrated development environment with automated testing, security scanning, and deployment tools for rapid, secure smart contract development.

Development Best Practices: Asset tokenization smart contracts require comprehensive testing with 95%+ code coverage and security audits before handling real-world assets.

Setup Process:

Navigate to Dev tools in the left sidebar
Click Add a dev tool → Code Studio → Smart Contract Set
Select the Empty template for maximum customization flexibility
Name your contract set (e.g., "Enterprise-Asset-Tokenization")
Choose same deployment plan for resource consistency

Create a Smart Contract

Smart Contract Features to Implement:

ERC-1155 Multi-Token Standard: Handle multiple asset types efficiently
Fractional Ownership: Enable micro-investments starting at $1
Automated Compliance: Built-in KYC/AML and regulatory checks
Governance Rights: Token holder voting on asset management decisions
Revenue Distribution: Automatic dividend/rental income distribution

For detailed smart contract development guidance, see our Smart Contract Sets documentation.

What are the business outcomes of asset tokenization?

Organizations implementing asset tokenization platforms report significant business improvements across multiple metrics, with measurable ROI typically achieved within 12-18 months.

Revenue & Cost Improvements

Transaction Volume: 300-500% increase in asset trading frequency
Cost Reduction: 60-80% lower transaction costs vs traditional methods
New Revenue Streams: Transaction fees, management fees, platform licensing
Faster Settlement: 24-48 hours vs 30-90 days traditional settlements
Reduced Overhead: 70% reduction in manual compliance processes

Case Study: Real estate tokenization platform increased property liquidity by 400% while reducing transaction costs from $50,000 to $5,000 per deal.

Process & Efficiency Gains

24/7 Operations: Continuous trading without geographic limitations
Automated Compliance: Smart contracts handle regulatory requirements
Transparent Auditing: Real-time visibility into all transactions
Reduced Fraud: Blockchain immutability prevents document tampering
Faster Onboarding: Digital KYC/AML processes reduce approval time by 80%

Success Metric: Investment funds report 90% faster investor onboarding and 75% reduction in compliance staff requirements.

Growth & Access Opportunities

Global Reach: Access international investors 24/7
Fractional Ownership: Lower minimum investments from $100K to $1K
Increased Participation: 50-200% more investors per asset
Secondary Markets: Create liquidity for previously illiquid assets
Portfolio Diversification: Enable micro-investments across multiple assets

Market Impact: Art tokenization platforms report 300% increase in market participation with average investment sizes dropping from $50,000 to $5,000.

How do I integrate the frontend and business logic?

Open development environment

To add and edit the smart contract code, you will use the IDE.

Open Fullscreen

Once the resource has been deployed, select the IDE tab and then View in fullscreen mode.

3. Adding the smart contract code

With the IDE open in fullscreen, create a new file for your Asset Tokenization smart contract.

Create Asset Contract

On the File Explorer on the left side, select the Contracts option.
Right Click and select New File...
Create a new file called AssetTokenization.sol

Before adding the contract code, you'll need to install the OpenZeppelin contracts dependency. This provides the base contracts we'll inherit from for features like upgradability and access control.

Open the terminal in the IDE and run:

npm install @openzeppelin/contracts-upgradeable

This package provides the base contracts we'll use like UUPSUpgradeable, OwnableUpgradeable, and ERC1155SupplyUpgradeable.

After installing the dependency, copy and paste the Solidity code below:

Solidity Code

// SPDX-License-Identifier: MIT
// SettleMint.com

pragma solidity ^0.8.13;

import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC1155/extensions/ERC1155SupplyUpgradeable.sol";

/**
 * @title AssetTokenization
 * @dev A contract for tokenizing assets using ERC1155 standard with upgradeable functionality.
 */
contract AssetTokenization is Initializable, UUPSUpgradeable, ERC1155SupplyUpgradeable, OwnableUpgradeable {
    /**
     * @dev Struct representing an asset.
     * @param assetId Unique identifier number.
     * @param name Name of the asset.
     * @param symbol Symbol of the asset.
     * @param maxSupply Maximum number of tokens for the asset.
     * @param faceValue Initial value of the asset.
     * @param maturityTimestamp Maturity date in the value of a unix timestamp.
     * @param assetUri URI for the asset metadata.
     */
    struct Asset {
        uint256 assetId;
        string name;
        string symbol;
        uint256 maxSupply;
        uint256 faceValue;
        uint256 maturityTimestamp;
        string assetUri;
    }

    /// @notice Mapping from asset ID to asset details.
    mapping(uint256 => Asset) public assetToDetails;

    /**
     * @dev Event emitted on asset transfer.
     * @param from Address from which the asset is transferred.
     * @param to Address to which the asset is transferred.
     * @param assetIds Array of asset IDs being transferred.
     * @param amounts Array of amounts of each asset being transferred.
     */
    event AssetTransferEvent(address indexed from, address indexed to, uint256[] assetIds, uint256[] amounts);

    /**
     * @dev Initializes the contract.
     */
    function initialize() external initializer {
        __ERC1155_init("");
        __Ownable_init(msg.sender);
        __UUPSUpgradeable_init();
    }

    /**
     * @dev Creates a new asset.
     * @param assetId Unique identifier for the asset.
     * @param name Name of the asset.
     * @param symbol Symbol of the asset.
     * @param maxSupply Maximum supply of the asset.
     * @param faceValue Initial value of the asset.
     * @param maturityTimestamp Maturity date of the asset in unix timestamp.
     * @param assetUri URI for the asset metadata.
     */
    function createAsset(
        uint256 assetId,
        string memory name,
        string memory symbol,
        uint256 maxSupply,
        uint256 faceValue,
        uint256 maturityTimestamp,
        string memory assetUri
    ) external onlyOwner {
        require(assetToDetails[assetId].assetId != assetId, "Asset already exists");
        Asset memory asset = Asset(assetId, name, symbol, maxSupply, faceValue, maturityTimestamp, assetUri);
        assetToDetails[assetId] = asset;
    }

    /**
     * @dev Mints a specified amount of an asset to a recipient.
     * @param assetId ID of the asset to mint.
     * @param amounts Amount of the asset to mint.
     * @param recipient Address to receive the minted assets.
     */
    function mint(uint256 assetId, uint256 amounts, address recipient) external onlyOwner {
        require(assetToDetails[assetId].assetId == assetId, "Asset does not exist");
        require(totalSupply(assetId) + amounts <= assetToDetails[assetId].maxSupply, "Max supply exceeded");
        require(assetToDetails[assetId].maturityTimestamp > block.timestamp, "Asset is already matured");
        _mint(recipient, assetId, amounts, "");
    }

    /**
     * @dev Mints multiple assets in a batch to a recipient.
     * @param assetIds Array of asset IDs to mint.
     * @param amounts Array of amounts for each asset to mint.
     * @param recipient Address to receive the minted assets.
     */
    function mintBatch(uint256[] memory assetIds, uint256[] memory amounts, address recipient) public onlyOwner {
        uint256 length = assetIds.length;
        for (uint256 i = 0; i < length; i++) {
            require(assetToDetails[assetIds[i]].assetId == assetIds[i], "Asset does not exist");
            require(
                totalSupply(assetIds[i]) + amounts[i] <= assetToDetails[assetIds[i]].maxSupply, "Max supply exceeded"
            );
            require(assetToDetails[assetIds[i]].maturityTimestamp > block.timestamp, "Asset is already matured");
        }
        _mintBatch(recipient, assetIds, amounts, "");
    }

    /**
     * @dev Burns a specified amount of an asset from the sender.
     * @param assetId ID of the asset to burn.
     * @param amounts Amount of the asset to burn.
     */
    function burn(uint256 assetId, uint256 amounts) external {
        require(assetToDetails[assetId].assetId == assetId, "Asset does not exist");
        _burn(msg.sender, assetId, amounts);
    }

    /**
     * @dev Burns multiple assets in a batch from the sender.
     * @param assetIds Array of asset IDs to burn.
     * @param amounts Array of amounts for each asset to burn.
     */
    function burnBatch(uint256[] memory assetIds, uint256[] memory amounts) external {
        uint256 length = assetIds.length;
        for (uint256 i = 0; i < length; i++) {
            require(assetToDetails[assetIds[i]].assetId == assetIds[i], "Asset does not exist");
        }
        _burnBatch(msg.sender, assetIds, amounts);
    }

    /**
     * @dev Returns the URI for a specific asset ID.
     * @param id Asset ID to query the URI for.
     * @return URI of the specified asset ID.
     */
    function uri(uint256 id) public view override returns (string memory) {
        return assetToDetails[id].assetUri;
    }

    /**
     * @dev Updates the state on asset transfer and emits the transfer event.
     * @param from Address from which the asset is transferred.
     * @param to Address to which the asset is transferred.
     * @param assetIds Array of asset IDs being transferred.
     * @param amounts Array of amounts of each asset being transferred.
     */
    function _update(address from, address to, uint256[] memory assetIds, uint256[] memory amounts)
        internal
        override(ERC1155SupplyUpgradeable)
    {
        super._update(from, to, assetIds, amounts);
        emit AssetTransferEvent(from, to, assetIds, amounts);
    }

    /**
     * @dev Authorizes the upgrade of the contract to a new implementation.
     * @param newImplementation Address of the new implementation.
     */
    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
}

4. Change the deployment configuration

With the code pasted in the IDE, you now need to change the deployment settings to include the smart contract you have just created.

Edit Deployment Contract

In the file explorer on the left, select the ignition folder. Then open the main.ts file under modules.

Replace the content of main.ts with the code below:

Ignition Module Code

// SPDX-License-Identifier: MIT
// SettleMint.com
import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";

const AssetTokenizationModule = buildModule("AssetTokenizationModule", (m) => {
  const assetTokenization = m.contract("AssetTokenization");

  return { assetTokenization };
});

export default AssetTokenizationModule;

5. Deploy the contract

With those settings changed, you are now ready to compile and deploy your smart contract.

Compile Contract

To compile the smart contract:

Select the Task Manager on the left menu
Click Foundry - Build or Hardhat - Build to compile the contract
A terminal window below will show the status of the compiling contract

To deploy your smart contract:

Select the Hardhat - Deploy to platform network option
The terminal will open to show the status of deploying your contract
The terminal will show the contract address of your smart contract

Contract Address

The contract address can also be found in deployed_addresses.json in the deploymentsfolder created when deploying the smart contract code. You will need it later for the integration.

Part 3: connect the resources

1. Upload an image to ipfs

You will now upload the image to the IPFS storage service you deployed earlier.

Asset Image

Save the image above to your computer. It is what you will use to represent your asset.

Add to IPFS

To upload this image to IPFS:

Click on Storage
Select File Manager
Select the Import option

Set Pinning

After the image has been imported, select the Share Link option by clicking on the 3 dots next to the file size.

Save this URL as you will use it later in this guide when building the integration.

Select the Set pinning option. This will make sure your file remains on IPFS.

Set Local Node

Choose the local node option and click Apply.

2. Get the json-rpc endpoint

To connect to the network that you have created, you need to get your JSON-RPC connection URL.

JSON RPC Node

The URL can be found by:

Selecting Blockchain nodes
Clicking on the Connect tab
Copy the JSON-RPC URL

Save this URL as you will use it later in this guide when building the integration.

3. Creating an access token

To connect to your node and storage, you will need an access token. We recommend you use an application access token.

You can create an application access token by navigating to the application dashboard, and then clicking on the Access Tokens section in the left sidebar.

API Keys

You can now create an application access token with an expiration and the scopes you want to use. For this guide, we recommend you create an access token scoped to your node and storage.

You will now see your access token. Copy the token since you cannot see it again! For more information on how to use access tokens, see our Access Tokens section.

4. Setup integration studio deployment

The final step is to create a deployment of the Integration Studio.

Create an Integration

To create an integration studio deployment:

Click on Integration Tools on the left menu
Name the Integration Studio
Choose the same deployment plan you have used in this guide

Open an Integration

Open your Integration Studio by selecting the Interface tab and then opening it in fullscreen mode.

For this guide, import the template below into the Integration Studio.

Import an Integration

To import the below JSON file:

Click on the hamburger icon in the top right next to the Deploy button.
Select the import option
Paste the below JSON code into the window

JSON Code


[ { "id": "8154b1dd0912e484", "type": "function", "z": "a781da6f697711d2",
"name": "Set Global Variables", "func": "const glbVar = {\n privateKey:
\"PRIVATE_KEY\",\n privateKeyAddress: \"ADDRESS\",\n smartContract:
\"ADDRESS\",\n accessToken: \"ACCESS_TOKEN\",\n rpcEndpoint: \"RCP_ENDPOINT\",\n
abi: [\n {\n \"inputs\": [\n {\n \"internalType\": \"address\",\n \"name\":
\"target\",\n \"type\": \"address\"\n }\n ],\n \"name\": \"AddressEmptyCode\",\n
\"type\": \"error\"\n },\n {\n \"inputs\": [\n {\n \"internalType\":
\"address\",\n \"name\": \"sender\",\n \"type\": \"address\"\n },\n {\n
\"internalType\": \"uint256\",\n \"name\": \"balance\",\n \"type\":
\"uint256\"\n },\n {\n \"internalType\": \"uint256\",\n \"name\": \"needed\",\n
\"type\": \"uint256\"\n },\n {\n \"internalType\": \"uint256\",\n \"name\":
\"tokenId\",\n \"type\": \"uint256\"\n }\n ],\n \"name\":
\"ERC1155InsufficientBalance\",\n \"type\": \"error\"\n },\n {\n \"inputs\": [\n
{\n \"internalType\": \"address\",\n \"name\": \"approver\",\n \"type\":
\"address\"\n }\n ],\n \"name\": \"ERC1155InvalidApprover\",\n \"type\":
\"error\"\n },\n {\n \"inputs\": [\n {\n \"internalType\": \"uint256\",\n
\"name\": \"idsLength\",\n \"type\": \"uint256\"\n },\n {\n \"internalType\":
\"uint256\",\n \"name\": \"valuesLength\",\n \"type\": \"uint256\"\n }\n ],\n
\"name\": \"ERC1155InvalidArrayLength\",\n \"type\": \"error\"\n },\n {\n
\"inputs\": [\n {\n \"internalType\": \"address\",\n \"name\": \"operator\",\n
\"type\": \"address\"\n }\n ],\n \"name\": \"ERC1155InvalidOperator\",\n
\"type\": \"error\"\n },\n {\n \"inputs\": [\n {\n \"internalType\":
\"address\",\n \"name\": \"receiver\",\n \"type\": \"address\"\n }\n ],\n
\"name\": \"ERC1155InvalidReceiver\",\n \"type\": \"error\"\n },\n {\n
\"inputs\": [\n {\n \"internalType\": \"address\",\n \"name\": \"sender\",\n
\"type\": \"address\"\n }\n ],\n \"name\": \"ERC1155InvalidSender\",\n \"type\":
\"error\"\n },\n {\n \"inputs\": [\n {\n \"internalType\": \"address\",\n
\"name\": \"operator\",\n \"type\": \"address\"\n },\n {\n \"internalType\":
\"address\",\n \"name\": \"owner\",\n \"type\": \"address\"\n }\n ],\n \"name\":
\"ERC1155MissingApprovalForAll\",\n \"type\": \"error\"\n },\n {\n \"inputs\":
[\n {\n \"internalType\": \"address\",\n \"name\": \"implementation\",\n
\"type\": \"address\"\n }\n ],\n \"name\": \"ERC1967InvalidImplementation\",\n
\"type\": \"error\"\n },\n {\n \"inputs\": [],\n \"name\":
\"ERC1967NonPayable\",\n \"type\": \"error\"\n },\n {\n \"inputs\": [],\n
\"name\": \"FailedInnerCall\",\n \"type\": \"error\"\n },\n {\n \"inputs\":
[],\n \"name\": \"InvalidInitialization\",\n \"type\": \"error\"\n },\n {\n
\"inputs\": [],\n \"name\": \"NotInitializing\",\n \"type\": \"error\"\n },\n
{\n \"inputs\": [\n {\n \"internalType\": \"address\",\n \"name\": \"owner\",\n
\"type\": \"address\"\n }\n ],\n \"name\": \"OwnableInvalidOwner\",\n \"type\":
\"error\"\n },\n {\n \"inputs\": [\n {\n \"internalType\": \"address\",\n
\"name\": \"account\",\n \"type\": \"address\"\n }\n ],\n \"name\":
\"OwnableUnauthorizedAccount\",\n \"type\": \"error\"\n },\n {\n \"inputs\":
[],\n \"name\": \"UUPSUnauthorizedCallContext\",\n \"type\": \"error\"\n },\n
{\n \"inputs\": [\n {\n \"internalType\": \"bytes32\",\n \"name\": \"slot\",\n
\"type\": \"bytes32\"\n }\n ],\n \"name\": \"UUPSUnsupportedProxiableUUID\",\n
\"type\": \"error\"\n },\n {\n \"anonymous\": false,\n \"inputs\": [\n {\n
\"indexed\": true,\n \"internalType\": \"address\",\n \"name\": \"account\",\n
\"type\": \"address\"\n },\n {\n \"indexed\": true,\n \"internalType\":
\"address\",\n \"name\": \"operator\",\n \"type\": \"address\"\n },\n {\n
\"indexed\": false,\n \"internalType\": \"bool\",\n \"name\": \"approved\",\n
\"type\": \"bool\"\n }\n ],\n \"name\": \"ApprovalForAll\",\n \"type\":
\"event\"\n },\n {\n \"anonymous\": false,\n \"inputs\": [\n {\n \"indexed\":
true,\n \"internalType\": \"address\",\n \"name\": \"from\",\n \"type\":
\"address\"\n },\n {\n \"indexed\": true,\n \"internalType\": \"address\",\n
\"name\": \"to\",\n \"type\": \"address\"\n },\n {\n \"indexed\": false,\n
\"internalType\": \"uint256[]\",\n \"name\": \"assetIds\",\n \"type\":
\"uint256[]\"\n },\n {\n \"indexed\": false,\n \"internalType\":
\"uint256[]\",\n \"name\": \"amounts\",\n \"type\": \"uint256[]\"\n }\n ],\n
\"name\": \"AssetTransferEvent\",\n \"type\": \"event\"\n },\n {\n
\"anonymous\": false,\n \"inputs\": [\n {\n \"indexed\": false,\n
\"internalType\": \"uint64\",\n \"name\": \"version\",\n \"type\": \"uint64\"\n
}\n ],\n \"name\": \"Initialized\",\n \"type\": \"event\"\n },\n {\n
\"anonymous\": false,\n \"inputs\": [\n {\n \"indexed\": true,\n
\"internalType\": \"address\",\n \"name\": \"previousOwner\",\n \"type\":
\"address\"\n },\n {\n \"indexed\": true,\n \"internalType\": \"address\",\n
\"name\": \"newOwner\",\n \"type\": \"address\"\n }\n ],\n \"name\":
\"OwnershipTransferred\",\n \"type\": \"event\"\n },\n {\n \"anonymous\":
false,\n \"inputs\": [\n {\n \"indexed\": true,\n \"internalType\":
\"address\",\n \"name\": \"operator\",\n \"type\": \"address\"\n },\n {\n
\"indexed\": true,\n \"internalType\": \"address\",\n \"name\": \"from\",\n
\"type\": \"address\"\n },\n {\n \"indexed\": true,\n \"internalType\":
\"address\",\n \"name\": \"to\",\n \"type\": \"address\"\n },\n {\n \"indexed\":
false,\n \"internalType\": \"uint256[]\",\n \"name\": \"ids\",\n \"type\":
\"uint256[]\"\n },\n {\n \"indexed\": false,\n \"internalType\":
\"uint256[]\",\n \"name\": \"values\",\n \"type\": \"uint256[]\"\n }\n ],\n
\"name\": \"TransferBatch\",\n \"type\": \"event\"\n },\n {\n \"anonymous\":
false,\n \"inputs\": [\n {\n \"indexed\": true,\n \"internalType\":
\"address\",\n \"name\": \"operator\",\n \"type\": \"address\"\n },\n {\n
\"indexed\": true,\n \"internalType\": \"address\",\n \"name\": \"from\",\n
\"type\": \"address\"\n },\n {\n \"indexed\": true,\n \"internalType\":
\"address\",\n \"name\": \"to\",\n \"type\": \"address\"\n },\n {\n \"indexed\":
false,\n \"internalType\": \"uint256\",\n \"name\": \"id\",\n \"type\":
\"uint256\"\n },\n {\n \"indexed\": false,\n \"internalType\": \"uint256\",\n
\"name\": \"value\",\n \"type\": \"uint256\"\n }\n ],\n \"name\":
\"TransferSingle\",\n \"type\": \"event\"\n },\n {\n \"anonymous\": false,\n
\"inputs\": [\n {\n \"indexed\": false,\n \"internalType\": \"string\",\n
\"name\": \"value\",\n \"type\": \"string\"\n },\n {\n \"indexed\": true,\n
\"internalType\": \"uint256\",\n \"name\": \"id\",\n \"type\": \"uint256\"\n }\n
],\n \"name\": \"URI\",\n \"type\": \"event\"\n },\n {\n \"anonymous\": false,\n
\"inputs\": [\n {\n \"indexed\": true,\n \"internalType\": \"address\",\n
\"name\": \"implementation\",\n \"type\": \"address\"\n }\n ],\n \"name\":
\"Upgraded\",\n \"type\": \"event\"\n },\n {\n \"inputs\": [],\n \"name\":
\"UPGRADE_INTERFACE_VERSION\",\n \"outputs\": [\n {\n \"internalType\":
\"string\",\n \"name\": \"\",\n \"type\": \"string\"\n }\n ],\n
\"stateMutability\": \"view\",\n \"type\": \"function\"\n },\n {\n \"inputs\":
[\n {\n \"internalType\": \"uint256\",\n \"name\": \"\",\n \"type\":
\"uint256\"\n }\n ],\n \"name\": \"assetToDetails\",\n \"outputs\": [\n {\n
\"internalType\": \"uint256\",\n \"name\": \"assetId\",\n \"type\":
\"uint256\"\n },\n {\n \"internalType\": \"string\",\n \"name\": \"name\",\n
\"type\": \"string\"\n },\n {\n \"internalType\": \"string\",\n \"name\":
\"symbol\",\n \"type\": \"string\"\n },\n {\n \"internalType\": \"uint256\",\n
\"name\": \"maxSupply\",\n \"type\": \"uint256\"\n },\n {\n \"internalType\":
\"uint256\",\n \"name\": \"faceValue\",\n \"type\": \"uint256\"\n },\n {\n
\"internalType\": \"uint256\",\n \"name\": \"maturityTimestamp\",\n \"type\":
\"uint256\"\n },\n {\n \"internalType\": \"string\",\n \"name\": \"assetUri\",\n
\"type\": \"string\"\n }\n ],\n \"stateMutability\": \"view\",\n \"type\":
\"function\"\n },\n {\n \"inputs\": [\n {\n \"internalType\": \"address\",\n
\"name\": \"account\",\n \"type\": \"address\"\n },\n {\n \"internalType\":
\"uint256\",\n \"name\": \"id\",\n \"type\": \"uint256\"\n }\n ],\n \"name\":
\"balanceOf\",\n \"outputs\": [\n {\n \"internalType\": \"uint256\",\n \"name\":
\"\",\n \"type\": \"uint256\"\n }\n ],\n \"stateMutability\": \"view\",\n
\"type\": \"function\"\n },\n {\n \"inputs\": [\n {\n \"internalType\":
\"address[]\",\n \"name\": \"accounts\",\n \"type\": \"address[]\"\n },\n {\n
\"internalType\": \"uint256[]\",\n \"name\": \"ids\",\n \"type\":
\"uint256[]\"\n }\n ],\n \"name\": \"balanceOfBatch\",\n \"outputs\": [\n {\n
\"internalType\": \"uint256[]\",\n \"name\": \"\",\n \"type\": \"uint256[]\"\n
}\n ],\n \"stateMutability\": \"view\",\n \"type\": \"function\"\n },\n {\n
\"inputs\": [\n {\n \"internalType\": \"uint256\",\n \"name\": \"assetId\",\n
\"type\": \"uint256\"\n },\n {\n \"internalType\": \"uint256\",\n \"name\":
\"amounts\",\n \"type\": \"uint256\"\n }\n ],\n \"name\": \"burn\",\n
\"outputs\": [],\n \"stateMutability\": \"nonpayable\",\n \"type\":
\"function\"\n },\n {\n \"inputs\": [\n {\n \"internalType\": \"uint256[]\",\n
\"name\": \"assetIds\",\n \"type\": \"uint256[]\"\n },\n {\n \"internalType\":
\"uint256[]\",\n \"name\": \"amounts\",\n \"type\": \"uint256[]\"\n }\n ],\n
\"name\": \"burnBatch\",\n \"outputs\": [],\n \"stateMutability\":
\"nonpayable\",\n \"type\": \"function\"\n },\n {\n \"inputs\": [\n {\n
\"internalType\": \"uint256\",\n \"name\": \"assetId\",\n \"type\":
\"uint256\"\n },\n {\n \"internalType\": \"string\",\n \"name\": \"name\",\n
\"type\": \"string\"\n },\n {\n \"internalType\": \"string\",\n \"name\":
\"symbol\",\n \"type\": \"string\"\n },\n {\n \"internalType\": \"uint256\",\n
\"name\": \"maxSupply\",\n \"type\": \"uint256\"\n },\n {\n \"internalType\":
\"uint256\",\n \"name\": \"faceValue\",\n \"type\": \"uint256\"\n },\n {\n
\"internalType\": \"uint256\",\n \"name\": \"maturityTimestamp\",\n \"type\":
\"uint256\"\n },\n {\n \"internalType\": \"string\",\n \"name\": \"assetUri\",\n
\"type\": \"string\"\n }\n ],\n \"name\": \"createAsset\",\n \"outputs\": [],\n
\"stateMutability\": \"nonpayable\",\n \"type\": \"function\"\n },\n {\n
\"inputs\": [\n {\n \"internalType\": \"uint256\",\n \"name\": \"id\",\n
\"type\": \"uint256\"\n }\n ],\n \"name\": \"exists\",\n \"outputs\": [\n {\n
\"internalType\": \"bool\",\n \"name\": \"\",\n \"type\": \"bool\"\n }\n ],\n
\"stateMutability\": \"view\",\n \"type\": \"function\"\n },\n {\n \"inputs\":
[],\n \"name\": \"initialize\",\n \"outputs\": [],\n \"stateMutability\":
\"nonpayable\",\n \"type\": \"function\"\n },\n {\n \"inputs\": [\n {\n
\"internalType\": \"address\",\n \"name\": \"account\",\n \"type\":
\"address\"\n },\n {\n \"internalType\": \"address\",\n \"name\":
\"operator\",\n \"type\": \"address\"\n }\n ],\n \"name\":
\"isApprovedForAll\",\n \"outputs\": [\n {\n \"internalType\": \"bool\",\n
\"name\": \"\",\n \"type\": \"bool\"\n }\n ],\n \"stateMutability\": \"view\",\n
\"type\": \"function\"\n },\n {\n \"inputs\": [\n {\n \"internalType\":
\"uint256\",\n \"name\": \"assetId\",\n \"type\": \"uint256\"\n },\n {\n
\"internalType\": \"uint256\",\n \"name\": \"amounts\",\n \"type\":
\"uint256\"\n },\n {\n \"internalType\": \"address\",\n \"name\":
\"recipient\",\n \"type\": \"address\"\n }\n ],\n \"name\": \"mint\",\n
\"outputs\": [],\n \"stateMutability\": \"nonpayable\",\n \"type\":
\"function\"\n },\n {\n \"inputs\": [\n {\n \"internalType\": \"uint256[]\",\n
\"name\": \"assetIds\",\n \"type\": \"uint256[]\"\n },\n {\n \"internalType\":
\"uint256[]\",\n \"name\": \"amounts\",\n \"type\": \"uint256[]\"\n },\n {\n
\"internalType\": \"address\",\n \"name\": \"recipient\",\n \"type\":
\"address\"\n }\n ],\n \"name\": \"mintBatch\",\n \"outputs\": [],\n
\"stateMutability\": \"nonpayable\",\n \"type\": \"function\"\n },\n {\n
\"inputs\": [],\n \"name\": \"owner\",\n \"outputs\": [\n {\n \"internalType\":
\"address\",\n \"name\": \"\",\n \"type\": \"address\"\n }\n ],\n
\"stateMutability\": \"view\",\n \"type\": \"function\"\n },\n {\n \"inputs\":
[],\n \"name\": \"proxiableUUID\",\n \"outputs\": [\n {\n \"internalType\":
\"bytes32\",\n \"name\": \"\",\n \"type\": \"bytes32\"\n }\n ],\n
\"stateMutability\": \"view\",\n \"type\": \"function\"\n },\n {\n \"inputs\":
[],\n \"name\": \"renounceOwnership\",\n \"outputs\": [],\n \"stateMutability\":
\"nonpayable\",\n \"type\": \"function\"\n },\n {\n \"inputs\": [\n {\n
\"internalType\": \"address\",\n \"name\": \"from\",\n \"type\": \"address\"\n
},\n {\n \"internalType\": \"address\",\n \"name\": \"to\",\n \"type\":
\"address\"\n },\n {\n \"internalType\": \"uint256[]\",\n \"name\": \"ids\",\n
\"type\": \"uint256[]\"\n },\n {\n \"internalType\": \"uint256[]\",\n \"name\":
\"values\",\n \"type\": \"uint256[]\"\n },\n {\n \"internalType\": \"bytes\",\n
\"name\": \"data\",\n \"type\": \"bytes\"\n }\n ],\n \"name\":
\"safeBatchTransferFrom\",\n \"outputs\": [],\n \"stateMutability\":
\"nonpayable\",\n \"type\": \"function\"\n },\n {\n \"inputs\": [\n {\n
\"internalType\": \"address\",\n \"name\": \"from\",\n \"type\": \"address\"\n
},\n {\n \"internalType\": \"address\",\n \"name\": \"to\",\n \"type\":
\"address\"\n },\n {\n \"internalType\": \"uint256\",\n \"name\": \"id\",\n
\"type\": \"uint256\"\n },\n {\n \"internalType\": \"uint256\",\n \"name\":
\"value\",\n \"type\": \"uint256\"\n },\n {\n \"internalType\": \"bytes\",\n
\"name\": \"data\",\n \"type\": \"bytes\"\n }\n ],\n \"name\":
\"safeTransferFrom\",\n \"outputs\": [],\n \"stateMutability\":
\"nonpayable\",\n \"type\": \"function\"\n },\n {\n \"inputs\": [\n {\n
\"internalType\": \"address\",\n \"name\": \"operator\",\n \"type\":
\"address\"\n },\n {\n \"internalType\": \"bool\",\n \"name\": \"approved\",\n
\"type\": \"bool\"\n }\n ],\n \"name\": \"setApprovalForAll\",\n \"outputs\":
[],\n \"stateMutability\": \"nonpayable\",\n \"type\": \"function\"\n },\n {\n
\"inputs\": [\n {\n \"internalType\": \"bytes4\",\n \"name\": \"interfaceId\",\n
\"type\": \"bytes4\"\n }\n ],\n \"name\": \"supportsInterface\",\n \"outputs\":
[\n {\n \"internalType\": \"bool\",\n \"name\": \"\",\n \"type\": \"bool\"\n }\n
],\n \"stateMutability\": \"view\",\n \"type\": \"function\"\n },\n {\n
\"inputs\": [],\n \"name\": \"totalSupply\",\n \"outputs\": [\n {\n
\"internalType\": \"uint256\",\n \"name\": \"\",\n \"type\": \"uint256\"\n }\n
],\n \"stateMutability\": \"view\",\n \"type\": \"function\"\n },\n {\n
\"inputs\": [\n {\n \"internalType\": \"uint256\",\n \"name\": \"id\",\n
\"type\": \"uint256\"\n }\n ],\n \"name\": \"totalSupply\",\n \"outputs\": [\n
{\n \"internalType\": \"uint256\",\n \"name\": \"\",\n \"type\": \"uint256\"\n
}\n ],\n \"stateMutability\": \"view\",\n \"type\": \"function\"\n },\n {\n
\"inputs\": [\n {\n \"internalType\": \"address\",\n \"name\": \"newOwner\",\n
\"type\": \"address\"\n }\n ],\n \"name\": \"transferOwnership\",\n \"outputs\":
[],\n \"stateMutability\": \"nonpayable\",\n \"type\": \"function\"\n },\n {\n
\"inputs\": [\n {\n \"internalType\": \"address\",\n \"name\":
\"newImplementation\",\n \"type\": \"address\"\n },\n {\n \"internalType\":
\"bytes\",\n \"name\": \"data\",\n \"type\": \"bytes\"\n }\n ],\n \"name\":
\"upgradeToAndCall\",\n \"outputs\": [],\n \"stateMutability\": \"payable\",\n
\"type\": \"function\"\n },\n {\n \"inputs\": [\n {\n \"internalType\":
\"uint256\",\n \"name\": \"id\",\n \"type\": \"uint256\"\n }\n ],\n \"name\":
\"uri\",\n \"outputs\": [\n {\n \"internalType\": \"string\",\n \"name\":
\"\",\n \"type\": \"string\"\n }\n ],\n \"stateMutability\": \"view\",\n
\"type\": \"function\"\n }\n ]\n\n}\n\nglobal.set('privateKey',
glbVar.privateKey);\nglobal.set('privateKeyAddress',glbVar.privateKeyAddress)\nglobal.set('contract',
glbVar.smartContract);\nglobal.set('accessToken',
glbVar.accessToken);\nglobal.set('rpcEndpoint',
glbVar.rpcEndpoint);\nglobal.set('abi',glbVar.abi)\n\nreturn msg;", "outputs":
1, "timeout": "", "noerr": 0, "initialize": "", "finalize": "", "libs": [], "x":
460, "y": 80, "wires": [ [ "a7c63a0fd0d1a779" ] ] } ]

5. Interact with the smart contract

The Integration Studio allows you to interact with your smart contract and add business logic. Go to the newly created Asset Tokenisation tab in the Integration Studio.

Asset Imported

The first function you need to complete is to set the global variables of the integration.

Set Global Variables

To do this, click on the middle item in the diagram labeled Set Global Variables. There you will you a variable called glbVar. Here is where you will enter the information to start interacting with your smart contract.

Set Global Variables

privateKey - Enter your private key that you created in Part 1 / Step 4
privateKeyAdress - The address created after completing Part 1 / Step 4
smartContract - The address of your deployed smart contract after completing Part 2 / Step 5
accessToken - The API key created when completing Part 3 / Step 3
rpcEndpoint - The JSON RPC URL that was shown when completing Part 3 / Step 2

With this information entered, click on the blue square next to the Inject item.

Now you need to create an asset by creating an asset name, asset symbol and assetUri.

Change Asset Name

To create an asset, double click on the Inject option next to the Initialise Asset item.

In this window you can set: msg.assetName - Bond msg.assetSymbol - BND msg.assetUri - The IPFS URL of the asset you created after completing Part 3 / Step 1

From here you can now click on the other inject options to:

Create an Asset
View the Asset
Mint the Asset
View the Balance

Asset Name

To see how the interactions with your smart contract, choose the Debug option under the deploy button.

What's next for your asset tokenization platform?

Congratulations! You've successfully deployed a production-ready asset tokenization platform that can handle enterprise-scale operations and deliver measurable business value.

Platform Ready

Your asset tokenization platform is now capable of handling $10M+ in tokenized assets with enterprise-grade security, compliance automation, and global accessibility.

Scaling and optimization opportunities

Advanced Features

Implement additional functionality for enhanced user experience

Cross-chain Compatibility: Enable trading across multiple blockchains
DeFi Integration: Connect with lending and yield farming protocols
Mobile Applications: Native iOS/Android apps for retail investors
Analytics Dashboard: Real-time performance and market insights

ROI Impact: Advanced features typically increase user engagement by 150-200%

Market Expansion

Scale to new asset classes and geographic markets

Additional Asset Types: Stocks, bonds, commodities, intellectual property
Institutional Features: Custody services, professional trading tools
Regulatory Compliance: Additional jurisdictions and regulatory frameworks
White-label Solutions: License platform to other businesses

Revenue Potential: Market expansion can increase total addressable market by 10-50x

Performance Optimization

Enhance platform efficiency and reduce costs

Layer 2 Integration: Reduce transaction costs by 90%+
API Optimization: Improve response times and throughput
Smart Contract Upgrades: Add new features and security enhancements
Infrastructure Scaling: Handle 10,000+ concurrent users

Cost Savings: Optimizations typically reduce operational costs by 30-60%

Measuring success and ROI

Track these key performance indicators to measure your platform's business impact:

Transaction Volume: Monthly token transfers and trading volume
User Growth: New investor registrations and platform adoption
Asset Utilization: Percentage of assets actively traded vs held
Cost Efficiency: Transaction costs vs traditional asset transfer methods
Revenue Generation: Platform fees, transaction fees, and service revenue

Success Benchmark: Leading asset tokenization platforms achieve $100M+ in tokenized assets within 2-3 years of launch.

Continue building with SettleMint

Explore additional use cases and advanced features to expand your blockchain platform capabilities:

Supply Chain Tokenization - Track and tokenize supply chain assets
NFT Marketplaces - Create digital collectible platforms
DeFi Integration - Connect with decentralized finance protocols
Enterprise Integration - Integrate with existing business systems

Next Steps: Most successful asset tokenization platforms expand into 2-3 additional use cases within their first year, multiplying their total addressable market and revenue potential.

Asset Tokenization