Struct Connection 

pub struct Connection { /* private fields */ }

Implementations

impl Connection

pub fn new( rpc: &str, jwt_rpc: &str, project_id: &str, client_seed: [u8; 32], metadata: Metadata, ) -> Self

Examples found in repository

examples/connect-settle.rs (lines 19-29)

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:?}");
    }
}

examples/connect-auth.rs (lines 21-31)

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 fn metadata(&self) -> &Metadata

pub async fn init_pairing(self, uri: &str) -> Result<(Pairing, WcMessage)>

Examples found in repository

examples/connect-settle.rs (line 36)

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:?}");
    }
}

examples/connect-auth.rs (line 38)

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 irn_subscribe(&self, topic: &str) -> Result<String>

pub async fn irn_fetch_messages( &self, topic: &str, ) -> Result<Vec<EncryptedMessage>>

pub async fn irn_publish( &self, encrypted_message: EncryptedMessage, ) -> Result<Value>

Trait Implementations

impl Clone for Connection

fn clone(&self) -> Connection

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Connection

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

Formats the value using the given formatter.

impl PartialEq for Connection

fn eq(&self, other: &Connection) -> 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 Connection