On this blog, we will share insights, updates, and deep dives into our latest launches and developments from a developer's perspective. Here, you'll find detailed information about our newest features, APIs, and technical improvements that power Synapse Protocol.

What to Expect​

Our blog posts will cover a range of topics, including:

• New feature launches and updates
• Technical deep dives into our architecture
• API documentation and usage guides
• Performance improvements and optimizations
• Developer tools and resources

Whether you're an integrator, a third-party developer, or just curious about the technical aspects of Synapse, this blog is for you.

Latest Articles​

Here's a list of our most recent tech blog posts:

• REST API Now Live - October 10, 2024 Learn about our new REST API, its features, and how it simplifies integration for developers.

Stay Connected​

To stay up-to-date with our latest tech developments:

• Follow us on Twitter
• Join our Discord
• Check out our GitHub

We're excited to share our journey with you as we continue to innovate and improve the Synapse Protocol. Happy reading!

What Changed​

We've migrated our package registry from npm to GitHub Packages. This affects the following packages:

• @synapsecns/sdk-router
• @synapsecns/synapse-constants
• @synapsecns/contracts-core
• @synapsecns/solidity-devops
• @synapsecns/coverage-aggregator
• @synapsecns/widget

How to Update Your Project​

To install @synapsecns packages from GitHub Packages, add a .npmrc file to the root of your project (next to your package.json):

@synapsecns:registry=https://npm.pkg.github.com

Then install packages as usual:

npm install @synapsecns/sdk-router
# or
yarn add @synapsecns/sdk-router

GitHub Packages requires authentication even for public packages. You can authenticate by adding your GitHub personal access token (with read:packages scope) to your .npmrc:

//npm.pkg.github.com/:_authToken=YOUR_GITHUB_TOKEN

Or set the environment variable:

export NPM_TOKEN=YOUR_GITHUB_TOKEN

Why the Move​

This migration consolidates our release infrastructure under GitHub, simplifying CI/CD and aligning package publishing with the repository where development happens.

Existing versions already published on the npm registry will remain available. All new versions will be published exclusively to GitHub Packages.

If you have any questions, feel free to open an issue on GitHub.

The Synapse Intent Network is a cross-chain communication protocol that enables seamless asset transfers and message passing between different blockchain networks. At its core, it provides a robust infrastructure for executing complex cross-chain operations while maintaining security and efficiency.

This major protocol upgrade represents a fundamental shift in the architecture, introducing intent-based routing, advanced bridging capabilities, and significant gas optimizations. The changes reflect a deeper focus on user experience while substantially improving the protocol's security, efficiency, and scalability.

Key Improvements At-A-Glance​

• Gas Optimization Revolution

  • Achieved 30-50% reduction in transaction costs through storage and execution improvements
  • Built-In Multicall allows efficient batching to save 21,000+ gas per operation

• Powerful Intent-Based Routing

  • New "Zap" architecture enables complex actions to be atomically executed after the intent is fulfilled
  • Reduces cross-contract calls
  • Allows for sophisticated bridging scenarios

• Exclusive Relayer Functionality

  • Intents can be assigned for exclusive fulfillment only by the Relayer who provided the best quote.
  • This eliminates wasteful on-chain competition while still incentivizing low fees and fast fills.

• Operational Flexibility

  • Relayers can now Relay, Prove, and Claim all from different addresses.
  • This offers throughput & efficiency improvements for advanced Relayers
  • Multiple Quoting options for relayers to choose from to maximize competitiveness

Synapse Intent Network: Technical Improvements​

Quoting and API Improvements​

The transition to the Synapse Intent Network brings significant changes to our quoting infrastructure, focusing on real-time price discovery and efficient market making. The most notable addition is active quoting alongside our existing passive quoting system.

Active Quoting​

Traditional passive quoting works like an order book - relayers post standing offers that users can take. While this model is simple and efficient for stable market conditions, it can lag during volatile periods. Active quoting addresses this limitation by enabling relayers to respond to quote requests in real-time:

// Example WebSocket quote request format
interface QuoteRequest {
  data: {
    origin_chain_id: number;
    dest_chain_id: number;
    origin_token_addr: string;
    dest_token_addr: string;
    origin_amount_exact: string;
    expiration_window: number;
  }
}

This hybrid approach gives relayers flexibility in their market-making strategies. Simple integrations can stick with passive quoting, while sophisticated relayers can implement dynamic pricing models that account for immediate market conditions, liquidity depth, and cross-chain gas costs.

WebSocket API Evolution​

Supporting this new quoting model required rethinking our API infrastructure. The new WebSocket layer eliminates the need for polling and complex state management:

const operations = {
  subscribe: "Subscribe to specific chains",
  send_quote: "Respond to quote request",
  request_quote: "New quote request notification"
}

The real-time nature of WebSockets dramatically reduces quote latency. Rather than repeatedly querying for updates, relayers receive instant notifications about new opportunities. This improved efficiency translates directly to better pricing for end users as relayers can operate with tighter spreads.

Contract Improvements​

Gas Optimizations​

A core focus of V2 was reducing transaction costs without sacrificing code clarity. Through careful struct packing and custom error implementations, we've achieved significant gas savings:

struct BridgeTxDetails {
    BridgeStatus status;           // 1 byte
    uint32 destChainId;           // 4 bytes
    uint16 proverID;              // 2 bytes
    uint40 proofBlockTimestamp;   // 5 bytes
    address proofRelayer;         // 20 bytes
} // Total: 32 bytes (1 slot)

These optimizations balance efficiency with maintainability. While more aggressive packing was possible, it would have made the code significantly harder to reason about. The current implementation provides meaningful gas savings while keeping the codebase approachable for new developers.

Atomic Operations with Multicall and Zaps​

Cross-chain operations often require multiple transactions. V2 introduces multicall support and a new Zap interface to address this friction:

// Multicall enables efficient batching
fastBridge.multicallNoResults([
    abi.encodeCall(IFastBridge.prove, (request1)),
    abi.encodeCall(IFastBridge.claim, (request1))
], false);

// Zaps enable complex atomic operations
interface IZapRecipient {
    function zap(
        address token,
        uint256 amount,
        bytes memory zapData
    ) external payable returns (bytes4);
}

The Zap interface is intentionally minimal, maximizing composability while maintaining security. It enables powerful workflows like "bridge and stake" or "bridge and provide liquidity" in a single atomic transaction. These compound operations significantly improve the user experience by reducing transaction overhead and eliminating partial execution risks.

Final Thoughts​

The Synapse Intent Network (FastBridgeV2) update represents a thoughtful evolution of our protocol. Each change was evaluated not just for its immediate benefits, but for its long-term impact on protocol composability and user experience. The result is a more efficient, developer-friendly, and user-centric cross-chain bridging system. Please reach out to us if you have any questions or feedback.

Last week, we launched the Synapse REST API: api.synapseprotocol.com. The new update is key in making Synapse easier to integrate for applications.

Summary​

The REST API is a restful interface for applications to query, construct, and initiate cross-chain transactions. The service comes with supporting modules for querying liquidity, transaction status, and more. The aim of the API is to enable applications to integrate cross-chain functionality through an API call.

Why it Matters​

The REST API makes it significantly easier for aggregators to integrate with the Synapse Bridge, complete with supplementary modules for returning key information like transaction status to users , as well as standardizing and sanitizing inputs and outputs. Rather than interact with complex contracts, aggregators can interact with a simple /bridge endpoint.

The REST API is also built with third-party developers in mind. Many people run external services around the Synapse Bridge: from arbitrage bots, to on-chain AI agents. The REST API makes it much simpler to interact with the Synapse Bridge from any environment, with just an http request. Third party developers also don't have to sacrifice complexity.

Challenges​

When building the REST API we ran into a couple challenges that have created a more robust developer experience.

Standardizing Constants: We needed a set of constants to verify all inputs against, so that users did not attempt to bridge or swap with unsupported assets/chains. This launch gave us the chance to standardize the Synapse Constants library, and extend this library throughout other services.

Liquidity Warnings: When bridging programmatically, it's harder to identify abnormalities, thus we added different endpoints to help applications retrieve liquidity parameters before bridging. Responses also include detailed information about what the expected amount will be.

Launch Details​

Structurally, the REST API is a wrapper around the Synapse SDK – the primary abstraction of the Synapse Contracts. The modules allow users to swap, bridge, and a host of other supporting functions. This level of abstraction is key for applications that want to interact with the Synapse Contracts from any framework, in a standardized manner.

This update incorporated the addition of new methods to support aggregator integrations such as:

/bridgeTxStatus Enables developers to retrieve the status of any bridge transaction. Helpful for debugging as well as providing transaction level information to the user.

/destinationTokens Returns a list of tokens that can be bridged to (given an input token), giving developers clarity on where they can bridge to.

/bridgeLimits Returns a max/min amount of tokens to be bridged, giving an accurate representation of liquidity for any possible bridge route.

Other main changes include:

• Standardized RESTful responses, eliminated mixed response types (Markup and JSON) to now consistently return JSON for all endpoints.
• Enhanced error handling using input validations with express-validator, middleware for error handling. Includes checks for unsupported chains, bridge modules, tokens and a friendly error message indicating specific error messages.
• Architectural improvements including a traditional MVC approach, separating routes and controllers, improved code readability and organization, so we can easily compose new routes
• Development workflow updates, like yarn dev which has hot reloading so we don't need to manually stop and restart the server during development

Swagger documentation was also included in the latest release to assist developer onboarding.