External Developer Guide

Become External Developer

To begin using the Photon messaging or DataStream protocol, please reach out to Entangle to undergo the KYC process and become registered as an external developer.

Contracts Preparation Guide

To utilize the Photon messaging or DataStream protocol, an external developer must ensure their smart contracts are compatible with the Endpoint contract.

This contract has the following interface for proposing omni-chain operations:

/// @notice function of emitting event Propose for catching by receivers
    /// @param protocolId protocol id to interact
    /// @param dstChainId dest chain id
    /// @param protocolAddress dest protocol address is bytes32 cause dstChainId may be non-EVM
    /// @param functionSelector dest protocol function id, for EVM is encoded abi func selector, for non-EVM may be func signature or whole func name
    /// @param params function params for dest protocol function
    function propose(
        bytes32 protocolId,
        uint256 dstChainId,
        bytes calldata protocolAddress,
        bytes calldata functionSelector,
        bytes calldata params
    ) external isAllowedProposer(protocolId)

The smart contract on the destination chain will be capable of processing the following call:

(bool success, bytes memory ret) = protocolAddress.call{value: msg.value}(
                abi.encodeWithSelector(
                    selector,
                    abi.encode(
                        opData.protocolId,
                        opData.srcChainId,
                        opData.srcBlockNumber,
                        opData.srcOpTxId,
                        opData.params
                    )
                )
            );

Protocol Configuration Guide - Configuring with External Developer Hub contract

To create your protocol X within the ExternalDeveloperHub contract, you should set up the following parameters (note that all values are provided as examples, and it's mandatory to deploy at least one manual Receiver Agent, also known as a Transmitter, for your protocol):

const MANUAL_TRANSMITTERS = ["address1", "address2"];
    const transmittersParams: TransmittersParams = {
        maxTransmitters: 10,
        minDelegateAmount: ethers.utils.parseUnits("100", "ether"),
        minPersonalAmount: ethers.utils.parseUnits("10", "ether"),
    }
    const protocolParams: ProtocolParams = {
        msgBetAmount: ethers.utils.parseUnits("0.001", "ether"),
        dataBetAmount: ethers.utils.parseUnits("0.0001", "ether"),
        msgBetReward: ethers.utils.parseUnits("0.002", "ether"),
        dataBetReward: ethers.utils.parseUnits("0.0002", "ether"),
        msgBetFirstReward: ethers.utils.parseUnits("0.004", "ether"),
        dataBetFirstReward: ethers.utils.parseUnits("0.0004", "ether"),
        consensusTargetRate: CONSENSUS_TARGET_RATE
    };

To proceed with setting up your protocol, you'll need to add the protocol address on the destination chain where the data is intended to be delivered:

await protocol.addProtocolAddressEvm(CHAIN_ID, protocolContractAddress);

If it's the first time you are adding a protocol or proposer address to a new chain, you should wait until your protocol is initialized on the chain.

await protocol.waitProtocoloInitForChainId(CHAIN_ID, undefined, retries);

For Photon messaging protocol to work it is also needed to set at least one proposer address:

 await protocol.addProposerAddressEvm(CHAIN_ID, proposerContractAddress);

Deploy own Executor agent and add it too:

await protocol.addExecutorEvm(CHAIN_ID, executorAddress);

(Link to full code snippet)

Deposit NGL for protocol fees and receiver rewards.

Once all setups are completed, external developers must supply their address with $NGL tokens by approving and depositing them into the ExternalDeveloperHub contract:

  /// @notice Deposit NGL to protocol balance
    /// @param _protocolId - Protocol id
    /// @param _amount - Amount of NGL to deposit
    function deposit(bytes32 _protocolId, uint _amount) external protocolOwner(_protocolId)

Contract Deploying Guide – Not Required For Photon Messaging

In DataStream integration, the next step involves deploying the StreamDataSpotter contract via the StreamDataFactory contract using your specific parameters. This can be achieved by making a call.

    /// @notice Deploy spotter contract for the new sourceID
    /// @param protocolId protocol id
    /// @param sourceId source id
    /// @param processingLib address of deployed processing lib contract to be used for that spotter
    /// @param consensusRate consensus rate of agents necessary for update to happend
    /// @param allowedKeys array of allowed data keys, only existing datakeys can be used to vote the data for
    function deployNewStreamDataSpotter(
        bytes32 protocolId,
        bytes32 sourceId,
        address processingLib,
        uint256 consensusRate,
        uint256 minFinalizationInterval,
        bytes32[] calldata allowedKeys
    ) public onlyProtocolOwner(protocolId) returns (address)

Please note that these contracts are on the Entangle Oracle blockchain, so bridging some $NGL tokens is required to proceed.