Specialized Relayer

Last updated 1 year ago

Was this helpful?

Specialized Relayer

Wormhole is compatible with many and integration is straight forward.

On Chain

Sending a message

// ...

IWormhole wormhole = IWormhole(wormholeAddr);

// Get the fee for publishing a message
uint256 wormholeFee = wormhole.messageFee();

// ... fee/value checks

// create the HelloWorldMessage struct
HelloWorldMessage memory parsedMessage = HelloWorldMessage({
    payloadID: uint8(1),
    message: helloWorldMessage
});

// encode the HelloWorldMessage struct into bytes
bytes memory encodedMessage = encodeMessage(parsedMessage);

// Send the HelloWorld message by calling publishMessage on the
// Wormhole core contract and paying the Wormhole protocol fee.
messageSequence = wormhole.publishMessage{value: wormholeFee}(
    0, // batchID
    encodedMessage,
    wormholeFinality()
);

Using the wormhole_anchor_sdk::wormhole module and given the wormhole program account, we can pass a message directly to the core contract.

// ...

let fee = ctx.accounts.wormhole_bridge.fee();
// ... fee check/send

let config = &ctx.accounts.config;
let payload: Vec<u8> = HelloWorldMessage::Hello { message }.try_to_vec()?;

// Invoke `wormhole::post_message`.
wormhole::post_message(
    CpiContext::new_with_signer(
        ctx.accounts.wormhole_program.to_account_info(),
        wormhole::PostMessage {
            // ... set fields
        },
        &[
            // ... set seeds
        ],
    ),
    config.batch_id,
    payload,
    config.finality.into(),
)?;

// ...

Receiving a message

The way a message may be received depends on the environment.

On EVM chains, the message passed is the raw VAA encoded as binary.

It has not been verified by the core contract and should be treated as untrusted input until parseAndVerifyVM has been called.

function receiveMessage(bytes memory encodedMessage) public {
    // call the Wormhole core contract to parse and verify the encodedMessage
    (
        IWormhole.VM memory wormholeMessage,
        bool valid,
        string memory reason
    ) = wormhole().parseAndVerifyVM(encodedMessage);

    // ... safety checks

    // decode the message payload into the HelloWorldMessage struct
    HelloWorldMessage memory parsedMessage = decodeMessage(
        wormholeMessage.payload
    );

    // ... do something cool
}

On Solana, the VAA is first posted and verified by the core contract, after which it can be read by the receiving contract and action taken.

pub fn receive_message(ctx: Context<ReceiveMessage>, vaa_hash: [u8; 32]) -> Result<()> {
    let posted_message = &ctx.accounts.posted;

    if let HelloWorldMessage::Hello { message } = posted_message.data() {
        // ... check message
        // ... do something cool 
        // Done
        Ok(())
    } else {
        Err(HelloWorldError::InvalidMessage.into())
    }
}

Emitter: Is this coming from an emitter address and chain id I expect? Typically contracts will provide a method to register a new emitter and check the incoming message against the set of emitters it trusts.
Sequence: Is this the sequence number I expect? How should I handle out of order deliveries?

Outside of body of the VAA, but also relevant, is the digest of the VAA which can be used for replay protection by checking if the digest has already been seen.

Since the payload itself is application specific, there may be other elements to check to ensure safety.

Off Chain

After enough Guardians have signed the message (at least 2/3 + 1 or 13 of 19 guardians), the VAA is available to be delivered to a target chain.