CROSSINCH+

CROSSINCH+ is a Atomic swap platform used to transfer XLM (Stellar's native token) and ETH (Ethereum's native token) between the Stellar and Ethereum blockchains using atomic swaps. It extends the 1Inch Limit Order Protocol (LOP) for Ethereum, for cross-chain operations using LimitOrderBuilder and deploying a contract to interact with stellar scripts parameters named HTLCPredicate within LOP, while implementing HTLC smart contract for Stellar to handle XLM transfers. The current resolvers are custom built for implementation.

Core System Cross-Chain Bridge: Moves tokens (XLM ETH) between Stellar and Ethereum Holesky Atomic Safety: Guarantees either both transfers complete or both fail - no stuck funds Frontend Integration: React interface for user-friendly swap execution Bridge Server: 1inch LOP LimitBuilder that coordinates cross-chain operations with HTLC contracts.

Technical Architecture
Flow: Frontend → Bridge Server → Cross-Chain Script → Blockchain ContractsStellar Side:

• Uses your Hashlock hex preimage format
• contract calls with proper contractInt implementation
• Event extraction for swapId from blockchain
• SHA256-based hashlock validation

Ethereum Side:

• Uses standard ethers.js UTF-8 format
• HTLC predicate registration and validation
• ETH Holesky transfers between wallets
• Keccak256-based hashlock validation

What Actually HappensUser enters amounts Bridge server receives request and spawns transfer script Stellar: XLM gets locked in HTLC contract Ethereum: HTLC predicate gets registered with hashlock Stellar: User claims XLM, revealing secret on blockchain Ethereum: User claims ETH using revealed secret Result: Tokens moved atomically between chains

1INCH SIDE:

What You Do: Create a Limit Order The relayer/maker signs a 1inch limit order offering ETH, using a custom HTLC predicate.

Use an HTLC Predicate The order’s validity depends on:

The user revealing a valid preimage

The claim happening before a timelock

This logic is enforced in your HTLCPredicate.sol contract.

User Claims Stellar Swap → Gets Preimage The user first claims tokens on Stellar using the secret.

Fill 1inch Order Using Preimage The user (taker) uses LimitOrderProtocol.fillOrder(...) and supplies the preimage as interaction.

Predicate Verifies → ETH Released If the predicate approves (preimage matches, not expired), ETH is transferred to the user.

1)Used LimitOrderBuilder.buildLimitOrder() by one-inch which handles all the struct formatting and ABI encoding needed to match one-inch LOPs smart contract's requirements. This is the first time it has been implemented for stellar chain.

1. We extended the limit-order-protocol on oneinch at evm side by deploying a contract which interacts with oneinch and stellar parameters.

2. We used stellar's timelock and hashlock contract functionality to preserve transaction credentials and allows for secure transfer and claim untill the preimage and hash has been passed.

3. The type parameters for Ethereum and Stellar are complete opposite it was a nightmare to have them defined, build, deployed and work but without compromising flow of funds we did that.

5)Smart Contracts:

Solidity: HTLC Predicate contract extending 1inch LOP Rust: Stellar HTLC smart contract (Soroban) 1inch LOP v4: Base limit order protocol

6)Backend:

Node.js: Cross-chain bridge logic and API endpoints Ethers.js: Ethereum blockchain interaction Stellar SDK: Stellar network integration Express.js: REST API for price feeds and swap execution

1. CoinMarketCap for live price updates of XLM and ETH tokens.