Struct Pairing 

pub struct Pairing { /* private fields */ }

Implementations

impl Pairing

pub fn new(uri: &str, connection: Connection) -> Result<Self>

pub async fn init_pairing(&mut self) -> Result<WcMessage>

Initialise the pairing process

1. Subscribe to the relay with the topic in the URI
2. Fetch messages from the relay sent by the dapp
3. Decrypt the messages
4. Check if the first message is a session_propose and the second is a session_authenticate

To continue the process further, use the approve method

pub async fn approve_with_session_settle( &mut self, account_address: Address, ) -> Result<Vec<WcMessage>>

Approve the pairing by using wc_sessionSettle

1. Create a SessionProposeResponse message on the SessionProposal message id, mention our public key in it.
2. Create a SessionSettle message with the session properties encrypted using the derived symmetric key
3. Also subscribe to the topic derived from the symmetric key to receive messages from the dappcxd

Examples found in repository

examples/connect-settle.rs (lines 41-45)

async fn main() {
    env_logger::init();

    // ProjectId is required to prevent DOS on the relay. In case following
    // cause rate limits, you can create your own from https://cloud.reown.com
    let project_id = "35d44d49c2dee217a3eb24bb4410acc7";

    // Used to sign JWTs. Must be generated and stored by client. Same seed
    // should be reused for all connections.
    let client_seed = [123u8; 32];

    let conn = Connection::new(
        "https://relay.walletconnect.org/rpc",
        "https://relay.walletconnect.org",
        project_id,
        client_seed,  Metadata {
            name: "WalletConnect Rust SDK".to_string(),
            description: "WalletConnect Rust SDK enables to connect to relay and interact with dapp".to_string(),
            url: "https://github.com/zemse/walletconnect-sdk".to_string(),
            icons: vec![],
        },
    );

    // WalletConnect URI - you can get it by visiting any dApp and clicking on
    // "Connect Wallet" and select WalletConnect
    let uri_from_dapp = "wc:e4b9eb7a1372bf88abc46c37acac3687301afdfd0d2a4c2355945d66a1164464@2?relay-protocol=irn&symKey=d7430284e1b70853829a010518a088cde0e163bcad5f24425e3b17578b2b402d&expiryTimestamp=1749783095&methods=wc_sessionAuthenticate";

    let (mut pairing, _) = conn
        .init_pairing(uri_from_dapp)
        .await
        .expect("pairing failed");

    pairing
        .approve_with_session_settle(
            "0x0000000000000000000000000000000000000123"
                .parse()
                .unwrap(),
        )
        .await
        .expect("approve failed");

    loop {
        let result =
            pairing.watch_messages(Topic::Derived, None).await.unwrap();

        println!("result: {result:?}");
    }
}

pub async fn approve_with_cacao(&self, cacao: Cacao) -> Result<()>

Approve the pairing by responding to wc_sessionAuthenticate

1. Create a SessionAuthenticateResponse message on the SessionAuthenticate message id. Encrypt the message using derived symetric key and mention our public key by using the type 1 envelope.

Examples found in repository

examples/connect-auth.rs (line 56)

async fn main() {
    env_logger::init();

    // ProjectId is required to prevent DOS on the relay. In case following
    // cause rate limits, you can create your own from https://cloud.reown.com
    let project_id = "35d44d49c2dee217a3eb24bb4410acc7";

    // Used to sign JWTs. Must be generated and stored by client. Same seed
    // should be reused for all connections.
    let client_seed = [123u8; 32];

    let conn = Connection::new(
        "https://relay.walletconnect.org/rpc",
        "https://relay.walletconnect.org",
        project_id,
        client_seed,  Metadata {
            name: "WalletConnect Rust SDK".to_string(),
            description: "WalletConnect Rust SDK enables to connect to relay and interact with dapp".to_string(),
            url: "https://github.com/zemse/walletconnect-sdk".to_string(),
            icons: vec![],
        },
    );

    // WalletConnect URI - you can get it by visiting any dApp and clicking on
    // "Connect Wallet" and select WalletConnect
    let uri_from_dapp = "wc:60b429580a4c390b05661a1921a806abe0fa9891c6f38b303a519367d3aafba0@2?relay-protocol=irn&symKey=d08415aff3fb5b387b4a607ad20d5431e81e54dad759f9a658d99353a6815775&expiryTimestamp=1744387698&methods=wc_sessionAuthenticate";

    let (pairing, _) = conn
        .init_pairing(uri_from_dapp)
        .await
        .expect("pairing failed");

    let private_key = SigningKey::random(&mut OsRng);
    let signer = PrivateKeySigner::from(private_key);

    // inspect pairing requests if it looks good
    let (mut cacao, proposal, auth) =
        pairing.get_proposal_old(signer.address(), 1).unwrap();
    println!("cacao: {cacao:?}");
    println!("proposal: {proposal:?}");
    println!("auth: {auth:?}");

    let message = cacao.caip122_message().unwrap();
    let signature = signer.sign_message_sync(message.as_bytes()).unwrap();
    cacao.insert_signature(signature).unwrap();

    pairing.approve_with_cacao(cacao).await.unwrap();
    // TODO there's error from dApp side "Signature verification failed"
}

pub async fn watch_messages( &self, topic: Topic, dur: Option<Duration>, ) -> Result<Vec<WcMessage>>

Examples found in repository

examples/connect-settle.rs (line 51)

async fn main() {
    env_logger::init();

    // ProjectId is required to prevent DOS on the relay. In case following
    // cause rate limits, you can create your own from https://cloud.reown.com
    let project_id = "35d44d49c2dee217a3eb24bb4410acc7";

    // Used to sign JWTs. Must be generated and stored by client. Same seed
    // should be reused for all connections.
    let client_seed = [123u8; 32];

    let conn = Connection::new(
        "https://relay.walletconnect.org/rpc",
        "https://relay.walletconnect.org",
        project_id,
        client_seed,  Metadata {
            name: "WalletConnect Rust SDK".to_string(),
            description: "WalletConnect Rust SDK enables to connect to relay and interact with dapp".to_string(),
            url: "https://github.com/zemse/walletconnect-sdk".to_string(),
            icons: vec![],
        },
    );

    // WalletConnect URI - you can get it by visiting any dApp and clicking on
    // "Connect Wallet" and select WalletConnect
    let uri_from_dapp = "wc:e4b9eb7a1372bf88abc46c37acac3687301afdfd0d2a4c2355945d66a1164464@2?relay-protocol=irn&symKey=d7430284e1b70853829a010518a088cde0e163bcad5f24425e3b17578b2b402d&expiryTimestamp=1749783095&methods=wc_sessionAuthenticate";

    let (mut pairing, _) = conn
        .init_pairing(uri_from_dapp)
        .await
        .expect("pairing failed");

    pairing
        .approve_with_session_settle(
            "0x0000000000000000000000000000000000000123"
                .parse()
                .unwrap(),
        )
        .await
        .expect("approve failed");

    loop {
        let result =
            pairing.watch_messages(Topic::Derived, None).await.unwrap();

        println!("result: {result:?}");
    }
}

pub async fn send_message<T>( &self, topic: Topic, message: &Message<String, T>, type_byte: Option<u8>, tag: IrnTag, ttl: u64, ) -> Result<Value>

where T: Serialize + DeserializeOwned,

pub fn get_proposal(&self) -> Result<&WcMessage>

pub fn get_proposal_old( &self, account_address: Address, chain_id: u64, ) -> Result<(Cacao, WcMessage, WcMessage)>

Examples found in repository

examples/connect-auth.rs (line 47)

async fn main() {
    env_logger::init();

    // ProjectId is required to prevent DOS on the relay. In case following
    // cause rate limits, you can create your own from https://cloud.reown.com
    let project_id = "35d44d49c2dee217a3eb24bb4410acc7";

    // Used to sign JWTs. Must be generated and stored by client. Same seed
    // should be reused for all connections.
    let client_seed = [123u8; 32];

    let conn = Connection::new(
        "https://relay.walletconnect.org/rpc",
        "https://relay.walletconnect.org",
        project_id,
        client_seed,  Metadata {
            name: "WalletConnect Rust SDK".to_string(),
            description: "WalletConnect Rust SDK enables to connect to relay and interact with dapp".to_string(),
            url: "https://github.com/zemse/walletconnect-sdk".to_string(),
            icons: vec![],
        },
    );

    // WalletConnect URI - you can get it by visiting any dApp and clicking on
    // "Connect Wallet" and select WalletConnect
    let uri_from_dapp = "wc:60b429580a4c390b05661a1921a806abe0fa9891c6f38b303a519367d3aafba0@2?relay-protocol=irn&symKey=d08415aff3fb5b387b4a607ad20d5431e81e54dad759f9a658d99353a6815775&expiryTimestamp=1744387698&methods=wc_sessionAuthenticate";

    let (pairing, _) = conn
        .init_pairing(uri_from_dapp)
        .await
        .expect("pairing failed");

    let private_key = SigningKey::random(&mut OsRng);
    let signer = PrivateKeySigner::from(private_key);

    // inspect pairing requests if it looks good
    let (mut cacao, proposal, auth) =
        pairing.get_proposal_old(signer.address(), 1).unwrap();
    println!("cacao: {cacao:?}");
    println!("proposal: {proposal:?}");
    println!("auth: {auth:?}");

    let message = cacao.caip122_message().unwrap();
    let signature = signer.sign_message_sync(message.as_bytes()).unwrap();
    cacao.insert_signature(signature).unwrap();

    pairing.approve_with_cacao(cacao).await.unwrap();
    // TODO there's error from dApp side "Signature verification failed"
}

Trait Implementations

impl Clone for Pairing

fn clone(&self) -> Pairing

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Pairing

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Pairing

fn eq(&self, other: &Pairing) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Pairing