internet-court/internet-court-skill / vendored/sendaifun/debridge
debridge
VerifiedComplete deBridge Protocol SDK for building cross-chain bridges, message passing, and token transfers on Solana. Use when building cross-chain applications, bridging assets between Solana and EVM chains, or implementing trustless external calls.
| File | Kind | Size |
|---|---|---|
| LICENSE | other | 11.1 KB |
| SKILL.md | skill md | 19.2 KB |
| docs/troubleshooting.md | markdown | 9.5 KB |
| examples/basic-transfer/README.md | markdown | 12.3 KB |
| examples/external-calls/README.md | markdown | 13.5 KB |
| examples/fee-configurations/README.md | markdown | 13.5 KB |
| examples/message-passing/README.md | markdown | 14.5 KB |
| resources/chain-ids.md | markdown | 5.1 KB |
| resources/error-codes.md | markdown | 9.2 KB |
| resources/program-ids.md | markdown | 7.5 KB |
| resources/sdk-api-reference.md | markdown | 10.8 KB |
examples/message-passing/README.md
View on GitHub# Message Passing Example
Send arbitrary messages across chains without token transfers using deBridge.
## Overview
deBridge Message Passing enables:
- Cross-chain communication without token transfers
- Arbitrary data transmission between blockchains
- Trustless message verification on destination
- Integration with cross-chain governance, oracles, etc.
## Rust Program
### Message Sender
```rust
use anchor_lang::prelude::*;
use debridge_solana_sdk::prelude::*;
use debridge_solana_sdk::sending::{SendIx, SendSubmissionParamsInput, invoke_send_message};
use debridge_solana_sdk::flags::{SetReservedFlag, REVERT_IF_EXTERNAL_FAIL};
declare_id!("YourProgramId11111111111111111111111111111");
#[program]
pub mod message_passing {
use super::*;
/// Send a message to another chain
///
/// # Arguments
/// * `target_chain_id` - Destination chain
/// * `receiver` - Contract to receive the message (20 bytes for EVM)
/// * `message` - Arbitrary message data
/// * `execution_fee` - Fee for message delivery
pub fn send_message(
ctx: Context<SendMessage>,
target_chain_id: [u8; 32],
receiver: Vec<u8>,
message: Vec<u8>,
execution_fee: u64,
) -> Result<()> {
require!(!message.is_empty(), ErrorCode::EmptyMessage);
// Compute message hash
let message_hash = solana_program::keccak::hash(&message).to_bytes();
// Configure flags
let mut flags = [0u8; 32];
flags.set_reserved_flag(REVERT_IF_EXTERNAL_FAIL);
let submission_params = SendSubmissionParamsInput {
execution_fee,
flags,
fallback_address: vec![], // No fallback for messages
external_call_shortcut: message_hash,
};
invoke_send_message(
SendIx {
target_chain_id,
receiver,
is_use_asset_fee: false,
amount: 0, // No token transfer
submission_params: Some(submission_params),
referral_code: None,
},
ctx.remaining_accounts,
)?;
emit!(MessageSent {
sender: ctx.accounts.sender.key(),
target_chain: target_chain_id,
message_hash,
nonce: ctx.accounts.nonce_counter.nonce,
});
// Increment nonce
ctx.accounts.nonce_counter.nonce += 1;
Ok(())
}
/// Send a governance proposal cross-chain
pub fn send_governance_proposal(
ctx: Context<SendGovernance>,
target_chain_id: [u8; 32],
governance_contract: Vec<u8>,
proposal_id: u64,
actions: Vec<GovernanceAction>,
) -> Result<()> {
// Serialize proposal data
let proposal_data = serialize_proposal(proposal_id, &actions)?;
let message_hash = solana_program::keccak::hash(&proposal_data).to_bytes();
let mut flags = [0u8; 32];
flags.set_reserved_flag(REVERT_IF_EXTERNAL_FAIL);
let submission_params = SendSubmissionParamsInput {
execution_fee: 0,
flags,
fallback_address: vec![],
external_call_shortcut: message_hash,
};
invoke_send_message(
SendIx {
target_chain_id,
receiver: governance_contract,
is_use_asset_fee: false,
amount: 0,
submission_params: Some(submission_params),
referral_code: None,
},
ctx.remaining_accounts,
)?;
Ok(())
}
/// Send oracle price update
pub fn send_oracle_update(
ctx: Context<SendOracle>,
target_chain_id: [u8; 32],
oracle_contract: Vec<u8>,
price_feed_id: [u8; 32],
price: i128,
confidence: u64,
timestamp: i64,
) -> Result<()> {
// Serialize oracle data
let oracle_data = serialize_oracle_update(
price_feed_id,
price,
confidence,
timestamp,
)?;
let message_hash = solana_program::keccak::hash(&oracle_data).to_bytes();
let submission_params = SendSubmissionParamsInput {
execution_fee: 0,
flags: [0u8; 32],
fallback_address: vec![],
external_call_shortcut: message_hash,
};
invoke_send_message(
SendIx {
target_chain_id,
receiver: oracle_contract,
is_use_asset_fee: false,
amount: 0,
submission_params: Some(submission_params),
referral_code: None,
},
ctx.remaining_accounts,
)?;
Ok(())
}
}
fn serialize_proposal(proposal_id: u64, actions: &[GovernanceAction]) -> Result<Vec<u8>> {
let mut data = Vec::new();
// Message type identifier
data.push(0x01); // GOVERNANCE_PROPOSAL
// Proposal ID
data.extend_from_slice(&proposal_id.to_be_bytes());
// Number of actions
data.extend_from_slice(&(actions.len() as u32).to_be_bytes());
// Serialize each action
for action in actions {
data.extend_from_slice(&action.target);
data.extend_from_slice(&action.value.to_be_bytes());
data.extend_from_slice(&(action.calldata.len() as u32).to_be_bytes());
data.extend_from_slice(&action.calldata);
}
Ok(data)
}
fn serialize_oracle_update(
feed_id: [u8; 32],
price: i128,
confidence: u64,
timestamp: i64,
) -> Result<Vec<u8>> {
let mut data = Vec::new();
// Message type identifier
data.push(0x02); // ORACLE_UPDATE
// Feed ID
data.extend_from_slice(&feed_id);
// Price (as bytes)
data.extend_from_slice(&price.to_be_bytes());
// Confidence
data.extend_from_slice(&confidence.to_be_bytes());
// Timestamp
data.extend_from_slice(×tamp.to_be_bytes());
Ok(data)
}
#[derive(Accounts)]
pub struct SendMessage<'info> {
#[account(mut)]
pub sender: Signer<'info>,
#[account(
mut,
seeds = [b"nonce", sender.key().as_ref()],
bump,
)]
pub nonce_counter: Account<'info, NonceCounter>,
pub system_program: Program<'info, System>,
}
#[derive(Accounts)]
pub struct SendGovernance<'info> {
#[account(mut)]
pub governance_authority: Signer<'info>,
pub system_program: Program<'info, System>,
}
#[derive(Accounts)]
pub struct SendOracle<'info> {
#[account(mut)]
pub oracle_authority: Signer<'info>,
pub system_program: Program<'info, System>,
}
#[account]
pub struct NonceCounter {
pub nonce: u64,
}
#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
pub struct GovernanceAction {
pub target: [u8; 20], // Target contract
pub value: u64, // ETH value
pub calldata: Vec<u8>, // Function call data
}
#[event]
pub struct MessageSent {
pub sender: Pubkey,
pub target_chain: [u8; 32],
pub message_hash: [u8; 32],
pub nonce: u64,
}
#[error_code]
pub enum ErrorCode {
#[msg("Message cannot be empty")]
EmptyMessage,
#[msg("Invalid governance action")]
InvalidGovernanceAction,
}
```
### Message Receiver (Solana)
```rust
use anchor_lang::prelude::*;
use debridge_solana_sdk::check_claiming::*;
#[program]
pub mod message_receiver {
use super::*;
/// Receive and process a cross-chain message
pub fn receive_message(
ctx: Context<ReceiveMessage>,
expected_source_chain: [u8; 32],
expected_sender: Vec<u8>,
) -> Result<()> {
// Validate the claim instruction
let claim_ix = ValidatedExecuteExtCallIx::try_from_current_ix()?;
let validation = SubmissionAccountValidation {
source_chain_id_validation: Some(expected_source_chain),
native_sender_validation: Some(expected_sender),
receiver_validation: Some(ctx.accounts.receiver.key()),
..Default::default()
};
claim_ix.validate_submission_account(
&ctx.accounts.submission_account,
&validation,
)?;
// Message is now verified, process it
emit!(MessageReceived {
source_chain: expected_source_chain,
receiver: ctx.accounts.receiver.key(),
});
Ok(())
}
/// Receive governance proposal
pub fn receive_governance(
ctx: Context<ReceiveGovernance>,
source_chain: [u8; 32],
authorized_sender: Vec<u8>,
) -> Result<()> {
let claim_ix = ValidatedExecuteExtCallIx::try_from_current_ix()?;
let validation = SubmissionAccountValidation {
source_chain_id_validation: Some(source_chain),
native_sender_validation: Some(authorized_sender),
..Default::default()
};
claim_ix.validate_submission_account(
&ctx.accounts.submission_account,
&validation,
)?;
// Process governance action
// The message data would be parsed and executed here
Ok(())
}
}
#[derive(Accounts)]
pub struct ReceiveMessage<'info> {
pub receiver: Signer<'info>,
/// CHECK: Validated in instruction
pub submission_account: AccountInfo<'info>,
}
#[derive(Accounts)]
pub struct ReceiveGovernance<'info> {
pub governance_executor: Signer<'info>,
/// CHECK: Validated in instruction
pub submission_account: AccountInfo<'info>,
}
#[event]
pub struct MessageReceived {
pub source_chain: [u8; 32],
pub receiver: Pubkey,
}
```
## TypeScript Client
### Send Message
```typescript
import { Program, BN } from '@coral-xyz/anchor';
import { PublicKey, Keypair } from '@solana/web3.js';
import { keccak256 } from '@ethersproject/keccak256';
async function sendMessage(
program: Program,
sender: Keypair,
targetChainId: number[],
receiver: string,
message: Uint8Array,
executionFee: bigint,
) {
const receiverBytes = ethers.getBytes(receiver);
const debridgeAccounts = await deriveDeBridgeAccounts(
program.provider.connection,
sender.publicKey,
targetChainId
);
const [nonceCounter] = PublicKey.findProgramAddressSync(
[Buffer.from('nonce'), sender.publicKey.toBuffer()],
program.programId
);
const tx = await program.methods
.sendMessage(
targetChainId,
Buffer.from(receiverBytes),
Buffer.from(message),
new BN(executionFee.toString()),
)
.accounts({
sender: sender.publicKey,
nonceCounter,
systemProgram: SystemProgram.programId,
})
.remainingAccounts(buildRemainingAccounts(debridgeAccounts))
.signers([sender])
.rpc();
return tx;
}
```
### Message Encoding Examples
```typescript
// Generic message
function encodeMessage(type: number, payload: Uint8Array): Uint8Array {
const result = new Uint8Array(1 + payload.length);
result[0] = type;
result.set(payload, 1);
return result;
}
// Governance message
function encodeGovernanceMessage(
proposalId: bigint,
actions: Array<{target: string; value: bigint; data: Uint8Array}>
): Uint8Array {
const encoder = new ethers.AbiCoder();
const encodedActions = actions.map(a => ({
target: a.target,
value: a.value,
data: a.data,
}));
const encoded = encoder.encode(
['uint256', 'tuple(address,uint256,bytes)[]'],
[proposalId, encodedActions]
);
return ethers.getBytes(encoded);
}
// Oracle update message
function encodeOracleMessage(
feedId: Uint8Array,
price: bigint,
confidence: bigint,
timestamp: bigint
): Uint8Array {
const encoder = new ethers.AbiCoder();
const encoded = encoder.encode(
['bytes32', 'int256', 'uint256', 'uint256'],
[feedId, price, confidence, timestamp]
);
return ethers.getBytes(encoded);
}
```
## Use Cases
### 1. Cross-Chain Governance
```typescript
// Send a governance proposal from Solana to Ethereum
const proposal = {
id: 42n,
actions: [
{
target: '0x1234...', // Treasury contract
value: 0n,
data: encodeTransferCall(recipient, amount),
}
],
};
const message = encodeGovernanceMessage(proposal.id, proposal.actions);
await sendMessage(program, authority, CHAIN_IDS.ETHEREUM, governanceContract, message, executionFee);
```
### 2. Cross-Chain Oracle
```typescript
// Push price data from Solana to Ethereum
const priceUpdate = {
feedId: SOL_USD_FEED_ID,
price: 10050000000n, // $100.50 with 8 decimals
confidence: 5000000n,
timestamp: BigInt(Date.now()),
};
const message = encodeOracleMessage(
priceUpdate.feedId,
priceUpdate.price,
priceUpdate.confidence,
priceUpdate.timestamp
);
await sendMessage(program, oracleAuthority, CHAIN_IDS.ETHEREUM, oracleContract, message, 0n);
```
### 3. Cross-Chain State Sync
```typescript
// Sync application state between chains
interface StateUpdate {
stateRoot: Uint8Array;
blockNumber: bigint;
signature: Uint8Array;
}
function encodeStateUpdate(update: StateUpdate): Uint8Array {
return ethers.concat([
update.stateRoot,
ethers.toBeArray(update.blockNumber),
update.signature,
]);
}
```
## Message Verification on Destination
### Solidity Receiver (EVM)
```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface ICallProxy {
function submissionChainIdFrom() external view returns (uint256);
function submissionNativeSender() external view returns (bytes memory);
}
contract CrossChainReceiver {
address public callProxy;
bytes32 public authorizedSolanaProgram;
modifier onlyFromSolana() {
require(msg.sender == callProxy, "Only call proxy");
uint256 sourceChain = ICallProxy(callProxy).submissionChainIdFrom();
require(sourceChain == SOLANA_CHAIN_ID, "Only from Solana");
bytes memory sender = ICallProxy(callProxy).submissionNativeSender();
require(
keccak256(sender) == authorizedSolanaProgram,
"Unauthorized sender"
);
_;
}
function receiveMessage(bytes calldata message) external onlyFromSolana {
// Process verified message
_processMessage(message);
}
function _processMessage(bytes calldata message) internal {
uint8 messageType = uint8(message[0]);
if (messageType == 0x01) {
_handleGovernance(message[1:]);
} else if (messageType == 0x02) {
_handleOracleUpdate(message[1:]);
}
}
}
```
## Notes
1. **No Token Transfer**: Message passing uses `amount: 0`
2. **Execution Fee**: Still required to incentivize delivery
3. **Message Format**: Define consistent encoding format across chains
4. **Verification**: Always verify source chain and sender on destination
5. **Nonce Tracking**: Track message nonces to prevent replay attacks
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |