Page MenuHomePhabricator
Differential D4959

[native] added react-native-webview to support SIWE
ClosedPublic
Actions

Authored by • derek on Aug 26 2022, 9:05 AM.
Tags
None
Referenced Files
Unknown Object (File)
Sat, Mar 22, 3:08 PM
Unknown Object (File)
Mon, Mar 17, 7:35 AM
Unknown Object (File)
Wed, Mar 12, 2:48 AM
Unknown Object (File)
Wed, Mar 5, 10:50 PM
Unknown Object (File)
Feb 17 2025, 5:25 AM
Unknown Object (File)
Feb 17 2025, 5:25 AM
Unknown Object (File)
Feb 17 2025, 5:25 AM
Unknown Object (File)
Feb 17 2025, 5:25 AM
View All Files
Subscribers
• abosh
• adrian
ashoat
atul
• jacek
tomek
varun

Details

Reviewers
atul
ashoat
• abosh
Commits
rCOMM75437d1e9f83: [native] added react-native-webview to support SIWE
Summary

added react-native-webview to support sign in with ethereum on native. related linear task - parent SIWE task

Test Plan

compile/run comm with xcode to ensure adding webview didn't break anything

Diff Detail

Repository
rCOMM Comm
Branch
derek/siwe-native-webview
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

• derek created this revision.Aug 26 2022, 9:05 AM
• derek edited the summary of this revision. (Show Details)Aug 26 2022, 9:06 AM
Harbormaster completed remote builds in B11639: Diff 16006.Aug 26 2022, 9:16 AM
• derek requested review of this revision.Aug 26 2022, 9:16 AM
• derek updated this revision to Diff 16010.Aug 26 2022, 9:39 AM

Updating D4959: rebased on top of master

Harbormaster completed remote builds in B11643: Diff 16010.Aug 26 2022, 9:48 AM
• abosh resigned from this revision.Aug 26 2022, 10:02 AM

Resigning since I don't have much context on adding new dependencies. But nice adding @ashoat here as a first-pass reviewer since he should take a look at all new dependencies!

ashoat accepted this revision.Aug 26 2022, 12:04 PM
This revision is now accepted and ready to land.Aug 26 2022, 12:04 PM
Closed by commit rCOMM75437d1e9f83: [native] added react-native-webview to support SIWE (authored by • derek). · Explain WhyAug 29 2022, 11:10 AM
This revision was automatically updated to reflect the committed changes.
• derek added a commit: rCOMM75437d1e9f83: [native] added react-native-webview to support SIWE.

Revision Contents
Changeset List

PathSize
native/
ios/
6 lines
1 line
20 lines

Diff 16010

View Options

native/ios/Podfile.lock

mod proto { mod proto {
tonic::include_proto!("blob"); tonic::include_proto!("blob");
} }
use proto::blob_service_client::BlobServiceClient; use proto::blob_service_client::BlobServiceClient;
use proto::put_request; use proto::put_request;
use proto::put_request::Data::*; use proto::put_request::Data::*;
use proto::PutRequest; use proto::PutRequest;
use crate::constants::{BLOB_ADDRESS, MPSC_CHANNEL_BUFFER_CAPACITY}; use crate::constants::{BLOB_ADDRESS, MPSC_CHANNEL_BUFFER_CAPACITY};
use crate::tools::{ use crate::tools::{
c_char_pointer_to_string, c_char_pointer_to_string_new, check_error, c_char_pointer_to_string, c_char_pointer_to_string_new, report_error, string_to_c_char_pointer_new,
report_error, string_to_c_char_pointer, string_to_c_char_pointer_new,
}; };
use anyhow::bail; use anyhow::bail;
use crate::RUNTIME; use crate::RUNTIME;
use lazy_static::lazy_static; use lazy_static::lazy_static;
use libc; use libc;
use libc::c_char; use libc::c_char;
use std::collections::HashMap; use std::collections::HashMap;
use std::ffi::CStr; use std::ffi::CStr;
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines if let Ok(mut grpc_client) =
} }
return Err(format!("could not access client for holder {}", holder)); return Err(format!("could not access client for holder {}", holder));
} }
Err("could not successfully connect to the blob server".to_string()) Err("could not successfully connect to the blob server".to_string())
} }
pub fn put_client_blocking_read_cxx( pub fn put_client_blocking_read_cxx(
holder_char: *const c_char, holder_char: *const c_char,
) -> Result<String, String> { ) -> anyhow::Result<String, anyhow::Error> {
let holder = c_char_pointer_to_string(holder_char)?; let holder = c_char_pointer_to_string_new(holder_char)?;
check_error(&ERROR_MESSAGES)?; Ok(RUNTIME.block_on(async {
let response: Option<String> = RUNTIME.block_on(async {
if let Ok(mut clients) = CLIENTS.lock() { if let Ok(mut clients) = CLIENTS.lock() {
let maybe_client = clients.get_mut(&holder); let maybe_client = clients.get_mut(&holder);
if let Some(client) = maybe_client { if let Some(client) = maybe_client {
if let Some(data) = client.rx.recv().await { if let Some(data) = client.rx.recv().await {
return Some(data); return Ok(data);
} else { } else {
report_error( bail!("couldn't receive data via client's receiver");
&ERROR_MESSAGES,
"couldn't receive data via client's receiver",
Some("put"),
);
} }
} else { } else {
report_error( bail!(format!("no client detected for {} in blocking read", holder));
&ERROR_MESSAGES,
"no client detected in blocking read",
Some("put"),
);
} }
} else { } else {
report_error(&ERROR_MESSAGES, "couldn't access client", Some("put")); bail!("couldn't access clients");
} }
None })?)
});
check_error(&ERROR_MESSAGES)?;
response.ok_or("response not received properly".to_string())
} }
/** /**
* field index: * field index:
* 1 - holder (utf8 string) * 1 - holder (utf8 string)
* 2 - blob hash (utf8 string) * 2 - blob hash (utf8 string)
* 3 - data chunk (bytes) * 3 - data chunk (bytes)
*/ */
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines
View Options

native/package.json

mod proto { mod proto {
tonic::include_proto!("blob"); tonic::include_proto!("blob");
} }
use proto::blob_service_client::BlobServiceClient; use proto::blob_service_client::BlobServiceClient;
use proto::put_request; use proto::put_request;
use proto::put_request::Data::*; use proto::put_request::Data::*;
use proto::PutRequest; use proto::PutRequest;
use crate::constants::{BLOB_ADDRESS, MPSC_CHANNEL_BUFFER_CAPACITY}; use crate::constants::{BLOB_ADDRESS, MPSC_CHANNEL_BUFFER_CAPACITY};
use crate::tools::{ use crate::tools::{
c_char_pointer_to_string, c_char_pointer_to_string_new, check_error, c_char_pointer_to_string, c_char_pointer_to_string_new, report_error, string_to_c_char_pointer_new,
report_error, string_to_c_char_pointer, string_to_c_char_pointer_new,
}; };
use anyhow::bail; use anyhow::bail;
use crate::RUNTIME; use crate::RUNTIME;
use lazy_static::lazy_static; use lazy_static::lazy_static;
use libc; use libc;
use libc::c_char; use libc::c_char;
use std::collections::HashMap; use std::collections::HashMap;
use std::ffi::CStr; use std::ffi::CStr;
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines if let Ok(mut grpc_client) =
} }
return Err(format!("could not access client for holder {}", holder)); return Err(format!("could not access client for holder {}", holder));
} }
Err("could not successfully connect to the blob server".to_string()) Err("could not successfully connect to the blob server".to_string())
} }
pub fn put_client_blocking_read_cxx( pub fn put_client_blocking_read_cxx(
holder_char: *const c_char, holder_char: *const c_char,
) -> Result<String, String> { ) -> anyhow::Result<String, anyhow::Error> {
let holder = c_char_pointer_to_string(holder_char)?; let holder = c_char_pointer_to_string_new(holder_char)?;
check_error(&ERROR_MESSAGES)?; Ok(RUNTIME.block_on(async {
let response: Option<String> = RUNTIME.block_on(async {
if let Ok(mut clients) = CLIENTS.lock() { if let Ok(mut clients) = CLIENTS.lock() {
let maybe_client = clients.get_mut(&holder); let maybe_client = clients.get_mut(&holder);
if let Some(client) = maybe_client { if let Some(client) = maybe_client {
if let Some(data) = client.rx.recv().await { if let Some(data) = client.rx.recv().await {
return Some(data); return Ok(data);
} else { } else {
report_error( bail!("couldn't receive data via client's receiver");
&ERROR_MESSAGES,
"couldn't receive data via client's receiver",
Some("put"),
);
} }
} else { } else {
report_error( bail!(format!("no client detected for {} in blocking read", holder));
&ERROR_MESSAGES,
"no client detected in blocking read",
Some("put"),
);
} }
} else { } else {
report_error(&ERROR_MESSAGES, "couldn't access client", Some("put")); bail!("couldn't access clients");
} }
None })?)
});
check_error(&ERROR_MESSAGES)?;
response.ok_or("response not received properly".to_string())
} }
/** /**
* field index: * field index:
* 1 - holder (utf8 string) * 1 - holder (utf8 string)
* 2 - blob hash (utf8 string) * 2 - blob hash (utf8 string)
* 3 - data chunk (bytes) * 3 - data chunk (bytes)
*/ */
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines
View Options

yarn.lock

mod proto { mod proto {
tonic::include_proto!("blob"); tonic::include_proto!("blob");
} }
use proto::blob_service_client::BlobServiceClient; use proto::blob_service_client::BlobServiceClient;
use proto::put_request; use proto::put_request;
use proto::put_request::Data::*; use proto::put_request::Data::*;
use proto::PutRequest; use proto::PutRequest;
use crate::constants::{BLOB_ADDRESS, MPSC_CHANNEL_BUFFER_CAPACITY}; use crate::constants::{BLOB_ADDRESS, MPSC_CHANNEL_BUFFER_CAPACITY};
use crate::tools::{ use crate::tools::{
c_char_pointer_to_string, c_char_pointer_to_string_new, check_error, c_char_pointer_to_string, c_char_pointer_to_string_new, report_error, string_to_c_char_pointer_new,
report_error, string_to_c_char_pointer, string_to_c_char_pointer_new,
}; };
use anyhow::bail; use anyhow::bail;
use crate::RUNTIME; use crate::RUNTIME;
use lazy_static::lazy_static; use lazy_static::lazy_static;
use libc; use libc;
use libc::c_char; use libc::c_char;
use std::collections::HashMap; use std::collections::HashMap;
use std::ffi::CStr; use std::ffi::CStr;
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines if let Ok(mut grpc_client) =
} }
return Err(format!("could not access client for holder {}", holder)); return Err(format!("could not access client for holder {}", holder));
} }
Err("could not successfully connect to the blob server".to_string()) Err("could not successfully connect to the blob server".to_string())
} }
pub fn put_client_blocking_read_cxx( pub fn put_client_blocking_read_cxx(
holder_char: *const c_char, holder_char: *const c_char,
) -> Result<String, String> { ) -> anyhow::Result<String, anyhow::Error> {
let holder = c_char_pointer_to_string(holder_char)?; let holder = c_char_pointer_to_string_new(holder_char)?;
check_error(&ERROR_MESSAGES)?; Ok(RUNTIME.block_on(async {
let response: Option<String> = RUNTIME.block_on(async {
if let Ok(mut clients) = CLIENTS.lock() { if let Ok(mut clients) = CLIENTS.lock() {
let maybe_client = clients.get_mut(&holder); let maybe_client = clients.get_mut(&holder);
if let Some(client) = maybe_client { if let Some(client) = maybe_client {
if let Some(data) = client.rx.recv().await { if let Some(data) = client.rx.recv().await {
return Some(data); return Ok(data);
} else { } else {
report_error( bail!("couldn't receive data via client's receiver");
&ERROR_MESSAGES,
"couldn't receive data via client's receiver",
Some("put"),
);
} }
} else { } else {
report_error( bail!(format!("no client detected for {} in blocking read", holder));
&ERROR_MESSAGES,
"no client detected in blocking read",
Some("put"),
);
} }
} else { } else {
report_error(&ERROR_MESSAGES, "couldn't access client", Some("put")); bail!("couldn't access clients");
} }
None })?)
});
check_error(&ERROR_MESSAGES)?;
response.ok_or("response not received properly".to_string())
} }
/** /**
* field index: * field index:
* 1 - holder (utf8 string) * 1 - holder (utf8 string)
* 2 - blob hash (utf8 string) * 2 - blob hash (utf8 string)
* 3 - data chunk (bytes) * 3 - data chunk (bytes)
*/ */
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines