Embedded Payments
Coming Soon
Ecosystem
Coming Soon
Developer
Coming Soon
Community

The Interoperability Protocol for Real-World Transactions

On-chain native real-world interoperability, enabling dApps
to leverage the best of both Web3 and Web2
Join Waitlist

Powering Real‑World Interoperability

Trensi is an interoperability protocol connecting Blockchain to real‑world APIs, natively on‑chain

Blockchain Native Real‑World Interoperability

Access Web2 development tools to build dApps that securely interact with Web2 APIs natively on‑chain
01011010100101010 01011010100101010

Connect to Global Payment APIs

Seamlessly bridge traditional and decentralized finance by connecting with global Web2 payment flows & capabilities natively on‑chain
1001010011010100 0101101010010101

Create Cutting‑Edge User Experiences

Redefine Web3 user experiences by breaking down barriers between Web2 and Web3, creating unified user journeys & experiences

Craft Next-Gen On-Chain dApps

Build Game-Changing dApps

Transform your dApps with disruptive solutions, innovative features and enhanced user experiences, leveraging the best of Web3 alongside the versatility and reach of Web2

Unprecedented Real-World Interoperability

Enhance your dApp with real-time communication and integration with Web2 APIs. Customize connections, security, compliance and rules within an open and decentralized framework

Tailored for On-Chain Finance

Meeting the unique demands and regulatory standards of global finance, by delivering specialized data security, and compliance solutions along with an asynchronous and secure transaction flow

Safe and Secure Architecture

With formidable transaction validation, data security, and verification through a robust Decentralized Attestation Network, security is emphasized throughout Trensi’s architecture

Making Real-World Interoperability Simple, Secure & Programable

Setup dApp Setup RPC Server Build Own REST API Create Tx Catch Tx Make API Call Receive Response Connect to RPC Server Submit Response Back to dApp Connect to Gateway Setup Pipeline Create Tx Receive Response

Work with any form of Money

Unleash the full capability of your smart contracts. Build dApps that work with any form of money

Global Rails & Currencies

Expand your user base by integrating with global payment rails and supporting a variety of local fiat currencies

Beyond Conventional Boundaries

Take your payments further - accept stablecoins, credit cards, SWIFT transactions, or any combination of these methods, natively on-chain

Ecosystem

Backed by top global institutions and a growing ecosystem, Trensi redefines the integration, interoperability and composability of on-chain and off-chain services and functionality

Expanding the Reach of Blockchain

Trensi enables smart contracts to do more, giving developers the power to drive innovation & cutting-edge user experiences, natively on-chain
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
pragma solidity ^0.8.24;

contract RemmitancePayment {
    IGateway public immutable gateway;
    address public responseContract;

    function makePayment(
        bytes32 pid_,
        uint256 amount_,
        string memory accountTo_,
        string memory accountFrom_,
        string memory currencyFrom_,
        string memory currencyTo_,
    ) external returns (Structs.MessagingReceipt memory) {
        string memory message = abi.encodePacked(
            amount_,
            accountFrom_,
            accountTo_,
            currencyFrom_,
            currencyTo_
        );
        return
            gateway.send{value: msg.value}(
                IGateway.ReqParams({
                    pid: pid_,
                    receiver: responseContract,
                    reqBody: bytes(message)
                })
            );
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
pragma solidity ^0.8.24;

contract EURAccount {
    IGateway public immutable gateway;
    address public responseContract;

    function getEurBalance(
        string memory id_,
        bytes32 pid_
    ) external returns (Structs.MessagingReceipt memory) {
        string memory message = abi.encodePacked(id_);
        return
            gateway.send{value: msg.value}(
                IGateway.ReqParams({
                    pid: pid_,
                    receiver: responseContract,
                    reqBody: bytes(message)
                })
            );
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
pragma solidity ^0.8.24;

contract Token is ERC20 {
    IGateway public immutable gateway;
    address public responseContract;
    bytes32 public pid;

    function tokenTransfer(
        address to,
        uint256 value
    ) external returns (Structs.MessagingReceipt memory) {
        transfer(to, value);
        string memory message = string(
            abi.encodePacked(
                "Successful transfer of ",
                value_.toString(),
                " from ",
                Strings.toHexString(_msgSender()),
                " to ",
                Strings.toHexString(to_)
            )
        );
        return
            gateway.send{value: msg.value}(
                IGateway.ReqParams({
                    pid: pid,
                    receiver: responseContract,
                    reqBody: bytes(message)
                })
            );
    }
}

Join the Trensi Community

© 2024 Trensi
Privacy Policy Teams Conditions