Use near-client from crates.io

.github/workflows/ci.yml

@@ -39,8 +39,8 @@ jobs:
           components: clippy
       - name: cargo clippy
         run: cargo +nightly clippy --workspace --tests -- -D warnings
-  tests-common-api:
-    name: tests-common-api
+  tests:
+    name: tests
     needs: [clippy, fmt]
     runs-on: ubuntu-latest
     steps:
@@ -50,34 +50,12 @@ jobs:
         with:
           toolchain: stable
       - name: Run tests for [common-api]
-        run: cargo test -p common-api --tests --all-features
-  tests-near:
-    name: tests-near
-    needs: [clippy, fmt]
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust Toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          target: wasm32-unknown-unknown
-      - name: Setup ssh access for a private repositories
-        uses: webfactory/ssh-agent@v0.7.0
-        with:
-          ssh-private-key: |
-            ${{ secrets.CLIENT_SSH_PRIVATE_KEY }}
-            ${{ secrets.SMARTCONTRACTS_SSH_PRIVATE_KEY }}
-      - name: Run tests for [near-rpc]
-        env:
-          CARGO_NET_GIT_FETCH_WITH_CLI: true
-        run: cargo test -p near-rpc --tests
+        run: cargo test --tests --all-features
   tests-web:
     name: tests-web
     needs: [clippy, fmt]
     runs-on: ubuntu-latest
     permissions:
-      contents: write
       packages: read
     steps:
       - name: Log in to the Container registry

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["web-client", "near-rpc", "common-api", "near-primitives-light"]
+members = ["web-client", "common-api"]
 
 [profile.release]
 codegen-units = 1

Dockerfile

@@ -2,9 +2,7 @@ FROM rust:latest
 
 # Copy a source code
 COPY web-client /build/web-client
-COPY near-rpc /build/near-rpc
 COPY common-api /build/common-api
-COPY near-primitives-light /build/near-primitives-light
 
 WORKDIR /build/web-client
 

common-api/Cargo.toml

@@ -9,24 +9,11 @@ API for signing data and shared types. Please note that all data
 structures should be serializable with "serde" and "borsh"
 """
 
-[features]
-default = ["headers", "api"]
-headers = ["dep:near-account-id"]
-api = ["dep:near-account-id", "dep:uuid"]
-
 [dependencies]
-bs58 = "0.4"
 borsh = "0.9"
-curve25519-dalek = "3"
-ed25519-dalek = "1"
-itertools = "0.10"
-near-account-id = { version = "0.15", optional = true }
+near-account-id = { version = "0.15" }
+near-client = "0.1"
 serde = { version = "1", default-features = false, features = ["derive"] }
-thiserror = "1"
-uuid = { version = "1", optional = true }
-x25519-dalek = { version = "1", features = ["serde"] }
 
 [dev-dependencies]
-rand = "0.8.5"
-rand_chacha = "0.3"
 serde_json = "1"

common-api/src/api.rs

@@ -1,6 +1,6 @@
-use crate::crypto::prelude::*;
 use borsh::{BorshDeserialize, BorshSerialize};
 use near_account_id::AccountId;
+use near_client::crypto::prelude::*;
 use serde::{Deserialize, Serialize};
 use std::{collections::HashSet, time::Duration};
 

common-api/src/crypto/ed25519.rs

@@ -1,305 +0,0 @@
-//! ### Sign with ed25519 elliptic curve signing algorithm
-//! ---
-//! Used Dalek cryptography, and implemented [`Borsh`](https://borsh.io/) serialization for them
-
-use borsh::{BorshDeserialize, BorshSerialize};
-use ed25519_dalek::{ExpandedSecretKey, PublicKey, SecretKey, Signature, Verifier};
-use itertools::Itertools;
-use serde::{Deserialize, Serialize};
-use std::{
-    fmt::Display,
-    hash::{Hash, Hasher},
-    io::{Error as IoError, ErrorKind},
-    str::FromStr,
-};
-
-use super::{split_encoded_str, Error, Key, Result, ED25519};
-
-pub use ed25519_dalek::{
-    KEYPAIR_LENGTH as ED25519_KEYPAIR_LENGTH, PUBLIC_KEY_LENGTH as ED25519_PUBLIC_KEY_LENGTH,
-    SECRET_KEY_LENGTH as ED25519_SECRET_KEY_LENGTH, SIGNATURE_LENGTH as ED25519_SIGNATURE_LENGTH,
-};
-
-#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
-pub struct Ed25519PublicKey(PublicKey);
-
-impl Ed25519PublicKey {
-    /// Verifies the signature of a signed data
-    pub fn verify(&self, data: &[u8], signature: &Ed25519Signature) -> Result<()> {
-        self.0
-            .verify(data, &signature.0)
-            .map_err(|_| Error::Verification(signature.string()))
-    }
-
-    #[inline]
-    pub fn as_bytes(&self) -> &[u8; ED25519_PUBLIC_KEY_LENGTH] {
-        self.0.as_bytes()
-    }
-}
-
-impl Key<ED25519_PUBLIC_KEY_LENGTH> for Ed25519PublicKey {
-    const KEY_TYPE: &'static str = ED25519;
-
-    #[inline]
-    fn to_bytes(&self) -> [u8; ED25519_PUBLIC_KEY_LENGTH] {
-        self.0.to_bytes()
-    }
-
-    fn try_from_bytes(buf: &[u8]) -> Result<Self> {
-        PublicKey::from_bytes(buf)
-            .map(Self)
-            .map_err(|err| Error::from_bytes::<Ed25519PublicKey>(buf, err.to_string()))
-    }
-}
-
-impl BorshDeserialize for Ed25519PublicKey {
-    fn deserialize(buf: &mut &[u8]) -> std::io::Result<Self> {
-        // The first byte is a key type, let's skip it because currently is used ed25519 only
-        // This implementation of [`Ed25519PublicKey`] is required by Near protocol
-        let temp_buf = std::mem::take(buf)
-            .split_first()
-            .map(|(.., key)| key)
-            .unwrap_or_default();
-        Ed25519PublicKey::try_from_bytes(temp_buf)
-            .map_err(|err| IoError::new(ErrorKind::InvalidData, err))
-    }
-}
-
-impl BorshSerialize for Ed25519PublicKey {
-    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
-        BorshSerialize::serialize(&0_u8, writer)?;
-        writer.write_all(self.0.as_bytes())
-    }
-}
-
-impl From<&Ed25519SecretKey> for Ed25519PublicKey {
-    fn from(sk: &Ed25519SecretKey) -> Self {
-        Self(PublicKey::from(&sk.0))
-    }
-}
-
-// This `Hash` implementation is safe since it retains the property
-// `k1 == k2 ⇒ hash(k1) == hash(k2)`.
-#[allow(clippy::derived_hash_with_manual_eq)]
-impl Hash for Ed25519PublicKey {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        state.write_u8(0u8);
-        state.write(self.0.as_bytes());
-    }
-}
-
-impl Display for Ed25519PublicKey {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.string())
-    }
-}
-
-pub struct Ed25519SecretKey(SecretKey);
-
-impl Ed25519SecretKey {
-    /// Sign a `data` with a private key
-    pub fn sign(&self, data: &[u8], public_key: &Ed25519PublicKey) -> Ed25519Signature {
-        let expanded_key = ExpandedSecretKey::from(&self.0);
-        Ed25519Signature(expanded_key.sign(data, &public_key.0))
-    }
-
-    /// Near protocol using expanded secret key
-    pub fn from_expanded(key: &str) -> Result<Self> {
-        let (key_type, bs58_encoded) = split_encoded_str(key)?;
-
-        if key_type != Self::KEY_TYPE {
-            return Err(Error::WrongKeyType {
-                key_type: key_type.to_owned(),
-                expected_key_type: Self::KEY_TYPE,
-            });
-        }
-
-        let expanded_key_bytes = bs58::decode(bs58_encoded)
-            .into_vec()
-            .map_err(|err| {
-                Error::from_string::<Ed25519SecretKey>(bs58_encoded.to_owned(), err.to_string())
-            })?
-            .into_iter()
-            .take(ED25519_SECRET_KEY_LENGTH)
-            .collect_vec();
-        Self::try_from_bytes(&expanded_key_bytes)
-    }
-
-    #[inline]
-    pub fn as_bytes(&self) -> &[u8; ED25519_PUBLIC_KEY_LENGTH] {
-        self.0.as_bytes()
-    }
-}
-
-impl Key<ED25519_SECRET_KEY_LENGTH> for Ed25519SecretKey {
-    const KEY_TYPE: &'static str = ED25519;
-
-    #[inline]
-    fn to_bytes(&self) -> [u8; ED25519_SECRET_KEY_LENGTH] {
-        self.0.to_bytes()
-    }
-
-    fn try_from_bytes(buf: &[u8]) -> Result<Self> {
-        SecretKey::from_bytes(buf)
-            .map(Self)
-            .map_err(|err| Error::from_bytes::<Ed25519SecretKey>(buf, err.to_string()))
-    }
-}
-
-impl BorshDeserialize for Ed25519SecretKey {
-    fn deserialize(buf: &mut &[u8]) -> std::io::Result<Self> {
-        Ed25519SecretKey::try_from_bytes(std::mem::take(buf))
-            .map_err(|err| IoError::new(ErrorKind::InvalidData, err))
-    }
-}
-
-impl BorshSerialize for Ed25519SecretKey {
-    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
-        writer.write_all(self.0.as_bytes())
-    }
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub struct Ed25519Signature(Signature);
-
-impl Key<ED25519_SIGNATURE_LENGTH> for Ed25519Signature {
-    const KEY_TYPE: &'static str = ED25519;
-
-    #[inline]
-    fn to_bytes(&self) -> [u8; ED25519_SIGNATURE_LENGTH] {
-        self.0.to_bytes()
-    }
-
-    fn try_from_bytes(buf: &[u8]) -> Result<Self> {
-        Signature::from_bytes(buf)
-            .map(Self)
-            .map_err(|err| Error::from_bytes::<Ed25519Signature>(buf, err.to_string()))
-    }
-}
-
-impl BorshDeserialize for Ed25519Signature {
-    fn deserialize(buf: &mut &[u8]) -> std::io::Result<Self> {
-        // The first byte is a key type, let's skip it because currently is used ed25519 only
-        // This implementation of [`Ed25519Signature`] is required by Near protocol
-        let temp_buf = std::mem::take(buf)
-            .split_first()
-            .map(|(.., key)| key)
-            .unwrap_or_default();
-        Ed25519Signature::try_from_bytes(temp_buf)
-            .map_err(|err| IoError::new(ErrorKind::InvalidData, err))
-    }
-}
-
-impl BorshSerialize for Ed25519Signature {
-    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
-        BorshSerialize::serialize(&0_u8, writer)?;
-        writer.write_all(&self.0.to_bytes())
-    }
-}
-
-#[allow(clippy::derived_hash_with_manual_eq)]
-impl Hash for Ed25519Signature {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.to_bytes().hash(state);
-    }
-}
-
-impl Display for Ed25519Signature {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.string())
-    }
-}
-
-/// Contains public and secret user keys
-#[derive(Serialize, Deserialize)]
-pub struct Keypair {
-    public_key: Ed25519PublicKey,
-    secret_key: Ed25519SecretKey,
-}
-
-impl Keypair {
-    pub fn new(secret_key: Ed25519SecretKey) -> Self {
-        let public_key = Ed25519PublicKey::from(&secret_key);
-        Self {
-            public_key,
-            secret_key,
-        }
-    }
-
-    pub fn from_expanded_secret(expanded: &str) -> Result<Self> {
-        let secret_key = Ed25519SecretKey::from_expanded(expanded)?;
-        let public_key = Ed25519PublicKey::from(&secret_key);
-        Ok(Self {
-            public_key,
-            secret_key,
-        })
-    }
-
-    pub fn sign(&self, data: &[u8]) -> Ed25519Signature {
-        self.secret_key.sign(data, &self.public_key)
-    }
-
-    pub fn verify(&self, data: &[u8], signature: &Ed25519Signature) -> Result<()> {
-        self.public_key.verify(data, signature)
-    }
-
-    pub fn public_key(&self) -> &Ed25519PublicKey {
-        &self.public_key
-    }
-
-    pub fn secret_key(&self) -> &Ed25519SecretKey {
-        &self.secret_key
-    }
-}
-
-impl ToString for Keypair {
-    fn to_string(&self) -> String {
-        let keypair_bytes = self
-            .secret_key()
-            .as_bytes()
-            .iter()
-            .chain(self.public_key().as_bytes().iter())
-            .copied()
-            .collect_vec();
-
-        format!("{ED25519}:{}", bs58::encode(keypair_bytes).into_string())
-    }
-}
-
-impl FromStr for Keypair {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self> {
-        let (key_type, data) = split_encoded_str(s)?;
-
-        if key_type != ED25519 {
-            return Err(Error::WrongKeyType {
-                key_type: key_type.to_owned(),
-                expected_key_type: ED25519,
-            });
-        }
-
-        let byte_data = bs58::decode(data)
-            .into_vec()
-            .map_err(|err| Error::from_string::<Keypair>(data.to_owned(), err.to_string()))?;
-
-        if byte_data.len() != ED25519_KEYPAIR_LENGTH {
-            return Err(Error::from_bytes::<Keypair>(
-                &byte_data,
-                format!(
-                    "Keypair byte array length doesn't equal\
-                     to requested length {ED25519_KEYPAIR_LENGTH}"
-                ),
-            ));
-        }
-
-        Ok(Self {
-            secret_key: Ed25519SecretKey::try_from_bytes(&byte_data[..ED25519_SECRET_KEY_LENGTH])?,
-            public_key: Ed25519PublicKey::try_from_bytes(&byte_data[ED25519_SECRET_KEY_LENGTH..])?,
-        })
-    }
-}
-
-serde_impl!(Ed25519PublicKey);
-serde_impl!(Ed25519SecretKey);
-serde_impl!(Ed25519Signature);

common-api/src/crypto/key_exchange.rs

@@ -1,165 +0,0 @@
-//! ### Diffie–Hellman key exchange with ed25519 elliptic curves algorithm
-//! ---
-//! Used Dalek cryptography, and implemented [`Borsh`](https://borsh.io/) serialization for it
-
-use super::{
-    ed25519::{Ed25519PublicKey, Ed25519SecretKey},
-    Error, Key, Result, X25519,
-};
-use std::{
-    fmt::Display,
-    io::{Error as IoError, ErrorKind},
-};
-
-use borsh::{BorshDeserialize, BorshSerialize};
-use curve25519_dalek::edwards::CompressedEdwardsY;
-use x25519_dalek::{PublicKey as DalekPublicKey, StaticSecret};
-
-pub const PUBLIC_KEY_LENGTH: usize = 32_usize;
-pub const SECRET_KEY_LENGTH: usize = 32_usize;
-
-pub struct SecretKey(StaticSecret);
-
-impl BorshSerialize for SecretKey {
-    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
-        writer.write_all(&self.0.to_bytes())
-    }
-}
-
-impl BorshDeserialize for SecretKey {
-    fn deserialize(buf: &mut &[u8]) -> std::io::Result<Self> {
-        let secret_key = Self::try_from_bytes(std::mem::take(buf))
-            .map_err(|err| IoError::new(ErrorKind::InvalidData, err))?;
-        Ok(secret_key)
-    }
-}
-
-#[derive(Copy, Clone, PartialEq, Eq)]
-pub struct PublicKey(DalekPublicKey);
-
-impl BorshSerialize for PublicKey {
-    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
-        writer.write_all(self.0.as_bytes())
-    }
-}
-
-impl BorshDeserialize for PublicKey {
-    fn deserialize(buf: &mut &[u8]) -> std::io::Result<Self> {
-        let public_key = Self::try_from_bytes(std::mem::take(buf))
-            .map_err(|err| IoError::new(ErrorKind::InvalidData, err))?;
-        Ok(public_key)
-    }
-}
-
-impl Display for PublicKey {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.string())
-    }
-}
-
-impl Key<SECRET_KEY_LENGTH> for SecretKey {
-    const KEY_TYPE: &'static str = X25519;
-
-    #[inline]
-    fn to_bytes(&self) -> [u8; SECRET_KEY_LENGTH] {
-        self.0.to_bytes()
-    }
-
-    fn try_from_bytes(buf: &[u8]) -> Result<Self> {
-        if buf.len() != SECRET_KEY_LENGTH {
-            return Err(Error::from_bytes::<PublicKey>(
-                buf,
-                format!(
-                    "input buffer size \"{}\" not equal to secret key size \"{SECRET_KEY_LENGTH}\"",
-                    buf.len()
-                ),
-            ));
-        }
-
-        let mut temp_buf = [0_u8; SECRET_KEY_LENGTH];
-        temp_buf.copy_from_slice(buf);
-
-        Ok(Self(StaticSecret::from(temp_buf)))
-    }
-}
-
-impl Key<PUBLIC_KEY_LENGTH> for PublicKey {
-    const KEY_TYPE: &'static str = X25519;
-
-    #[inline]
-    fn to_bytes(&self) -> [u8; PUBLIC_KEY_LENGTH] {
-        self.0.to_bytes()
-    }
-
-    fn try_from_bytes(buf: &[u8]) -> Result<Self> {
-        if buf.len() != PUBLIC_KEY_LENGTH {
-            return Err(Error::from_bytes::<PublicKey>(
-                buf,
-                format!(
-                    "input buffer size \"{}\" not equal to public key size \"{PUBLIC_KEY_LENGTH}\"",
-                    buf.len()
-                ),
-            ));
-        }
-
-        let mut temp_buf = [0_u8; PUBLIC_KEY_LENGTH];
-        temp_buf.copy_from_slice(buf);
-
-        Ok(Self(DalekPublicKey::from(temp_buf)))
-    }
-}
-
-impl<'a> From<&'a SecretKey> for PublicKey {
-    fn from(secret: &'a SecretKey) -> PublicKey {
-        Self(DalekPublicKey::from(&secret.0))
-    }
-}
-
-impl SecretKey {
-    /// Creates a secret part from other participant public part of keypair
-    ///
-    /// ## Arguments
-    /// - **other_public** - Another public part [`PublicKey`] of the key exchange process
-    ///
-    /// ## Returns
-    /// Byte array with a shared secret key
-    ///
-    pub fn exchange(&self, other_public: &PublicKey) -> [u8; SECRET_KEY_LENGTH] {
-        self.0.diffie_hellman(&other_public.0).to_bytes()
-    }
-}
-
-impl TryFrom<Ed25519PublicKey> for PublicKey {
-    type Error = Error;
-
-    fn try_from(key: Ed25519PublicKey) -> Result<Self> {
-        let edwards_point = CompressedEdwardsY::from_slice(key.as_bytes())
-            .decompress()
-            .ok_or_else(|| {
-                Error::from_bytes::<Ed25519PublicKey>(
-                    key.as_bytes(),
-                    "Couldn't decompress an Edwards point".to_owned(),
-                )
-            })?;
-
-        PublicKey::try_from_bytes(edwards_point.to_montgomery().as_bytes())
-    }
-}
-
-impl TryFrom<Ed25519SecretKey> for SecretKey {
-    type Error = Error;
-
-    fn try_from(key: Ed25519SecretKey) -> Result<Self> {
-        use ed25519_dalek::{ExpandedSecretKey, SecretKey as S};
-
-        let expanded_key =
-            ExpandedSecretKey::from(&S::from_bytes(key.as_bytes()).map_err(|err| {
-                Error::from_bytes::<Ed25519SecretKey>(key.as_bytes(), err.to_string())
-            })?);
-
-        Self::try_from_bytes(&expanded_key.to_bytes()[..32])
-    }
-}
-
-serde_impl!(SecretKey);
-serde_impl!(PublicKey);

common-api/src/crypto/mod.rs

@@ -1,183 +0,0 @@
-#[macro_use]
-mod serde_impl {
-    macro_rules! serde_impl {
-        ($key_type: ty) => {
-            impl serde::Serialize for $key_type {
-                fn serialize<S>(
-                    &self,
-                    serializer: S,
-                ) -> std::result::Result<
-                    <S as serde::Serializer>::Ok,
-                    <S as serde::Serializer>::Error,
-                >
-                where
-                    S: serde::Serializer,
-                {
-                    serializer.serialize_str(&Key::string(self))
-                }
-            }
-
-            impl<'de> serde::Deserialize<'de> for $key_type {
-                fn deserialize<D>(
-                    deserializer: D,
-                ) -> std::result::Result<Self, <D as serde::Deserializer<'de>>::Error>
-                where
-                    D: serde::Deserializer<'de>,
-                {
-                    let s = <String as serde::Deserialize>::deserialize(deserializer)?;
-                    <$key_type>::from_string(&s).map_err(|err| {
-                        serde::de::Error::custom(format!("Deserialization failed: `{}`", err))
-                    })
-                }
-            }
-        };
-    }
-}
-
-pub mod ed25519;
-pub mod key_exchange;
-pub mod prelude {
-    pub use super::{
-        ed25519::{
-            Ed25519PublicKey, Ed25519SecretKey, Ed25519Signature, Keypair,
-            ED25519_PUBLIC_KEY_LENGTH, ED25519_SECRET_KEY_LENGTH, ED25519_SIGNATURE_LENGTH,
-        },
-        key_exchange::{PublicKey, SecretKey, PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH},
-        Error, Key,
-    };
-}
-
-use itertools::Itertools;
-
-type Result<T> = std::result::Result<T, Error>;
-
-pub(crate) const ED25519: &str = "ed25519";
-pub(crate) const X25519: &str = "x25519";
-
-/// ## Key
-/// **KEY_LENGTH** - It's a key size for ed25519 or x25519
-/// **KEY_TYPE** - Key type, for internal usage to reduce a boilerplate code.
-/// It's a prefix for a key string serialization. Possible values are ["ed25519", "x25519"]
-pub trait Key<const KEY_LENGTH: usize>: Sized {
-    const KEY_TYPE: &'static str;
-
-    /// Parse an encoded string to the corresponding [`Key`]
-    fn from_string(key: &str) -> Result<Self> {
-        let (key_type, bs58_encoded) = split_encoded_str(key)?;
-
-        if key_type != Self::KEY_TYPE {
-            return Err(Error::WrongKeyType {
-                key_type: key_type.to_owned(),
-                expected_key_type: Self::KEY_TYPE,
-            });
-        }
-
-        let bytes = bs58::decode(bs58_encoded)
-            .into_vec()
-            .map_err(|err| Error::from_string::<Self>(bs58_encoded.to_owned(), err.to_string()))?;
-        Self::try_from_bytes(&bytes)
-    }
-
-    /// Return a string representation of a [`Key`]
-    /// The string is split with a delimiter ":"
-    /// The first part is a [`X25519`] or [`ED25519`] prefix
-    /// The second part is a bs58 encoded key
-    fn string(&self) -> String {
-        format!(
-            "{}:{}",
-            Self::KEY_TYPE,
-            bs58::encode(self.to_bytes()).into_string()
-        )
-    }
-
-    /// Parse a bytes slice to the corresponding [`Key`]
-    fn try_from_bytes(buf: &[u8]) -> Result<Self>;
-
-    /// Return a byte representation of a [`Key`]
-    /// The size of a slice defined with a [`KEY_LENGTH`]
-    fn to_bytes(&self) -> [u8; KEY_LENGTH];
-}
-
-#[derive(thiserror::Error, Debug)]
-pub enum Error {
-    #[error("Couldn't convert key from bytes \"{data}\" into \"{key_name}\", because of: {cause}")]
-    ConvertFromBytes {
-        key_name: &'static str,
-        data: String,
-        cause: String,
-    },
-    #[error(
-        "Couldn't convert key from string \"{data}\" into \"{key_name}\", because of: {cause}"
-    )]
-    ConvertFromString {
-        key_name: &'static str,
-        data: String,
-        cause: String,
-    },
-    #[error("The key format \"{0}\" seems different from ed25519 or x25519 format")]
-    UnknownKeyType(String),
-    #[error(
-        "The expected key type \"{expected_key_type}\" is different from actual \"{key_type}\""
-    )]
-    WrongKeyType {
-        key_type: String,
-        expected_key_type: &'static str,
-    },
-    #[error("Signature \"{0}\" verification failed")]
-    Verification(String),
-}
-
-impl Error {
-    pub(crate) fn from_string<T>(data: String, cause: String) -> Self {
-        Self::ConvertFromString {
-            key_name: std::any::type_name::<T>()
-                .rsplit("::")
-                .next()
-                .unwrap_or_default(),
-            data,
-            cause,
-        }
-    }
-
-    pub(crate) fn from_bytes<T>(data: &[u8], cause: String) -> Self {
-        Self::ConvertFromBytes {
-            key_name: std::any::type_name::<T>()
-                .rsplit("::")
-                .next()
-                .unwrap_or_default(),
-            data: bs58::encode(data).into_string(),
-            cause,
-        }
-    }
-}
-
-/// Split encoded [`str`] to key prefix and bs58 encoded string
-fn split_encoded_str(encoded: &str) -> Result<(&str, &str)> {
-    match encoded.split(':').next_tuple() {
-        Some((key_type @ ED25519, bs58_encoded) | (key_type @ X25519, bs58_encoded)) => {
-            Ok((key_type, bs58_encoded))
-        }
-        _ => Err(Error::UnknownKeyType(encoded.to_owned())),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use super::{split_encoded_str, Error, ED25519, X25519};
-
-    #[test]
-    fn split_encoded() {
-        let bs58_str = bs58::encode(vec![0, 0, 0]).into_string();
-        assert!(matches!(
-                split_encoded_str(&format!("ed25519:{bs58_str}")),
-                Ok((key_type, s)) if key_type == ED25519 && s == bs58_str));
-        assert!(matches!(
-                split_encoded_str(&format!("x25519:{bs58_str}")),
-                Ok((key_type, s)) if key_type == X25519 && s == bs58_str));
-        assert!(matches!(
-            split_encoded_str(&bs58_str),
-            Err(Error::UnknownKeyType(..))
-        ));
-    }
-}

common-api/src/headers.rs

@@ -1,5 +1,5 @@
-use crate::crypto::prelude::*;
 use near_account_id::AccountId;
+use near_client::crypto::prelude::*;
 use serde::{Deserialize, Serialize};
 
 pub const SIGNATURE_HEADER_NAME: &str = "signature";

common-api/src/lib.rs

@@ -1,5 +1,2 @@
-#[cfg(feature = "api")]
 pub mod api;
-pub mod crypto;
-#[cfg(feature = "headers")]
 pub mod headers;

common-api/tests/crypto.rs

@@ -1,325 +0,0 @@
-use std::str::FromStr;
-
-use borsh::BorshDeserialize;
-use common_api::crypto::prelude::*;
-use ed25519_dalek::{ExpandedSecretKey, SecretKey as DalekSecretKey};
-use rand::{RngCore, SeedableRng};
-use rand_chacha::ChaChaRng;
-
-#[test]
-fn try_from_bytes_ed25519() {
-    let sk = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
-    let pk = Ed25519PublicKey::from(&sk);
-    let _ = Ed25519PublicKey::try_from_bytes(pk.as_bytes()).unwrap();
-
-    assert!(matches!(
-        Ed25519PublicKey::try_from_bytes(&[0, 0, 0]),
-        Err(Error::ConvertFromBytes { .. })
-    ));
-
-    assert!(matches!(
-        Ed25519SecretKey::try_from_bytes(&[0, 0, 0]),
-        Err(Error::ConvertFromBytes { .. })
-    ));
-}
-
-#[test]
-fn to_string_ed25519() {
-    let sk = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
-    let pk = Ed25519PublicKey::from(&sk);
-
-    assert_eq!(
-        format!("ed25519:{}", bs58::encode(sk.as_bytes()).into_string()),
-        sk.string()
-    );
-    assert_eq!(
-        format!("ed25519:{}", bs58::encode(pk.as_bytes()).into_string()),
-        pk.string()
-    );
-}
-
-#[test]
-fn from_string_ed25519() {
-    let sk = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
-    let pk = Ed25519PublicKey::from(&sk);
-
-    let _ = Ed25519SecretKey::from_string(
-        format!("ed25519:{}", bs58::encode(sk.as_bytes()).into_string()).as_str(),
-    )
-    .unwrap();
-
-    let _ = Ed25519PublicKey::from_string(
-        format!("ed25519:{}", bs58::encode(pk.as_bytes()).into_string()).as_str(),
-    )
-    .unwrap();
-
-    assert!(matches!(
-        Ed25519PublicKey::from_string(
-            format!("x25519:{}", bs58::encode(vec![0, 0, 0]).into_string()).as_str()
-        ),
-        Err(Error::WrongKeyType { .. })
-    ));
-
-    assert!(matches!(
-        Ed25519SecretKey::from_string(
-            format!("x25519:{}", bs58::encode(vec![0, 0, 0]).into_string()).as_str(),
-        ),
-        Err(Error::WrongKeyType { .. })
-    ));
-
-    assert!(matches!(
-        Ed25519SecretKey::from_string(format!("ed25519:{}", "==1234%#").as_str(),),
-        Err(Error::ConvertFromString { .. })
-    ));
-
-    assert!(matches!(
-        Ed25519PublicKey::from_string(
-            format!("ed25519:{}", bs58::encode(vec![0, 0, 0]).into_string()).as_str(),
-        ),
-        Err(Error::ConvertFromBytes { .. })
-    ));
-
-    assert!(matches!(
-        Ed25519PublicKey::from_string(format!("ed25519:{}", "==1234%#").as_str(),),
-        Err(Error::ConvertFromString { .. })
-    ));
-}
-
-#[test]
-fn from_expanded() {
-    let dalek_sk = ExpandedSecretKey::from(&DalekSecretKey::from_bytes(&random_bits()).unwrap());
-    let exp_str = format!(
-        "ed25519:{}",
-        bs58::encode(dalek_sk.to_bytes()).into_string()
-    );
-    let sk = Ed25519SecretKey::from_expanded(&exp_str).unwrap();
-
-    assert_eq!(sk.as_bytes(), &dalek_sk.to_bytes()[..32]);
-}
-
-#[test]
-fn from_expanded_fail() {
-    let dalek_sk = ExpandedSecretKey::from(&DalekSecretKey::from_bytes(&random_bits()).unwrap());
-
-    let exp_str = bs58::encode(dalek_sk.to_bytes()).into_string();
-    assert!(matches!(
-        Ed25519SecretKey::from_expanded(&exp_str),
-        Err(Error::UnknownKeyType { .. })
-    ));
-
-    let exp_str = format!("ed25519:{}", bs58::encode(vec![0, 0, 0]).into_string());
-    assert!(matches!(
-        Ed25519SecretKey::from_expanded(&exp_str),
-        Err(Error::ConvertFromBytes { .. })
-    ));
-
-    let exp_str = format!("ed25519:{}", "===%123@@#31");
-    assert!(matches!(
-        Ed25519SecretKey::from_expanded(&exp_str),
-        Err(Error::ConvertFromString { .. })
-    ));
-}
-
-#[test]
-fn try_from_bytes_x25519() {
-    let sk = SecretKey::try_from_bytes(&random_bits()).unwrap();
-    let pk = PublicKey::from(&sk);
-    let _ = PublicKey::try_from_bytes(&pk.to_bytes()).unwrap();
-
-    assert!(matches!(
-        PublicKey::try_from_bytes(&[0, 0, 0]),
-        Err(Error::ConvertFromBytes { .. })
-    ));
-
-    assert!(matches!(
-        SecretKey::try_from_bytes(&[0, 0, 0]),
-        Err(Error::ConvertFromBytes { .. })
-    ));
-}
-
-#[test]
-fn to_string_x25519() {
-    let sk = SecretKey::try_from_bytes(&random_bits()).unwrap();
-    let pk = PublicKey::from(&sk);
-
-    assert_eq!(
-        format!("x25519:{}", bs58::encode(&sk.to_bytes()).into_string()),
-        sk.string()
-    );
-    assert_eq!(
-        format!("x25519:{}", bs58::encode(&pk.to_bytes()).into_string()),
-        pk.string()
-    );
-}
-
-#[test]
-fn from_string_x25519() {
-    let sk = SecretKey::try_from_bytes(&random_bits()).unwrap();
-    let pk = PublicKey::from(&sk);
-
-    let _ = SecretKey::from_string(
-        format!("x25519:{}", bs58::encode(&sk.to_bytes()).into_string()).as_str(),
-    )
-    .unwrap();
-
-    let _ = PublicKey::from_string(
-        format!("x25519:{}", bs58::encode(&pk.to_bytes()).into_string()).as_str(),
-    )
-    .unwrap();
-
-    assert!(matches!(
-        PublicKey::from_string(
-            format!("ed25519:{}", bs58::encode(vec![0, 0, 0]).into_string()).as_str()
-        ),
-        Err(Error::WrongKeyType { .. })
-    ));
-
-    assert!(matches!(
-        SecretKey::from_string(
-            format!("ed25519:{}", bs58::encode(vec![0, 0, 0]).into_string()).as_str(),
-        ),
-        Err(Error::WrongKeyType { .. })
-    ));
-
-    assert!(matches!(
-        SecretKey::from_string(
-            format!("x25519:{}", bs58::encode(vec![0, 0, 0]).into_string()).as_str(),
-        ),
-        Err(Error::ConvertFromBytes { .. })
-    ));
-
-    assert!(matches!(
-        SecretKey::from_string(format!("x25519:{}", "==1234%#").as_str(),),
-        Err(Error::ConvertFromString { .. })
-    ));
-
-    assert!(matches!(
-        PublicKey::from_string(
-            format!("x25519:{}", bs58::encode(vec![0, 0, 0]).into_string()).as_str(),
-        ),
-        Err(Error::ConvertFromBytes { .. })
-    ));
-
-    assert!(matches!(
-        PublicKey::from_string(format!("x25519:{}", "==1234%#").as_str(),),
-        Err(Error::ConvertFromString { .. })
-    ));
-}
-
-#[test]
-fn public_key_verify() {
-    let sk = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
-    let pk = Ed25519PublicKey::from(&sk);
-
-    let signature = sk.sign(b"message", &pk);
-    pk.verify(b"message", &signature).unwrap();
-}
-
-#[test]
-fn keypair_verify() {
-    let keypair = Keypair::new(Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap());
-    let signature = keypair.sign(b"message");
-    keypair.verify(b"message", &signature).unwrap();
-}
-
-#[test]
-fn key_exchange() {
-    let alice_sk = SecretKey::try_from_bytes(&random_bits()).unwrap();
-    let alice_pk = PublicKey::from(&alice_sk);
-
-    let bob_sk = SecretKey::try_from_bytes(&random_bits()).unwrap();
-    let bob_pk = PublicKey::from(&bob_sk);
-
-    assert_eq!(alice_sk.exchange(&bob_pk), bob_sk.exchange(&alice_pk));
-}
-
-#[test]
-fn borsh_ed25519() {
-    let sk = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
-    let sk_bytes = borsh::to_vec(&sk).unwrap();
-    let pk = Ed25519PublicKey::from(&sk);
-    let pk_bytes = borsh::to_vec(&pk).unwrap();
-
-    assert_eq!(pk_bytes.len(), pk.as_bytes().len() + 1);
-    assert_eq!(pk_bytes[0], 0);
-    assert_eq!(sk_bytes.len(), sk.as_bytes().len());
-
-    let sk = Ed25519SecretKey::try_from_slice(&sk_bytes).unwrap();
-    let pk = Ed25519PublicKey::try_from_slice(&pk_bytes).unwrap();
-
-    let signature_bytes = borsh::to_vec(&sk.sign(b"message", &pk)).unwrap();
-    pk.verify(
-        b"message",
-        &Ed25519Signature::try_from_slice(&signature_bytes).unwrap(),
-    )
-    .unwrap();
-}
-
-#[test]
-fn borsh_x25519() {
-    let sk = SecretKey::try_from_bytes(&random_bits()).unwrap();
-    let sk_bytes = borsh::to_vec(&sk).unwrap();
-    let pk = PublicKey::from(&sk);
-    let pk_bytes = borsh::to_vec(&pk).unwrap();
-
-    // just try to serialize and deserialize. We doesn't support key-exchange for now
-    let _ = SecretKey::try_from_slice(&sk_bytes).unwrap();
-    let _ = PublicKey::try_from_slice(&pk_bytes).unwrap();
-}
-
-#[test]
-fn keypair_from_str() {
-    let sk = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
-    let pk = Ed25519PublicKey::from(&sk);
-
-    let mut sk_bytes = sk.to_bytes().to_vec();
-    sk_bytes.extend_from_slice(&pk.to_bytes());
-
-    let keypair_bs58 = format!("ed25519:{}", bs58::encode(sk_bytes).into_string());
-
-    let keypair = Keypair::from_str(&keypair_bs58).unwrap();
-
-    assert_eq!(keypair.secret_key().to_bytes(), sk.to_bytes());
-    assert_eq!(keypair.public_key().to_bytes(), pk.to_bytes());
-}
-
-#[test]
-fn keypair_to_string() {
-    let sk = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
-    let pk = Ed25519PublicKey::from(&sk);
-
-    let mut sk_bytes = sk.to_bytes().to_vec();
-    sk_bytes.extend_from_slice(&pk.to_bytes());
-
-    let keypair_bs58 = format!("ed25519:{}", bs58::encode(sk_bytes).into_string());
-    let keypair = Keypair::new(sk);
-
-    assert_eq!(keypair_bs58, keypair.to_string());
-}
-
-#[test]
-fn convert_from_edwards_to_montgomery() {
-    let alice_sk = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
-    let bob_sk = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
-
-    let alice_pk = Ed25519PublicKey::from(&alice_sk);
-    let bob_pk = Ed25519PublicKey::from(&bob_sk);
-
-    let alice_sk_dhx = SecretKey::try_from(alice_sk).unwrap();
-    let bob_sk_dhx = SecretKey::try_from(bob_sk).unwrap();
-
-    let alice_pk_dhx = PublicKey::try_from(alice_pk).unwrap();
-    let bob_pk_dhx = PublicKey::try_from(bob_pk).unwrap();
-
-    assert_eq!(
-        alice_sk_dhx.exchange(&bob_pk_dhx),
-        bob_sk_dhx.exchange(&alice_pk_dhx)
-    );
-}
-
-fn random_bits() -> [u8; ED25519_SECRET_KEY_LENGTH] {
-    let mut chacha = ChaChaRng::from_entropy();
-    let mut secret_bytes = [0_u8; ED25519_SECRET_KEY_LENGTH];
-    chacha.fill_bytes(&mut secret_bytes);
-    secret_bytes
-}

near-primitives-light/Cargo.toml

@@ -1,17 +0,0 @@
-[package]
-name = "near-primitives-light"
-version = "0.1.0"
-edition = "2021"
-authors = ["silvestr@relayz.io"]
-description = """
-Copy-paste from a https://github.com/near/nearcore.
-It's a reduced implementation of near primitives.
-"""
-
-[dependencies]
-borsh = "0.9"
-common-api = { path = "../common-api" }
-chrono = { version = "0.4", features = ["serde"] }
-serde = { version = "1", default-features = false, features = ["derive", "rc"] }
-near-primitives-core = "0.15"
-near-vm-errors = "3.1"

near-primitives-light/src/errors.rs

@@ -1,802 +0,0 @@
-use serde::{Deserialize, Serialize};
-use std::fmt::{Debug, Display};
-
-use near_primitives_core::{
-    hash::CryptoHash,
-    serialize::dec_format,
-    types::{AccountId, Balance, Gas, Nonce},
-};
-
-use common_api::crypto::prelude::*;
-
-use borsh::{BorshDeserialize, BorshSerialize};
-
-/// Error returned in the ExecutionOutcome in case of failure
-#[derive(BorshSerialize, BorshDeserialize, Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
-pub enum TxExecutionError {
-    /// An error happened during Action execution
-    ActionError(ActionError),
-    /// An error happened during Transaction execution
-    InvalidTxError(InvalidTxError),
-}
-
-impl std::error::Error for TxExecutionError {}
-
-impl Display for TxExecutionError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        match self {
-            TxExecutionError::ActionError(e) => write!(f, "{e}"),
-            TxExecutionError::InvalidTxError(e) => write!(f, "{e}"),
-        }
-    }
-}
-
-impl From<ActionError> for TxExecutionError {
-    fn from(error: ActionError) -> Self {
-        TxExecutionError::ActionError(error)
-    }
-}
-
-impl From<InvalidTxError> for TxExecutionError {
-    fn from(error: InvalidTxError) -> Self {
-        TxExecutionError::InvalidTxError(error)
-    }
-}
-
-/// Error returned from `Runtime::apply`
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum RuntimeError {
-    /// An unexpected integer overflow occurred. The likely issue is an invalid state or the transition.
-    UnexpectedIntegerOverflow,
-    /// An error happened during TX verification and account charging. It's likely the chunk is invalid.
-    /// and should be challenged.
-    InvalidTxError(InvalidTxError),
-    /// Unexpected error which is typically related to the node storage corruption.
-    /// It's possible the input state is invalid or malicious.
-    StorageError(StorageError),
-    /// An error happens if `check_balance` fails, which is likely an indication of an invalid state.
-    BalanceMismatchError(BalanceMismatchError),
-    /// The incoming receipt didn't pass the validation, it's likely a malicious behaviour.
-    ReceiptValidationError(ReceiptValidationError),
-    /// Error when accessing validator information. Happens inside epoch manager.
-    ValidatorError(EpochError),
-}
-
-impl std::fmt::Display for RuntimeError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        f.write_str(&format!("{self:?}"))
-    }
-}
-
-impl std::error::Error for RuntimeError {}
-
-/// Internal
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum StorageError {
-    /// Key-value db internal failure
-    StorageInternalError,
-    /// Storage is PartialStorage and requested a missing trie node
-    TrieNodeMissing,
-    /// Either invalid state or key-value db is corrupted.
-    /// For PartialStorage it cannot be corrupted.
-    /// Error message is unreliable and for debugging purposes only. It's also probably ok to
-    /// panic in every place that produces this error.
-    /// We can check if db is corrupted by verifying everything in the state trie.
-    StorageInconsistentState(String),
-    /// Error from flat storage
-    FlatStorageError(String),
-}
-
-impl std::fmt::Display for StorageError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        f.write_str(&format!("{self:?}"))
-    }
-}
-
-impl std::error::Error for StorageError {}
-
-/// An error happened during TX execution
-#[derive(BorshSerialize, BorshDeserialize, Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
-pub enum InvalidTxError {
-    /// Happens if a wrong AccessKey used or AccessKey has not enough permissions
-    InvalidAccessKeyError(InvalidAccessKeyError),
-    /// TX signer_id is not a valid [`AccountId`]
-    InvalidSignerId { signer_id: String },
-    /// TX signer_id is not found in a storage
-    SignerDoesNotExist { signer_id: AccountId },
-    /// Transaction nonce must be `account[access_key].nonce + 1`.
-    InvalidNonce { tx_nonce: Nonce, ak_nonce: Nonce },
-    /// Transaction nonce is larger than the upper bound given by the block height
-    NonceTooLarge { tx_nonce: Nonce, upper_bound: Nonce },
-    /// TX receiver_id is not a valid AccountId
-    InvalidReceiverId { receiver_id: String },
-    /// TX signature is not valid
-    InvalidSignature,
-    /// Account does not have enough balance to cover TX cost
-    NotEnoughBalance {
-        signer_id: AccountId,
-        #[serde(with = "dec_format")]
-        balance: Balance,
-        #[serde(with = "dec_format")]
-        cost: Balance,
-    },
-    /// Signer account doesn't have enough balance after transaction.
-    LackBalanceForState {
-        /// An account which doesn't have enough balance to cover storage.
-        signer_id: AccountId,
-        /// Required balance to cover the state.
-        #[serde(with = "dec_format")]
-        amount: Balance,
-    },
-    /// An integer overflow occurred during transaction cost estimation.
-    CostOverflow,
-    /// Transaction parent block hash doesn't belong to the current chain
-    InvalidChain,
-    /// Transaction has expired
-    Expired,
-    /// An error occurred while validating actions of a Transaction.
-    ActionsValidation(ActionsValidationError),
-    /// The size of serialized transaction exceeded the limit.
-    TransactionSizeExceeded { size: u64, limit: u64 },
-}
-
-impl std::error::Error for InvalidTxError {}
-
-#[derive(BorshSerialize, BorshDeserialize, Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
-pub enum InvalidAccessKeyError {
-    /// The access key identified by the `public_key` doesn't exist for the account
-    AccessKeyNotFound {
-        account_id: AccountId,
-        public_key: Ed25519PublicKey,
-    },
-    /// Transaction `receiver_id` doesn't match the access key receiver_id
-    ReceiverMismatch {
-        tx_receiver: AccountId,
-        ak_receiver: String,
-    },
-    /// Transaction method name isn't allowed by the access key
-    MethodNameMismatch { method_name: String },
-    /// Transaction requires a full permission access key.
-    RequiresFullAccess,
-    /// Access Key does not have enough allowance to cover transaction cost
-    NotEnoughAllowance {
-        account_id: AccountId,
-        public_key: Ed25519PublicKey,
-        #[serde(with = "dec_format")]
-        allowance: Balance,
-        #[serde(with = "dec_format")]
-        cost: Balance,
-    },
-    /// Having a deposit with a function call action is not allowed with a function call access key.
-    DepositWithFunctionCall,
-}
-
-/// Describes the error for validating a list of actions.
-#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
-pub enum ActionsValidationError {
-    /// The delete action must be a final aciton in transaction
-    DeleteActionMustBeFinal,
-    /// The total prepaid gas (for all given actions) exceeded the limit.
-    TotalPrepaidGasExceeded { total_prepaid_gas: Gas, limit: Gas },
-    /// The number of actions exceeded the given limit.
-    TotalNumberOfActionsExceeded {
-        total_number_of_actions: u64,
-        limit: u64,
-    },
-    /// The total number of bytes of the method names exceeded the limit in a Add Key action.
-    AddKeyMethodNamesNumberOfBytesExceeded {
-        total_number_of_bytes: u64,
-        limit: u64,
-    },
-    /// The length of some method name exceeded the limit in a Add Key action.
-    AddKeyMethodNameLengthExceeded { length: u64, limit: u64 },
-    /// Integer overflow during a compute.
-    IntegerOverflow,
-    /// Invalid account ID.
-    InvalidAccountId { account_id: String },
-    /// The size of the contract code exceeded the limit in a DeployContract action.
-    ContractSizeExceeded { size: u64, limit: u64 },
-    /// The length of the method name exceeded the limit in a Function Call action.
-    FunctionCallMethodNameLengthExceeded { length: u64, limit: u64 },
-    /// The length of the arguments exceeded the limit in a Function Call action.
-    FunctionCallArgumentsLengthExceeded { length: u64, limit: u64 },
-    /// An attempt to stake with a public key that is not convertible to ristretto.
-    UnsuitableStakingKey { public_key: Ed25519PublicKey },
-    /// The attached amount of gas in a FunctionCall action has to be a positive number.
-    FunctionCallZeroAttachedGas,
-}
-
-/// Describes the error for validating a receipt.
-#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
-pub enum ReceiptValidationError {
-    /// The `predecessor_id` of a Receipt is not valid.
-    InvalidPredecessorId { account_id: String },
-    /// The `receiver_id` of a Receipt is not valid.
-    InvalidReceiverId { account_id: String },
-    /// The `signer_id` of an ActionReceipt is not valid.
-    InvalidSignerId { account_id: String },
-    /// The `receiver_id` of a DataReceiver within an ActionReceipt is not valid.
-    InvalidDataReceiverId { account_id: String },
-    /// The length of the returned data exceeded the limit in a DataReceipt.
-    ReturnedValueLengthExceeded { length: u64, limit: u64 },
-    /// The number of input data dependencies exceeds the limit in an ActionReceipt.
-    NumberInputDataDependenciesExceeded {
-        number_of_input_data_dependencies: u64,
-        limit: u64,
-    },
-    /// An error occurred while validating actions of an ActionReceipt.
-    ActionsValidation(ActionsValidationError),
-}
-
-impl Display for ReceiptValidationError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        match self {
-            ReceiptValidationError::InvalidPredecessorId { account_id } => {
-                write!(f, "The predecessor_id `{account_id}` of a Receipt is not valid.")
-            }
-            ReceiptValidationError::InvalidReceiverId { account_id } => {
-                write!(f, "The receiver_id `{account_id}` of a Receipt is not valid.")
-            }
-            ReceiptValidationError::InvalidSignerId { account_id } => {
-                write!(f, "The signer_id `{account_id}` of an ActionReceipt is not valid.")
-            }
-            ReceiptValidationError::InvalidDataReceiverId { account_id } => write!(
-                f,
-                "The receiver_id `{account_id}` of a DataReceiver within an ActionReceipt is not valid."
-            ),
-            ReceiptValidationError::ReturnedValueLengthExceeded { length, limit } => write!(
-                f,
-                "The length of the returned data {length} exceeded the limit {limit} in a DataReceipt"
-            ),
-            ReceiptValidationError::NumberInputDataDependenciesExceeded { number_of_input_data_dependencies, limit } => write!(
-                f,
-                "The number of input data dependencies {number_of_input_data_dependencies} exceeded the limit {limit} in an ActionReceipt"
-            ),
-            ReceiptValidationError::ActionsValidation(e) => write!(f, "{e}"),
-        }
-    }
-}
-
-impl std::error::Error for ReceiptValidationError {}
-
-impl Display for ActionsValidationError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        match self {
-            ActionsValidationError::DeleteActionMustBeFinal => {
-                write!(f, "The delete action must be the last action in transaction")
-            }
-            ActionsValidationError::TotalPrepaidGasExceeded { total_prepaid_gas, limit } => {
-                write!(f, "The total prepaid gas {total_prepaid_gas} exceeds the limit {limit}")
-            }
-            ActionsValidationError::TotalNumberOfActionsExceeded {total_number_of_actions, limit } => {
-                write!(
-                    f,
-                    "The total number of actions {total_number_of_actions} exceeds the limit {limit}"
-                )
-            }
-            ActionsValidationError::AddKeyMethodNamesNumberOfBytesExceeded { total_number_of_bytes, limit } => write!(
-                f,
-                "The total number of bytes in allowed method names {total_number_of_bytes} exceeds the maximum allowed number {limit} in a AddKey action"
-            ),
-            ActionsValidationError::AddKeyMethodNameLengthExceeded { length, limit } => write!(
-                f,
-                "The length of some method name {length} exceeds the maximum allowed length {limit} in a AddKey action"
-            ),
-            ActionsValidationError::IntegerOverflow => write!(
-                f,
-                "Integer overflow during a compute",
-            ),
-            ActionsValidationError::InvalidAccountId { account_id } => write!(
-                f,
-                "Invalid account ID `{account_id}`"
-            ),
-            ActionsValidationError::ContractSizeExceeded { size, limit } => write!(
-                f,
-                "The length of the contract size {size} exceeds the maximum allowed size {limit} in a DeployContract action"
-            ),
-            ActionsValidationError::FunctionCallMethodNameLengthExceeded { length, limit } => write!(
-                f,
-                "The length of the method name {length} exceeds the maximum allowed length {limit} in a FunctionCall action"
-            ),
-            ActionsValidationError::FunctionCallArgumentsLengthExceeded { length, limit } => write!(
-                f,
-                "The length of the arguments {length} exceeds the maximum allowed length {limit} in a FunctionCall action"
-            ),
-            ActionsValidationError::UnsuitableStakingKey { public_key } => write!(
-                f,
-                "The staking key must be ristretto compatible ED25519 key. {public_key} is provided instead."
-            ),
-            ActionsValidationError::FunctionCallZeroAttachedGas => write!(
-                f,
-                "The attached amount of gas in a FunctionCall action has to be a positive number",
-            ),
-        }
-    }
-}
-
-impl std::error::Error for ActionsValidationError {}
-
-/// An error happened during Action execution
-#[derive(BorshSerialize, BorshDeserialize, Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
-pub struct ActionError {
-    /// Index of the failed action in the transaction.
-    /// Action index is not defined if ActionError.kind is `ActionErrorKind::LackBalanceForState`
-    pub index: Option<u64>,
-    /// The kind of ActionError happened
-    pub kind: ActionErrorKind,
-}
-
-impl std::error::Error for ActionError {}
-
-#[derive(BorshSerialize, BorshDeserialize, Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
-pub enum ActionErrorKind {
-    /// Happens when CreateAccount action tries to create an account with account_id which is already exists in the storage
-    AccountAlreadyExists { account_id: AccountId },
-    /// Happens when TX receiver_id doesn't exist (but action is not Action::CreateAccount)
-    AccountDoesNotExist { account_id: AccountId },
-    /// A top-level account ID can only be created by registrar.
-    CreateAccountOnlyByRegistrar {
-        account_id: AccountId,
-        registrar_account_id: AccountId,
-        predecessor_id: AccountId,
-    },
-    /// A newly created account must be under a namespace of the creator account
-    CreateAccountNotAllowed {
-        account_id: AccountId,
-        predecessor_id: AccountId,
-    },
-    /// Administrative actions like `DeployContract`, `Stake`, `AddKey`, `DeleteKey`. can be proceed only if sender=receiver
-    /// or the first TX action is a `CreateAccount` action
-    ActorNoPermission {
-        account_id: AccountId,
-        actor_id: AccountId,
-    },
-    /// Account tries to remove an access key that doesn't exist
-    DeleteKeyDoesNotExist {
-        account_id: AccountId,
-        public_key: Ed25519PublicKey,
-    },
-    /// The public key is already used for an existing access key
-    AddKeyAlreadyExists {
-        account_id: AccountId,
-        public_key: Ed25519PublicKey,
-    },
-    /// Account is staking and can not be deleted
-    DeleteAccountStaking { account_id: AccountId },
-    /// ActionReceipt can't be completed, because the remaining balance will not be enough to cover storage.
-    LackBalanceForState {
-        /// An account which needs balance
-        account_id: AccountId,
-        /// Balance required to complete an action.
-        #[serde(with = "dec_format")]
-        amount: Balance,
-    },
-    /// Account is not yet staked, but tries to unstake
-    TriesToUnstake { account_id: AccountId },
-    /// The account doesn't have enough balance to increase the stake.
-    TriesToStake {
-        account_id: AccountId,
-        #[serde(with = "dec_format")]
-        stake: Balance,
-        #[serde(with = "dec_format")]
-        locked: Balance,
-        #[serde(with = "dec_format")]
-        balance: Balance,
-    },
-    InsufficientStake {
-        account_id: AccountId,
-        #[serde(with = "dec_format")]
-        stake: Balance,
-        #[serde(with = "dec_format")]
-        minimum_stake: Balance,
-    },
-    /// An error occurred during a `FunctionCall` Action, parameter is debug message.
-    FunctionCallError(near_vm_errors::FunctionCallErrorSer),
-    /// Error occurs when a new `ActionReceipt` created by the `FunctionCall` action fails
-    /// receipt validation.
-    NewReceiptValidationError(ReceiptValidationError),
-    /// Error occurs when a `CreateAccount` action is called on hex-characters
-    /// account of length 64.  See implicit account creation NEP:
-    /// <https://github.com/nearprotocol/NEPs/pull/71>.
-    OnlyImplicitAccountCreationAllowed { account_id: AccountId },
-    /// Delete account whose state is large is temporarily banned.
-    DeleteAccountWithLargeState { account_id: AccountId },
-}
-
-impl From<ActionErrorKind> for ActionError {
-    fn from(e: ActionErrorKind) -> ActionError {
-        ActionError {
-            index: None,
-            kind: e,
-        }
-    }
-}
-
-impl Display for InvalidTxError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        match self {
-            InvalidTxError::InvalidSignerId { signer_id } => {
-                write!(
-                    f,
-                    "Invalid signer account ID {signer_id:?} according to requirements"
-                )
-            }
-            InvalidTxError::SignerDoesNotExist { signer_id } => {
-                write!(f, "Signer {signer_id:?} does not exist")
-            }
-            InvalidTxError::InvalidAccessKeyError(access_key_error) => {
-                Display::fmt(&access_key_error, f)
-            }
-            InvalidTxError::InvalidNonce { tx_nonce, ak_nonce } => write!(
-                f,
-                "Transaction nonce {tx_nonce} must be larger than nonce of the used access key {ak_nonce}"
-            ),
-            InvalidTxError::InvalidReceiverId { receiver_id } => {
-                write!(
-                    f,
-                    "Invalid receiver account ID {receiver_id:?} according to requirements"
-                )
-            }
-            InvalidTxError::InvalidSignature => {
-                write!(f, "Transaction is not signed with the given public key")
-            }
-            InvalidTxError::NotEnoughBalance {
-                signer_id,
-                balance,
-                cost,
-            } => write!(
-                f,
-                "Sender {signer_id:?} does not have enough balance {balance} for operation costing {cost}"
-            ),
-            InvalidTxError::LackBalanceForState { signer_id, amount } => {
-                write!(f, "Failed to execute, because the account {signer_id:?} wouldn't have enough balance to cover storage, required to have {amount} yoctoNEAR more")
-            }
-            InvalidTxError::CostOverflow => {
-                write!(f, "Transaction gas or balance cost is too high")
-            }
-            InvalidTxError::InvalidChain => {
-                write!(
-                    f,
-                    "Transaction parent block hash doesn't belong to the current chain"
-                )
-            }
-            InvalidTxError::Expired => {
-                write!(f, "Transaction has expired")
-            }
-            InvalidTxError::ActionsValidation(error) => {
-                write!(f, "Transaction actions validation error: {error}")
-            }
-            InvalidTxError::NonceTooLarge {
-                tx_nonce,
-                upper_bound,
-            } => {
-                write!(
-                    f,
-                    "Transaction nonce {tx_nonce} must be smaller than the access key nonce upper bound {upper_bound}"
-                )
-            }
-            InvalidTxError::TransactionSizeExceeded { size, limit } => {
-                write!(
-                    f,
-                    "Size of serialized transaction {size} exceeded the limit {limit}"
-                )
-            }
-        }
-    }
-}
-
-impl From<InvalidAccessKeyError> for InvalidTxError {
-    fn from(error: InvalidAccessKeyError) -> Self {
-        InvalidTxError::InvalidAccessKeyError(error)
-    }
-}
-
-impl Display for InvalidAccessKeyError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        match self {
-            InvalidAccessKeyError::AccessKeyNotFound {
-                account_id,
-                public_key,
-            } => write!(
-                f,
-                "Signer {account_id:?} doesn't have access key with the given public_key {public_key}"
-            ),
-            InvalidAccessKeyError::ReceiverMismatch {
-                tx_receiver,
-                ak_receiver,
-            } => write!(
-                f,
-                "Transaction receiver_id {tx_receiver:?} doesn't match the access key receiver_id {ak_receiver:?}",
-            ),
-            InvalidAccessKeyError::MethodNameMismatch { method_name } => write!(
-                f,
-                "Transaction method name {method_name:?} isn't allowed by the access key"
-            ),
-            InvalidAccessKeyError::RequiresFullAccess => {
-                write!(f, "Invalid access key type. Full-access keys are required for transactions that have multiple or non-function-call actions")
-            }
-            InvalidAccessKeyError::NotEnoughAllowance {
-                account_id,
-                public_key,
-                allowance,
-                cost,
-            } => write!(
-                f,
-                "Access Key {account_id:?}:{public_key} does not have enough balance {allowance} for transaction costing {cost}"
-            ),
-            InvalidAccessKeyError::DepositWithFunctionCall => {
-                write!(f, "Having a deposit with a function call action is not allowed with a function call access key.")
-            }
-        }
-    }
-}
-
-impl std::error::Error for InvalidAccessKeyError {}
-
-/// Happens when the input balance doesn't match the output balance in Runtime apply.
-#[derive(BorshSerialize, BorshDeserialize, Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
-pub struct BalanceMismatchError {
-    // Input balances
-    #[serde(with = "dec_format")]
-    pub incoming_validator_rewards: Balance,
-    #[serde(with = "dec_format")]
-    pub initial_accounts_balance: Balance,
-    #[serde(with = "dec_format")]
-    pub incoming_receipts_balance: Balance,
-    #[serde(with = "dec_format")]
-    pub processed_delayed_receipts_balance: Balance,
-    #[serde(with = "dec_format")]
-    pub initial_postponed_receipts_balance: Balance,
-    // Output balances
-    #[serde(with = "dec_format")]
-    pub final_accounts_balance: Balance,
-    #[serde(with = "dec_format")]
-    pub outgoing_receipts_balance: Balance,
-    #[serde(with = "dec_format")]
-    pub new_delayed_receipts_balance: Balance,
-    #[serde(with = "dec_format")]
-    pub final_postponed_receipts_balance: Balance,
-    #[serde(with = "dec_format")]
-    pub tx_burnt_amount: Balance,
-    #[serde(with = "dec_format")]
-    pub slashed_burnt_amount: Balance,
-    #[serde(with = "dec_format")]
-    pub other_burnt_amount: Balance,
-}
-
-impl Display for BalanceMismatchError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        // Using saturating add to avoid overflow in display
-        let initial_balance = self
-            .incoming_validator_rewards
-            .saturating_add(self.initial_accounts_balance)
-            .saturating_add(self.incoming_receipts_balance)
-            .saturating_add(self.processed_delayed_receipts_balance)
-            .saturating_add(self.initial_postponed_receipts_balance);
-        let final_balance = self
-            .final_accounts_balance
-            .saturating_add(self.outgoing_receipts_balance)
-            .saturating_add(self.new_delayed_receipts_balance)
-            .saturating_add(self.final_postponed_receipts_balance)
-            .saturating_add(self.tx_burnt_amount)
-            .saturating_add(self.slashed_burnt_amount)
-            .saturating_add(self.other_burnt_amount);
-        write!(
-            f,
-            "Balance Mismatch Error. The input balance {} doesn't match output balance {}\n\
-             Inputs:\n\
-             \tIncoming validator rewards sum: {}\n\
-             \tInitial accounts balance sum: {}\n\
-             \tIncoming receipts balance sum: {}\n\
-             \tProcessed delayed receipts balance sum: {}\n\
-             \tInitial postponed receipts balance sum: {}\n\
-             Outputs:\n\
-             \tFinal accounts balance sum: {}\n\
-             \tOutgoing receipts balance sum: {}\n\
-             \tNew delayed receipts balance sum: {}\n\
-             \tFinal postponed receipts balance sum: {}\n\
-             \tTx fees burnt amount: {}\n\
-             \tSlashed amount: {}\n\
-             \tOther burnt amount: {}",
-            initial_balance,
-            final_balance,
-            self.incoming_validator_rewards,
-            self.initial_accounts_balance,
-            self.incoming_receipts_balance,
-            self.processed_delayed_receipts_balance,
-            self.initial_postponed_receipts_balance,
-            self.final_accounts_balance,
-            self.outgoing_receipts_balance,
-            self.new_delayed_receipts_balance,
-            self.final_postponed_receipts_balance,
-            self.tx_burnt_amount,
-            self.slashed_burnt_amount,
-            self.other_burnt_amount,
-        )
-    }
-}
-
-impl std::error::Error for BalanceMismatchError {}
-
-#[derive(BorshSerialize, BorshDeserialize, Debug, Clone, PartialEq, Eq)]
-pub struct IntegerOverflowError;
-
-impl std::fmt::Display for IntegerOverflowError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        f.write_str(&format!("{self:?}"))
-    }
-}
-
-impl std::error::Error for IntegerOverflowError {}
-
-impl From<IntegerOverflowError> for InvalidTxError {
-    fn from(_: IntegerOverflowError) -> Self {
-        InvalidTxError::CostOverflow
-    }
-}
-
-impl From<IntegerOverflowError> for RuntimeError {
-    fn from(_: IntegerOverflowError) -> Self {
-        RuntimeError::UnexpectedIntegerOverflow
-    }
-}
-
-impl From<StorageError> for RuntimeError {
-    fn from(e: StorageError) -> Self {
-        RuntimeError::StorageError(e)
-    }
-}
-
-impl From<BalanceMismatchError> for RuntimeError {
-    fn from(e: BalanceMismatchError) -> Self {
-        RuntimeError::BalanceMismatchError(e)
-    }
-}
-
-impl From<InvalidTxError> for RuntimeError {
-    fn from(e: InvalidTxError) -> Self {
-        RuntimeError::InvalidTxError(e)
-    }
-}
-
-impl From<EpochError> for RuntimeError {
-    fn from(e: EpochError) -> Self {
-        RuntimeError::ValidatorError(e)
-    }
-}
-
-impl Display for ActionError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        write!(
-            f,
-            "Action #{}: {}",
-            self.index.unwrap_or_default(),
-            self.kind
-        )
-    }
-}
-
-impl Display for ActionErrorKind {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        match self {
-            ActionErrorKind::AccountAlreadyExists { account_id } => {
-                write!(f, "Can't create a new account {account_id:?}, because it already exists")
-            }
-            ActionErrorKind::AccountDoesNotExist { account_id } => write!(
-                f,
-                "Can't complete the action because account {account_id:?} doesn't exist"
-            ),
-            ActionErrorKind::ActorNoPermission { actor_id, account_id } => write!(
-                f,
-                "Actor {actor_id:?} doesn't have permission to account {account_id:?} to complete the action"
-            ),
-            ActionErrorKind::LackBalanceForState { account_id, amount } => write!(
-                f,
-                "The account {account_id} wouldn't have enough balance to cover storage, required to have {amount} yoctoNEAR more"
-            ),
-            ActionErrorKind::TriesToUnstake { account_id } => {
-                write!(f, "Account {account_id:?} is not yet staked, but tries to unstake")
-            }
-            ActionErrorKind::TriesToStake { account_id, stake, locked, balance } => write!(
-                f,
-                "Account {account_id:?} tries to stake {stake}, but has staked {locked} and only has {balance}"
-            ),
-            ActionErrorKind::CreateAccountOnlyByRegistrar { account_id, registrar_account_id, predecessor_id } => write!(
-                f,
-                "A top-level account ID {account_id:?} can't be created by {predecessor_id:?}, short top-level account IDs can only be created by {registrar_account_id:?}"
-            ),
-            ActionErrorKind::CreateAccountNotAllowed { account_id, predecessor_id } => write!(
-                f,
-                "A sub-account ID {account_id:?} can't be created by account {predecessor_id:?}"
-            ),
-            ActionErrorKind::DeleteKeyDoesNotExist { account_id, .. } => write!(
-                f,
-                "Account {account_id:?} tries to remove an access key that doesn't exist"
-            ),
-            ActionErrorKind::AddKeyAlreadyExists { public_key, .. } => write!(
-                f,
-                "The public key {public_key:?} is already used for an existing access key"
-            ),
-            ActionErrorKind::DeleteAccountStaking { account_id } => {
-                write!(f, "Account {account_id:?} is staking and can not be deleted")
-            }
-            ActionErrorKind::FunctionCallError(s) => write!(f, "{s:?}"),
-            ActionErrorKind::NewReceiptValidationError(e) => {
-                write!(f, "An new action receipt created during a FunctionCall is not valid: {e}")
-            }
-            ActionErrorKind::InsufficientStake { account_id, stake, minimum_stake } => write!(f, "Account {account_id} tries to stake {stake} but minimum required stake is {minimum_stake}"),
-            ActionErrorKind::OnlyImplicitAccountCreationAllowed { account_id } => write!(f, "CreateAccount action is called on hex-characters account of length 64 {account_id}"),
-            ActionErrorKind::DeleteAccountWithLargeState { account_id } => write!(f, "The state of account {account_id} is too large and therefore cannot be deleted"),
-        }
-    }
-}
-
-#[derive(Eq, PartialEq, Clone)]
-pub enum EpochError {
-    /// Error calculating threshold from given stakes for given number of seats.
-    /// Only should happened if calling code doesn't check for integer value of stake > number of seats.
-    ThresholdError { stake_sum: Balance, num_seats: u64 },
-    /// Missing block hash in the storage (means there is some structural issue).
-    MissingBlock(CryptoHash),
-    /// Error due to IO (DB read/write, serialization, etc.).
-    IOErr(String),
-    /// Error getting information for a shard
-    ShardingError(String),
-    NotEnoughValidators {
-        num_validators: u64,
-        num_shards: u64,
-    },
-}
-
-impl std::error::Error for EpochError {}
-
-impl Display for EpochError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            EpochError::ThresholdError {
-                stake_sum,
-                num_seats,
-            } => write!(
-                f,
-                "Total stake {stake_sum} must be higher than the number of seats {num_seats}"
-            ),
-            EpochError::MissingBlock(hash) => write!(f, "Missing block {hash}"),
-            EpochError::IOErr(err) => write!(f, "IO: {err}"),
-            EpochError::ShardingError(err) => write!(f, "Sharding Error: {err}"),
-            EpochError::NotEnoughValidators {
-                num_shards,
-                num_validators,
-            } => {
-                write!(f, "There were not enough validator proposals to fill all shards. num_proposals: {num_validators}, num_shards: {num_shards}")
-            }
-        }
-    }
-}
-
-impl Debug for EpochError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            EpochError::ThresholdError {
-                stake_sum,
-                num_seats,
-            } => {
-                write!(f, "ThresholdError({stake_sum}, {num_seats})")
-            }
-            EpochError::MissingBlock(hash) => write!(f, "MissingBlock({hash})"),
-            EpochError::IOErr(err) => write!(f, "IOErr({err})"),
-            EpochError::ShardingError(err) => write!(f, "ShardingError({err})"),
-            EpochError::NotEnoughValidators {
-                num_shards,
-                num_validators,
-            } => {
-                write!(f, "NotEnoughValidators({num_validators}, {num_shards})")
-            }
-        }
-    }
-}
-
-impl From<std::io::Error> for EpochError {
-    fn from(error: std::io::Error) -> Self {
-        EpochError::IOErr(error.to_string())
-    }
-}

near-primitives-light/src/lib.rs

@@ -1,5 +0,0 @@
-pub mod errors;
-pub mod receipt;
-pub mod transaction;
-pub mod types;
-pub mod views;

near-primitives-light/src/receipt.rs

@@ -1,179 +0,0 @@
-use borsh::{BorshDeserialize, BorshSerialize};
-use near_primitives_core::{
-    hash::CryptoHash,
-    serialize::{dec_format, option_base64_format, to_base58},
-    types::{AccountId, Balance, ShardId},
-};
-use serde::{Deserialize, Serialize};
-use std::{borrow::Borrow, collections::HashMap, fmt, hash::Hash};
-
-use crate::transaction::*;
-use common_api::crypto::prelude::*;
-
-/// Receipts are used for a cross-shard communication.
-/// Receipts could be 2 types (determined by a `ReceiptEnum`): `ReceiptEnum::Action` of `ReceiptEnum::Data`.
-#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
-pub struct Receipt {
-    /// An issuer account_id of a particular receipt.
-    /// `predecessor_id` could be either `Transaction` `signer_id` or intermediate contract's `account_id`.
-    pub predecessor_id: AccountId,
-    /// `receiver_id` is a receipt destination.
-    pub receiver_id: AccountId,
-    /// An unique id for the receipt
-    pub receipt_id: CryptoHash,
-    /// A receipt type
-    pub receipt: ReceiptEnum,
-}
-
-impl Borrow<CryptoHash> for Receipt {
-    fn borrow(&self) -> &CryptoHash {
-        &self.receipt_id
-    }
-}
-
-impl Receipt {
-    /// It's not a content hash, but receipt_id is unique.
-    pub fn get_hash(&self) -> CryptoHash {
-        self.receipt_id
-    }
-
-    /// Generates a receipt with a transfer from system for a given balance without a receipt_id.
-    /// This should be used for token refunds instead of gas refunds. It doesn't refund the
-    /// allowance of the access key. For gas refunds use `new_gas_refund`.
-    pub fn new_balance_refund(receiver_id: &AccountId, refund: Balance) -> Self {
-        Receipt {
-            predecessor_id: "system".parse().unwrap(),
-            receiver_id: receiver_id.clone(),
-            receipt_id: CryptoHash::default(),
-
-            receipt: ReceiptEnum::Action(ActionReceipt {
-                signer_id: "system".parse().unwrap(),
-                signer_public_key: Ed25519PublicKey::try_from_bytes(&[0; 32]).unwrap(),
-                gas_price: 0,
-                output_data_receivers: vec![],
-                input_data_ids: vec![],
-                actions: vec![Action::Transfer(TransferAction { deposit: refund })],
-            }),
-        }
-    }
-
-    /// Generates a receipt with a transfer action from system for a given balance without a
-    /// receipt_id. It contains `signer_id` and `signer_public_key` to indicate this is a gas
-    /// refund. The execution of this receipt will try to refund the allowance of the
-    /// access key with the given public key.
-    /// NOTE: The access key may be replaced by the owner, so the execution can't rely that the
-    /// access key is the same and it should use best effort for the refund.
-    pub fn new_gas_refund(
-        receiver_id: &AccountId,
-        refund: Balance,
-        signer_public_key: Ed25519PublicKey,
-    ) -> Self {
-        Receipt {
-            predecessor_id: "system".parse().unwrap(),
-            receiver_id: receiver_id.clone(),
-            receipt_id: CryptoHash::default(),
-
-            receipt: ReceiptEnum::Action(ActionReceipt {
-                signer_id: receiver_id.clone(),
-                signer_public_key,
-                gas_price: 0,
-                output_data_receivers: vec![],
-                input_data_ids: vec![],
-                actions: vec![Action::Transfer(TransferAction { deposit: refund })],
-            }),
-        }
-    }
-}
-
-/// Receipt could be either ActionReceipt or DataReceipt
-#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
-#[allow(clippy::large_enum_variant)]
-pub enum ReceiptEnum {
-    Action(ActionReceipt),
-    Data(DataReceipt),
-}
-
-/// ActionReceipt is derived from an Action from `Transaction or from Receipt`
-#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
-pub struct ActionReceipt {
-    /// A signer of the original transaction
-    pub signer_id: AccountId,
-    /// An access key which was used to sign the original transaction
-    pub signer_public_key: Ed25519PublicKey,
-    /// A gas_price which has been used to buy gas in the original transaction
-    #[serde(with = "dec_format")]
-    pub gas_price: Balance,
-    /// If present, where to route the output data
-    pub output_data_receivers: Vec<DataReceiver>,
-    /// A list of the input data dependencies for this Receipt to process.
-    /// If all `input_data_ids` for this receipt are delivered to the account
-    /// that means we have all the `ReceivedData` input which will be than converted to a
-    /// `PromiseResult::Successful(value)` or `PromiseResult::Failed`
-    /// depending on `ReceivedData` is `Some(_)` or `None`
-    pub input_data_ids: Vec<CryptoHash>,
-    /// A list of actions to process when all input_data_ids are filled
-    pub actions: Vec<Action>,
-}
-
-/// An incoming (ingress) `DataReceipt` which is going to a Receipt's `receiver` input_data_ids
-/// Which will be converted to `PromiseResult::Successful(value)` or `PromiseResult::Failed`
-#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, Hash, PartialEq, Eq, Clone)]
-pub struct DataReceipt {
-    pub data_id: CryptoHash,
-    #[serde(with = "option_base64_format")]
-    pub data: Option<Vec<u8>>,
-}
-
-impl fmt::Debug for DataReceipt {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("DataReceipt")
-            .field("data_id", &self.data_id)
-            .field(
-                "data",
-                &format_args!("{:?}", self.data.as_deref().map(to_base58)),
-            )
-            .finish()
-    }
-}
-
-/// The outgoing (egress) data which will be transformed
-/// to a `DataReceipt` to be sent to a `receipt.receiver`
-#[derive(
-    BorshSerialize, BorshDeserialize, Serialize, Deserialize, Hash, Clone, Debug, PartialEq, Eq,
-)]
-pub struct DataReceiver {
-    pub data_id: CryptoHash,
-    pub receiver_id: AccountId,
-}
-
-/// A temporary data which is created by processing of DataReceipt
-/// stored in a state trie with a key = `account_id` + `data_id` until
-/// `input_data_ids` of all incoming Receipts are satisfied
-/// None means data retrieval was failed
-#[derive(BorshSerialize, BorshDeserialize, Hash, PartialEq, Eq, Clone)]
-pub struct ReceivedData {
-    pub data: Option<Vec<u8>>,
-}
-
-impl fmt::Debug for ReceivedData {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("ReceivedData")
-            .field(
-                "data",
-                &format_args!("{:?}", self.data.as_deref().map(to_base58)),
-            )
-            .finish()
-    }
-}
-
-/// Stores indices for a persistent queue for delayed receipts that didn't fit into a block.
-#[derive(Default, BorshSerialize, BorshDeserialize, Clone, PartialEq, Eq, Debug)]
-pub struct DelayedReceiptIndices {
-    // First inclusive index in the queue.
-    pub first_index: u64,
-    // Exclusive end index of the queue
-    pub next_available_index: u64,
-}
-
-/// Map of shard to list of receipts to send to it.
-pub type ReceiptResult = HashMap<ShardId, Vec<Receipt>>;

near-primitives-light/src/transaction.rs

@@ -1,401 +0,0 @@
-use std::{
-    borrow::Borrow,
-    fmt,
-    hash::{Hash, Hasher},
-    str::FromStr,
-};
-
-use borsh::{BorshDeserialize, BorshSerialize};
-use common_api::crypto::prelude::*;
-use near_primitives_core::{
-    account::AccessKey,
-    hash::{hash, CryptoHash},
-    profile::ProfileData,
-    serialize::{base64_format, dec_format, to_base58},
-    types::{AccountId, Balance, Gas, Nonce},
-};
-use serde::{Deserialize, Serialize};
-
-use crate::errors::TxExecutionError;
-
-pub type LogEntry = String;
-
-#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
-pub struct Transaction {
-    /// An account on which behalf transaction is signed
-    pub signer_id: AccountId,
-    /// A public key of the access key which was used to sign an account.
-    /// Access key holds permissions for calling certain kinds of actions.
-    pub public_key: Ed25519PublicKey,
-    /// Nonce is used to determine order of transaction in the pool.
-    /// It increments for a combination of `signer_id` and `public_key`
-    pub nonce: Nonce,
-    /// Receiver account for this transaction
-    pub receiver_id: AccountId,
-    /// The hash of the block in the blockchain on top of which the given transaction is valid
-    pub block_hash: CryptoHash,
-    /// A list of actions to be applied
-    pub actions: Vec<Action>,
-}
-
-impl Transaction {
-    /// Computes a hash of the transaction for signing and size of serialized transaction
-    pub fn get_hash_and_size(&self) -> (CryptoHash, u64) {
-        let bytes = self.try_to_vec().expect("Failed to deserialize");
-        (hash(&bytes), bytes.len() as u64)
-    }
-}
-
-#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
-pub enum Action {
-    /// Create an (sub)account using a transaction `receiver_id` as an ID for
-    /// a new account ID must pass validation rules described here
-    /// <http://nomicon.io/Primitives/Account.html>.
-    CreateAccount(CreateAccountAction),
-    /// Sets a Wasm code to a receiver_id
-    DeployContract(DeployContractAction),
-    FunctionCall(FunctionCallAction),
-    Transfer(TransferAction),
-    Stake(StakeAction),
-    AddKey(AddKeyAction),
-    DeleteKey(DeleteKeyAction),
-    DeleteAccount(DeleteAccountAction),
-}
-
-impl Action {
-    pub fn get_prepaid_gas(&self) -> Gas {
-        match self {
-            Action::FunctionCall(a) => a.gas,
-            _ => 0,
-        }
-    }
-    pub fn get_deposit_balance(&self) -> Balance {
-        match self {
-            Action::FunctionCall(a) => a.deposit,
-            Action::Transfer(a) => a.deposit,
-            _ => 0,
-        }
-    }
-}
-
-/// Create account action
-#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
-pub struct CreateAccountAction {}
-
-impl From<CreateAccountAction> for Action {
-    fn from(create_account_action: CreateAccountAction) -> Self {
-        Self::CreateAccount(create_account_action)
-    }
-}
-
-/// Deploy contract action
-#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone)]
-pub struct DeployContractAction {
-    /// WebAssembly binary
-    #[serde(with = "base64_format")]
-    pub code: Vec<u8>,
-}
-
-impl From<DeployContractAction> for Action {
-    fn from(deploy_contract_action: DeployContractAction) -> Self {
-        Self::DeployContract(deploy_contract_action)
-    }
-}
-
-impl fmt::Debug for DeployContractAction {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("DeployContractAction").finish()
-    }
-}
-
-#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone)]
-pub struct FunctionCallAction {
-    pub method_name: String,
-    #[serde(with = "base64_format")]
-    pub args: Vec<u8>,
-    pub gas: Gas,
-    #[serde(with = "dec_format")]
-    pub deposit: Balance,
-}
-
-impl From<FunctionCallAction> for Action {
-    fn from(function_call_action: FunctionCallAction) -> Self {
-        Self::FunctionCall(function_call_action)
-    }
-}
-
-impl fmt::Debug for FunctionCallAction {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("FunctionCallAction")
-            .field("method_name", &format_args!("{}", &self.method_name))
-            .field("args", &format_args!("{}", to_base58(&self.args)))
-            .field("gas", &format_args!("{}", &self.gas))
-            .field("deposit", &format_args!("{}", &self.deposit))
-            .finish()
-    }
-}
-
-#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
-pub struct TransferAction {
-    #[serde(with = "dec_format")]
-    pub deposit: Balance,
-}
-
-impl From<TransferAction> for Action {
-    fn from(transfer_action: TransferAction) -> Self {
-        Self::Transfer(transfer_action)
-    }
-}
-
-/// An action which stakes signer_id tokens and setup's validator public key
-#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
-pub struct StakeAction {
-    /// Amount of tokens to stake.
-    #[serde(with = "dec_format")]
-    pub stake: Balance,
-    /// Validator key which will be used to sign transactions on behalf of signer_id
-    pub public_key: Ed25519PublicKey,
-}
-
-impl From<StakeAction> for Action {
-    fn from(stake_action: StakeAction) -> Self {
-        Self::Stake(stake_action)
-    }
-}
-
-#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
-pub struct AddKeyAction {
-    /// A public key which will be associated with an access_key
-    pub public_key: Ed25519PublicKey,
-    /// An access key with the permission
-    pub access_key: AccessKey,
-}
-
-impl From<AddKeyAction> for Action {
-    fn from(add_key_action: AddKeyAction) -> Self {
-        Self::AddKey(add_key_action)
-    }
-}
-
-#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
-pub struct DeleteKeyAction {
-    /// A public key associated with the access_key to be deleted.
-    pub public_key: Ed25519PublicKey,
-}
-
-impl From<DeleteKeyAction> for Action {
-    fn from(delete_key_action: DeleteKeyAction) -> Self {
-        Self::DeleteKey(delete_key_action)
-    }
-}
-
-#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
-pub struct DeleteAccountAction {
-    pub beneficiary_id: AccountId,
-}
-
-impl From<DeleteAccountAction> for Action {
-    fn from(delete_account_action: DeleteAccountAction) -> Self {
-        Self::DeleteAccount(delete_account_action)
-    }
-}
-
-#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, Eq, Debug, Clone)]
-#[borsh_init(init)]
-pub struct SignedTransaction {
-    pub transaction: Transaction,
-    pub signature: Ed25519Signature,
-    #[borsh_skip]
-    hash: CryptoHash,
-    #[borsh_skip]
-    size: u64,
-}
-
-impl SignedTransaction {
-    pub fn new(signature: Ed25519Signature, transaction: Transaction) -> Self {
-        let mut signed_tx = Self {
-            signature,
-            transaction,
-            hash: CryptoHash::default(),
-            size: u64::default(),
-        };
-        signed_tx.init();
-        signed_tx
-    }
-
-    pub fn init(&mut self) {
-        let (hash, size) = self.transaction.get_hash_and_size();
-        self.hash = hash;
-        self.size = size;
-    }
-
-    pub fn get_hash(&self) -> CryptoHash {
-        self.hash
-    }
-
-    pub fn get_size(&self) -> u64 {
-        self.size
-    }
-}
-
-impl Hash for SignedTransaction {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.hash.hash(state)
-    }
-}
-
-impl PartialEq for SignedTransaction {
-    fn eq(&self, other: &SignedTransaction) -> bool {
-        self.hash == other.hash && self.signature == other.signature
-    }
-}
-
-impl Borrow<CryptoHash> for SignedTransaction {
-    fn borrow(&self) -> &CryptoHash {
-        &self.hash
-    }
-}
-
-/// The status of execution for a transaction or a receipt.
-#[derive(Default, BorshSerialize, BorshDeserialize, PartialEq, Eq, Clone)]
-pub enum ExecutionStatus {
-    /// The execution is pending or unknown.
-    #[default]
-    Unknown,
-    /// The execution has failed with the given execution error.
-    Failure(Box<TxExecutionError>),
-    /// The final action succeeded and returned some value or an empty vec.
-    SuccessValue(Vec<u8>),
-    /// The final action of the receipt returned a promise or the signed transaction was converted
-    /// to a receipt. Contains the receipt_id of the generated receipt.
-    SuccessReceiptId(CryptoHash),
-}
-
-impl fmt::Debug for ExecutionStatus {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            ExecutionStatus::Unknown => f.write_str("Unknown"),
-            ExecutionStatus::Failure(e) => f.write_fmt(format_args!("Failure({e})")),
-            ExecutionStatus::SuccessValue(v) => {
-                f.write_fmt(format_args!("SuccessValue({})", to_base58(v)))
-            }
-            ExecutionStatus::SuccessReceiptId(receipt_id) => {
-                f.write_fmt(format_args!("SuccessReceiptId({receipt_id})"))
-            }
-        }
-    }
-}
-
-/// ExecutionOutcome for proof. Excludes logs and metadata
-#[derive(BorshSerialize, BorshDeserialize, PartialEq, Eq, Clone)]
-pub struct PartialExecutionOutcome {
-    pub receipt_ids: Vec<CryptoHash>,
-    pub gas_burnt: Gas,
-    pub tokens_burnt: Balance,
-    pub executor_id: AccountId,
-    pub status: PartialExecutionStatus,
-}
-
-impl From<&ExecutionOutcome> for PartialExecutionOutcome {
-    fn from(outcome: &ExecutionOutcome) -> Self {
-        Self {
-            receipt_ids: outcome.receipt_ids.clone(),
-            gas_burnt: outcome.gas_burnt,
-            tokens_burnt: outcome.tokens_burnt,
-            executor_id: outcome.executor_id.clone(),
-            status: outcome.status.clone().into(),
-        }
-    }
-}
-
-/// ExecutionStatus for proof. Excludes failure debug info.
-#[derive(BorshSerialize, BorshDeserialize, PartialEq, Eq, Clone)]
-pub enum PartialExecutionStatus {
-    Unknown,
-    Failure,
-    SuccessValue(Vec<u8>),
-    SuccessReceiptId(CryptoHash),
-}
-
-impl From<ExecutionStatus> for PartialExecutionStatus {
-    fn from(status: ExecutionStatus) -> PartialExecutionStatus {
-        match status {
-            ExecutionStatus::Unknown => PartialExecutionStatus::Unknown,
-            ExecutionStatus::Failure(_) => PartialExecutionStatus::Failure,
-            ExecutionStatus::SuccessValue(value) => PartialExecutionStatus::SuccessValue(value),
-            ExecutionStatus::SuccessReceiptId(id) => PartialExecutionStatus::SuccessReceiptId(id),
-        }
-    }
-}
-
-/// Execution outcome for one signed transaction or one receipt.
-#[derive(BorshSerialize, BorshDeserialize, PartialEq, Clone, Eq)]
-pub struct ExecutionOutcome {
-    /// Logs from this transaction or receipt.
-    pub logs: Vec<LogEntry>,
-    /// Receipt IDs generated by this transaction or receipt.
-    pub receipt_ids: Vec<CryptoHash>,
-    /// The amount of the gas burnt by the given transaction or receipt.
-    pub gas_burnt: Gas,
-    /// The amount of tokens burnt corresponding to the burnt gas amount.
-    /// This value doesn't always equal to the `gas_burnt` multiplied by the gas price, because
-    /// the prepaid gas price might be lower than the actual gas price and it creates a deficit.
-    pub tokens_burnt: Balance,
-    /// The id of the account on which the execution happens. For transaction this is signer_id,
-    /// for receipt this is receiver_id.
-    pub executor_id: AccountId,
-    /// Execution status. Contains the result in case of successful execution.
-    /// NOTE: Should be the latest field since it contains unparsable by light client
-    /// ExecutionStatus::Failure
-    pub status: ExecutionStatus,
-    /// Execution metadata, versioned
-    pub metadata: ExecutionMetadata,
-}
-
-impl Default for ExecutionOutcome {
-    fn default() -> Self {
-        Self {
-            logs: Default::default(),
-            receipt_ids: Default::default(),
-            gas_burnt: Default::default(),
-            tokens_burnt: Default::default(),
-            executor_id: AccountId::from_str("test").unwrap(),
-            status: Default::default(),
-            metadata: Default::default(),
-        }
-    }
-}
-
-#[derive(Default, BorshSerialize, BorshDeserialize, PartialEq, Clone, Eq, Debug)]
-pub enum ExecutionMetadata {
-    // V1: Empty Metadata
-    #[default]
-    V1,
-
-    // V2: With ProfileData
-    V2(ProfileData),
-}
-
-impl fmt::Debug for ExecutionOutcome {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("ExecutionOutcome")
-            .field("logs", &self.logs)
-            .field("receipt_ids", &self.receipt_ids)
-            .field("burnt_gas", &self.gas_burnt)
-            .field("tokens_burnt", &self.tokens_burnt)
-            .field("status", &self.status)
-            .field("metadata", &self.metadata)
-            .finish()
-    }
-}
-
-/// Execution outcome with the identifier.
-/// For a signed transaction, the ID is the hash of the transaction.
-/// For a receipt, the ID is the receipt ID.
-#[derive(PartialEq, Clone, Default, Debug, BorshSerialize, BorshDeserialize, Eq)]
-pub struct ExecutionOutcomeWithId {
-    /// The transaction hash or the receipt ID.
-    pub id: CryptoHash,
-    /// Should be the latest field since contains unparsable by light client ExecutionStatus::Failure
-    pub outcome: ExecutionOutcome,
-}

near-primitives-light/src/types.rs

@@ -1,231 +0,0 @@
-use borsh::{BorshDeserialize, BorshSerialize};
-use common_api::crypto::prelude::*;
-use near_primitives_core::{
-    account::{AccessKey, Account},
-    hash::CryptoHash,
-    serialize::dec_format,
-    types::*,
-};
-use serde::{Deserialize, Serialize};
-
-/// Hash used by to store state root.
-pub type StateRoot = CryptoHash;
-
-/// Different types of finality.
-#[derive(Default, Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
-pub enum Finality {
-    #[serde(rename = "optimistic")]
-    None,
-    #[serde(rename = "near-final")]
-    DoomSlug,
-    #[default]
-    #[serde(rename = "final")]
-    Final,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct AccountWithPublicKey {
-    pub account_id: AccountId,
-    pub public_key: Ed25519PublicKey,
-}
-
-/// Account info for validators
-#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq)]
-pub struct AccountInfo {
-    pub account_id: AccountId,
-    pub public_key: Ed25519PublicKey,
-    #[serde(with = "dec_format")]
-    pub amount: Balance,
-}
-
-/// This type is used to mark function arguments.
-///
-/// NOTE: The main reason for this to exist (except the type-safety) is that the value is
-/// transparently serialized and deserialized as a base64-encoded string when serde is used
-/// (serde_json).
-#[derive(Debug, Clone, PartialEq, Eq, BorshSerialize, BorshDeserialize)]
-pub struct FunctionArgs(Vec<u8>);
-
-/// A structure used to indicate the kind of state changes due to transaction/receipt processing, etc.
-#[derive(Debug, Clone, BorshSerialize, BorshDeserialize)]
-pub enum StateChangeKind {
-    AccountTouched { account_id: AccountId },
-    AccessKeyTouched { account_id: AccountId },
-    DataTouched { account_id: AccountId },
-    ContractCodeTouched { account_id: AccountId },
-}
-
-pub type StateChangesKinds = Vec<StateChangeKind>;
-
-/// A structure used to index state changes due to transaction/receipt processing and other things.
-#[derive(Debug, Clone, BorshSerialize, BorshDeserialize)]
-pub enum StateChangeCause {
-    /// A type of update that does not get finalized. Used for verification and execution of
-    /// immutable smart contract methods. Attempt fo finalize a `TrieUpdate` containing such
-    /// change will lead to panic.
-    NotWritableToDisk,
-    /// A type of update that is used to mark the initial storage update, e.g. during genesis
-    /// or in tests setup.
-    InitialState,
-    /// Processing of a transaction.
-    TransactionProcessing { tx_hash: CryptoHash },
-    /// Before the receipt is going to be processed, inputs get drained from the state, which
-    /// causes state modification.
-    ActionReceiptProcessingStarted { receipt_hash: CryptoHash },
-    /// Computation of gas reward.
-    ActionReceiptGasReward { receipt_hash: CryptoHash },
-    /// Processing of a receipt.
-    ReceiptProcessing { receipt_hash: CryptoHash },
-    /// The given receipt was postponed. This is either a data receipt or an action receipt.
-    /// A `DataReceipt` can be postponed if the corresponding `ActionReceipt` is not received yet,
-    /// or other data dependencies are not satisfied.
-    /// An `ActionReceipt` can be postponed if not all data dependencies are received.
-    PostponedReceipt { receipt_hash: CryptoHash },
-    /// Updated delayed receipts queue in the state.
-    /// We either processed previously delayed receipts or added more receipts to the delayed queue.
-    UpdatedDelayedReceipts,
-    /// State change that happens when we update validator accounts. Not associated with with any
-    /// specific transaction or receipt.
-    ValidatorAccountsUpdate,
-    /// State change that is happens due to migration that happens in first block of an epoch
-    /// after protocol upgrade
-    Migration,
-    /// State changes for building states for re-sharding
-    Resharding,
-}
-
-/// This represents the committed changes in the Trie with a change cause.
-#[derive(Debug, Clone, BorshSerialize, BorshDeserialize)]
-pub struct RawStateChange {
-    pub cause: StateChangeCause,
-    pub data: Option<Vec<u8>>,
-}
-
-#[derive(Debug)]
-pub enum StateChangesRequest {
-    AccountChanges { account_ids: Vec<AccountId> },
-    SingleAccessKeyChanges { keys: Vec<AccountWithPublicKey> },
-    AllAccessKeyChanges { account_ids: Vec<AccountId> },
-    ContractCodeChanges { account_ids: Vec<AccountId> },
-}
-
-#[derive(Debug)]
-pub enum StateChangeValue {
-    AccountUpdate {
-        account_id: AccountId,
-        account: Account,
-    },
-    AccountDeletion {
-        account_id: AccountId,
-    },
-    AccessKeyUpdate {
-        account_id: AccountId,
-        public_key: Ed25519PublicKey,
-        access_key: AccessKey,
-    },
-    AccessKeyDeletion {
-        account_id: AccountId,
-        public_key: Ed25519PublicKey,
-    },
-    ContractCodeUpdate {
-        account_id: AccountId,
-        code: Vec<u8>,
-    },
-    ContractCodeDeletion {
-        account_id: AccountId,
-    },
-}
-
-impl StateChangeValue {
-    pub fn affected_account_id(&self) -> &AccountId {
-        match &self {
-            StateChangeValue::AccountUpdate { account_id, .. }
-            | StateChangeValue::AccountDeletion { account_id }
-            | StateChangeValue::AccessKeyUpdate { account_id, .. }
-            | StateChangeValue::AccessKeyDeletion { account_id, .. }
-            | StateChangeValue::ContractCodeUpdate { account_id, .. }
-            | StateChangeValue::ContractCodeDeletion { account_id } => account_id,
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct StateChangeWithCause {
-    pub cause: StateChangeCause,
-    pub value: StateChangeValue,
-}
-
-pub type StateChanges = Vec<StateChangeWithCause>;
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(untagged)]
-pub enum BlockId {
-    Height(BlockHeight),
-    Hash(CryptoHash),
-}
-
-pub type MaybeBlockId = Option<BlockId>;
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum SyncCheckpoint {
-    Genesis,
-    EarliestAvailable,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum BlockReference {
-    BlockId(BlockId),
-    Finality(Finality),
-    SyncCheckpoint(SyncCheckpoint),
-}
-
-impl BlockReference {
-    pub fn latest() -> Self {
-        Self::Finality(Finality::None)
-    }
-}
-
-impl From<BlockId> for BlockReference {
-    fn from(block_id: BlockId) -> Self {
-        Self::BlockId(block_id)
-    }
-}
-
-impl From<Finality> for BlockReference {
-    fn from(finality: Finality) -> Self {
-        Self::Finality(finality)
-    }
-}
-
-#[derive(Default, BorshSerialize, BorshDeserialize, Clone, Debug, PartialEq, Eq)]
-pub struct ValidatorStats {
-    pub produced: NumBlocks,
-    pub expected: NumBlocks,
-}
-
-#[derive(Debug, BorshSerialize, BorshDeserialize, PartialEq, Eq)]
-pub struct BlockChunkValidatorStats {
-    pub block_stats: ValidatorStats,
-    pub chunk_stats: ValidatorStats,
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug)]
-#[serde(tag = "type", rename_all = "snake_case")]
-pub enum TransactionOrReceiptId {
-    Transaction {
-        transaction_hash: CryptoHash,
-        sender_id: AccountId,
-    },
-    Receipt {
-        receipt_id: CryptoHash,
-        receiver_id: AccountId,
-    },
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, BorshDeserialize, BorshSerialize)]
-pub enum CompiledContract {
-    CompileModuleError,
-    Code(Vec<u8>),
-}

near-rpc/Cargo.toml

@@ -1,33 +0,0 @@
-[package]
-name = "near-rpc"
-version = "0.1.0"
-edition = "2021"
-authors = ["silvestr@relayz.io", "kyrylo@relayz.io"]
-description = """
-The basic implementation of NEAR RPC.
-"""
-
-[dependencies]
-base64 = { version = "0.20" }
-bs58 = "0.4"
-borsh = "0.9"
-common-api = { path = "../common-api" }
-itertools = "0.10"
-near-primitives-light = { path = "../near-primitives-light" }
-near-primitives-core = "0.15"
-near-units = "0.2"
-reqwest = { version = "0.11", features = ["json"] }
-serde = { version = "1", default-features = false, features = ["derive"] }
-serde_json = { version = "1", default-features = false }
-thiserror = "1"
-url = "2"
-
-[dev-dependencies]
-reqwest = { version = "0.11", features = ["json"] }
-rand = "0.8.5"
-rand_chacha = "0.3"
-tempfile = "3"
-tokio = { version = "1.2.1", features = ["full"] }
-workspaces = { git = "https://github.com/near/workspaces-rs.git", features = [
-    "unstable",
-] }

near-rpc/src/client.rs

@@ -1,496 +0,0 @@
-use near_primitives_light::{
-    transaction::{
-        Action, AddKeyAction, CreateAccountAction, DeleteAccountAction, DeployContractAction,
-        FunctionCallAction, TransferAction,
-    },
-    types::Finality,
-    views::{
-        BlockView, ExecutionOutcomeWithIdView, FinalExecutionOutcomeView, FinalExecutionStatus,
-    },
-};
-
-use near_primitives_core::{
-    account::{id::AccountId, AccessKey, AccessKeyPermission},
-    hash::CryptoHash,
-    types::{Balance, Gas, Nonce},
-};
-
-use crate::{
-    rpc::{client::RpcClient, Error as RpcError, NearError},
-    utils::{
-        extract_logs, serialize_arguments, serialize_transaction, CallResult, TransactionInfo,
-        ViewAccessKey, ViewResult,
-    },
-    Error, Result,
-};
-
-use common_api::crypto::prelude::*;
-use serde::de::DeserializeOwned;
-use serde_json::{json, Value};
-use url::Url;
-
-use std::{
-    ops::Deref,
-    sync::{
-        atomic::{AtomicU64, Ordering},
-        Arc,
-    },
-};
-
-type AtomicNonce = Arc<AtomicU64>;
-/// Used for signing a transactions
-pub struct Signer {
-    keypair: Keypair,
-    account_id: AccountId,
-    nonce: AtomicNonce,
-}
-
-impl Signer {
-    #[allow(clippy::result_large_err)]
-    pub fn from_secret_str(secret_key: &str, account_id: AccountId, nonce: Nonce) -> Result<Self> {
-        Ok(Self {
-            keypair: Keypair::from_expanded_secret(secret_key).map_err(Error::CreateSigner)?,
-            account_id,
-            nonce: AtomicNonce::new(AtomicU64::new(nonce)),
-        })
-    }
-
-    pub fn from_secret(secret_key: Ed25519SecretKey, account_id: AccountId, nonce: Nonce) -> Self {
-        Self {
-            keypair: Keypair::new(secret_key),
-            account_id,
-            nonce: AtomicNonce::new(AtomicU64::new(nonce)),
-        }
-    }
-
-    /// Sign a transaction
-    ///
-    /// Arguments
-    ///
-    /// - data - Serialized transaction with a [Borsh](https://borsh.io/)
-    pub fn sign(&self, data: &[u8]) -> Ed25519Signature {
-        self.keypair.sign(data)
-    }
-
-    pub fn public_key(&self) -> &Ed25519PublicKey {
-        self.keypair.public_key()
-    }
-
-    pub fn secret_key(&self) -> &Ed25519SecretKey {
-        self.keypair.secret_key()
-    }
-
-    pub fn account(&self) -> &AccountId {
-        &self.account_id
-    }
-
-    pub fn nonce(&self) -> Nonce {
-        self.nonce.load(Ordering::Acquire)
-    }
-
-    pub fn update_nonce(&self, nonce: Nonce) {
-        self.nonce.store(nonce, Ordering::Release);
-    }
-
-    pub fn increment_nonce(&self, value: u64) {
-        self.nonce.fetch_add(value, Ordering::AcqRel);
-    }
-}
-
-pub struct NearClient {
-    pub(crate) rpc_client: RpcClient,
-}
-
-impl NearClient {
-    #[allow(clippy::result_large_err)]
-    pub fn new(url: Url) -> Result<Self> {
-        Ok(Self {
-            rpc_client: RpcClient::new(url).map_err(Error::CreateClient)?,
-        })
-    }
-
-    /// Queries network and returns block for given height or hash
-    pub async fn block(&self, finality: Finality) -> Result<CryptoHash> {
-        self.rpc_client
-            .request("block", Some(json!({ "finality": finality })))
-            .await
-            .map_err(Error::BlockCall)
-            .and_then(|block_res| {
-                serde_json::from_value::<BlockView>(block_res).map_err(Error::DeserializeBlock)
-            })
-            .map(|block_view| block_view.header.hash)
-    }
-
-    /// Allows you to call a contract method as a view function.
-    ///
-    /// Arguments
-    ///
-    /// - contract_id - The [`AccountId`] where smart contract is located
-    /// - finality - [`Finality`]
-    /// - method - Function that is declared in a smart contract
-    /// - args - Function arguments, could be empty
-    pub async fn view<'a, T: DeserializeOwned>(
-        &'a self,
-        contract_id: &'a AccountId,
-        finality: Finality,
-        method: &'static str,
-        args: Option<Value>,
-    ) -> Result<ViewOutput<T>> {
-        self.rpc_client
-            .request(
-                "query",
-                Some(json!({
-                    "request_type": "call_function",
-                    "finality": finality,
-                    "account_id": contract_id,
-                    "method_name": method,
-                    "args_base64": base64::encode(serialize_arguments(args)?)
-                })),
-            )
-            .await
-            .map_err(Error::ViewCall)
-            .and_then(|it| {
-                serde_json::from_value::<ViewResult>(it).map_err(Error::DeserializeViewCall)
-            })
-            .and_then(|view_res| match view_res.result {
-                CallResult::Ok(data) => Ok(ViewOutput {
-                    logs: view_res.logs,
-                    data: serde_json::from_slice(&data).map_err(Error::DeserializeResponseView)?,
-                }),
-                CallResult::Err(cause) => Err(Error::ViewCall(RpcError::NearProtocol(
-                    NearError::new_simple(cause),
-                ))),
-            })
-    }
-
-    /// Returns information about a single access key for given account
-    ///
-    /// Arguments
-    ///
-    /// - account_id - The user [`AccountId`] in a Near network
-    /// - public_key - The user [`Ed25519PublicKey`] in a Near network
-    pub async fn view_access_key<'a>(
-        &'a self,
-        account_id: &'a AccountId,
-        public_key: &'a Ed25519PublicKey,
-        finality: Finality,
-    ) -> Result<ViewAccessKey> {
-        self.rpc_client
-            .request(
-                "query",
-                Some(json!({
-                    "request_type": "view_access_key",
-                    "finality": finality,
-                    "account_id": account_id,
-                    "public_key": public_key,
-                })),
-            )
-            .await
-            .map_err(Error::ViewAccessKeyCall)
-            .and_then(|it| {
-                serde_json::from_value::<ViewAccessKey>(it)
-                    .map_err(Error::DeserializeAccessKeyViewCall)
-            })
-    }
-
-    /// Queries status of a transaction by hash,
-    /// returning the final transaction result and details of all receipts.
-    ///
-    /// Arguments
-    ///
-    /// - transaction_id - Transaction [`CryptoHash`]
-    /// - signer - [`Signer`] that contain information regarding user [`Keypair`]
-    ///
-    /// Return
-    ///
-    /// If a transaction still processing will be returned an error [`Error::ViewTransaction`],
-    /// in this case can try to execute [`view_transaction`] one more time, or a several times.
-    /// If an error differs from [`Error::ViewTransaction`] that something goes totally wrong and
-    /// you should stop to try executing [`view_transaction`] with the same arguments/signer
-    pub async fn view_transaction<'a>(
-        &'a self,
-        transaction_id: &'a CryptoHash,
-        signer: &'a Signer,
-    ) -> Result<Output> {
-        let params = Value::Array(vec![
-            serde_json::to_value(transaction_id)
-                .map_err(|err| Error::SerializeTxViewArg("transaction_id", err))?,
-            serde_json::to_value(signer.account())
-                .map_err(|err| Error::SerializeTxViewArg("signer_acc_id", err))?,
-        ]);
-
-        let execution_outcome = self
-            .rpc_client
-            .request("EXPERIMENTAL_tx_status", Some(params))
-            .await
-            .map_err(Error::ViewTransaction)
-            .and_then(|execution_outcome| {
-                serde_json::from_value::<FinalExecutionOutcomeView>(execution_outcome)
-                    .map_err(Error::DeserializeExecutionOutcome)
-            })?;
-
-        proceed_outcome(signer, execution_outcome)
-    }
-
-    /// Execute a transaction with a function call to the smart contract
-    ///
-    /// Arguments
-    ///
-    /// - signer - Transaction [`Signer`]
-    /// - contract_id - The [`AccountId`] where smart contract is located
-    /// - method - Function that is declared in a smart contract (Arguments fir function call provided later in a [`FunctionCallBuilder`])
-    pub fn function_call<'a>(
-        &'a self,
-        signer: &'a Signer,
-        contract_id: &'a AccountId,
-        method: &'static str,
-    ) -> FunctionCallBuilder {
-        let transaction_info = TransactionInfo::new(self, signer, contract_id);
-        FunctionCallBuilder::new(transaction_info, method)
-    }
-
-    pub fn deploy_contract<'a>(
-        &'a self,
-        signer: &'a Signer,
-        contract_id: &'a AccountId,
-        wasm: Vec<u8>,
-    ) -> FunctionCall {
-        FunctionCall {
-            info: TransactionInfo::new(self, signer, contract_id),
-            actions: vec![Action::from(DeployContractAction { code: wasm })],
-        }
-    }
-
-    pub fn create_account<'a>(
-        &'a self,
-        signer: &'a Signer,
-        new_account_id: &'a AccountId,
-        new_account_pk: Ed25519PublicKey,
-        amount: Balance,
-    ) -> FunctionCall {
-        let info = TransactionInfo::new(self, signer, new_account_id);
-        let actions = vec![
-            CreateAccountAction {}.into(),
-            AddKeyAction {
-                public_key: new_account_pk,
-                access_key: AccessKey {
-                    nonce: 0,
-                    permission: AccessKeyPermission::FullAccess,
-                },
-            }
-            .into(),
-            TransferAction { deposit: amount }.into(),
-        ];
-
-        FunctionCall { info, actions }
-    }
-
-    pub fn delete_account<'a>(
-        &'a self,
-        signer: &'a Signer,
-        account_id: &'a AccountId,
-        beneficiary_acc_id: &'a AccountId,
-    ) -> FunctionCall {
-        let info = TransactionInfo::new(self, signer, account_id);
-        let actions = vec![DeleteAccountAction {
-            beneficiary_id: beneficiary_acc_id.clone(),
-        }
-        .into()];
-
-        FunctionCall { info, actions }
-    }
-}
-
-#[derive(Debug)]
-pub struct ViewOutput<T: DeserializeOwned> {
-    logs: Vec<String>,
-    data: T,
-}
-
-impl<T: DeserializeOwned> ViewOutput<T> {
-    /// Logs from view call
-    pub fn logs(&self) -> Vec<String> {
-        self.logs.clone()
-    }
-
-    /// Return a view call result
-    pub fn data(self) -> T {
-        self.data
-    }
-}
-
-impl<T: DeserializeOwned> Deref for ViewOutput<T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        &self.data
-    }
-}
-
-/// Function call output.
-#[derive(Debug)]
-pub struct Output {
-    transaction: ExecutionOutcomeWithIdView,
-    logs: Vec<String>,
-    data: Vec<u8>,
-}
-
-impl Output {
-    #[allow(clippy::result_large_err)]
-    /// If function don't return anything it will return [`Error::DeserializeTransactionOutput`]
-    /// Or if you miss matching a return type
-    pub fn output<T: DeserializeOwned>(&self) -> Result<T> {
-        serde_json::from_slice::<T>(&self.data).map_err(Error::DeserializeTransactionOutput)
-    }
-
-    #[allow(clippy::misnamed_getters)]
-    /// Returns a transaction id
-    pub fn id(&self) -> CryptoHash {
-        self.transaction.block_hash
-    }
-
-    /// Amount of gas that was burnt during transaction execution
-    pub fn gas_burnt(&self) -> Gas {
-        self.transaction.outcome.gas_burnt
-    }
-
-    /// Logs that smart contract produced
-    pub fn logs(&self) -> Vec<String> {
-        self.logs.clone()
-    }
-}
-
-pub struct FunctionCallBuilder<'a> {
-    info: TransactionInfo<'a>,
-    deposit: Balance,
-    gas: Gas,
-    args: Option<Value>,
-    method_name: &'a str,
-}
-
-impl<'a> FunctionCallBuilder<'a> {
-    fn new(info: TransactionInfo<'a>, method_name: &'a str) -> Self {
-        Self {
-            info,
-            method_name,
-            gas: Default::default(),
-            args: Default::default(),
-            deposit: Default::default(),
-        }
-    }
-
-    pub fn deposit(mut self, deposit: Balance) -> Self {
-        self.deposit = deposit;
-        self
-    }
-
-    /// Amount of gas that will be hold for function execution
-    pub fn gas(mut self, gas: Gas) -> Self {
-        self.gas = gas;
-        self
-    }
-
-    pub fn args(mut self, args: Value) -> Self {
-        self.args = Some(args);
-        self
-    }
-
-    #[allow(clippy::result_large_err)]
-    pub fn build(self) -> Result<FunctionCall<'a>> {
-        let action = Action::from(FunctionCallAction {
-            method_name: self.method_name.to_string(),
-            args: serialize_arguments(self.args)?,
-            gas: self.gas,
-            deposit: self.deposit,
-        });
-
-        Ok(FunctionCall {
-            info: self.info,
-            actions: vec![action],
-        })
-    }
-
-    /// Take a look at [`FunctionCall`] `commit`
-    pub async fn commit(self, block_finality: Finality) -> Result<Output> {
-        let call = self.build()?;
-        call.commit(block_finality).await
-    }
-
-    /// Take a look at [`FunctionCall`] `commit_async`
-    pub async fn commit_async(self, block_finality: Finality) -> Result<CryptoHash> {
-        let call = self.build()?;
-        call.commit_async(block_finality).await
-    }
-}
-
-pub struct FunctionCall<'a> {
-    info: TransactionInfo<'a>,
-    actions: Vec<Action>,
-}
-
-impl<'a> FunctionCall<'a> {
-    /// Sends a transaction and waits until transaction is fully complete. (Has a 10 second timeout)
-    /// Also, possible that an output data will be empty if the transaction is still executing
-    pub async fn commit(self, block_finality: Finality) -> Result<Output> {
-        let transaction_bytes =
-            serialize_transaction(&self.info, self.actions, block_finality).await?;
-
-        let execution_outcome = self
-            .info
-            .rpc()
-            .request(
-                "broadcast_tx_commit",
-                Some(json!(vec![base64::encode(transaction_bytes)])),
-            )
-            .await
-            .map_err(Error::CommitTransaction)
-            .and_then(|execution_outcome| {
-                serde_json::from_value::<FinalExecutionOutcomeView>(execution_outcome)
-                    .map_err(Error::DeserializeExecutionOutcome)
-            })?;
-
-        proceed_outcome(self.info.signer(), execution_outcome)
-    }
-
-    /// Sends a transaction and immediately returns transaction hash.
-    pub async fn commit_async(self, block_finality: Finality) -> Result<CryptoHash> {
-        let transaction_bytes =
-            serialize_transaction(&self.info, self.actions, block_finality).await?;
-        self.info
-            .rpc()
-            .request(
-                "broadcast_tx_async",
-                Some(json!(vec![base64::encode(transaction_bytes)])),
-            )
-            .await
-            .map_err(Error::CommitAsyncTransaction)
-            .and_then(|id| {
-                serde_json::from_value::<CryptoHash>(id).map_err(Error::DeserializeTransactionId)
-            })
-    }
-}
-
-#[allow(clippy::result_large_err)]
-pub(crate) fn proceed_outcome(
-    signer: &Signer,
-    execution_outcome: FinalExecutionOutcomeView,
-) -> Result<Output> {
-    signer.update_nonce(execution_outcome.transaction.nonce);
-    let transaction = execution_outcome.transaction_outcome;
-    let logs = extract_logs(execution_outcome.receipts_outcome);
-
-    match execution_outcome.status {
-        FinalExecutionStatus::Failure(err) => Err(Error::TxExecution(err)),
-        FinalExecutionStatus::SuccessValue(data) => Ok(Output {
-            transaction,
-            logs,
-            data,
-        }),
-        FinalExecutionStatus::NotStarted => Err(Error::TxNotStarted),
-        FinalExecutionStatus::Started => Ok(Output {
-            transaction,
-            logs,
-            data: vec![],
-        }),
-    }
-}

near-rpc/src/lib.rs

@@ -1,51 +0,0 @@
-mod rpc;
-pub mod utils;
-
-pub mod client;
-pub use near_primitives_light::{self, types::Finality};
-
-type Result<T> = std::result::Result<T, Error>;
-
-#[derive(Debug, thiserror::Error)]
-pub enum Error {
-    #[error("Failed to create a signer, cause [\"{0}\"]")]
-    CreateSigner(common_api::crypto::Error),
-    #[error("Transaction not started")]
-    TxNotStarted,
-    #[error("Transaction failed during execution, cause [\"{0:?}\"]")]
-    TxExecution(near_primitives_light::errors::TxExecutionError),
-    #[error("Transaction serialization error: [\"{0}\"]")]
-    TxSerialization(std::io::Error),
-    #[error("Couldn't serialize an argument [\"{0}\"] to view a transaction, cause: [\"{1}\"]")]
-    SerializeTxViewArg(&'static str, serde_json::Error),
-    #[error("Couldn't serialize arguments for view or function call, cause: [\"{0}\"]")]
-    ArgsSerialization(serde_json::Error),
-    #[error("Client creation failed, cause: [\"{0}\"]")]
-    CreateClient(rpc::Error),
-    #[error("Can't view a transaction, cause: [\"{0}\"]")]
-    ViewTransaction(rpc::Error),
-    #[error("Transaction commit failed with an error, cause: [\"{0}\"]")]
-    CommitTransaction(rpc::Error),
-    #[error("Transaction async commit failed with an error, cause: [\"{0}\"]")]
-    CommitAsyncTransaction(rpc::Error),
-    #[error("Block call failed with an error: \"{0}\"")]
-    BlockCall(rpc::Error),
-    #[error("Access key call failed with an error: \"{0}\"")]
-    ViewAccessKeyCall(rpc::Error),
-    #[error("View call failed with an error: \"{0}\"")]
-    ViewCall(rpc::Error),
-    #[error("Couldn't deserialize a transaction function output, cause: [\"{0}\"]")]
-    DeserializeTransactionOutput(serde_json::Error),
-    #[error("Couldn't deserialize a transaction outcome, cause: [\"{0}\"]")]
-    DeserializeExecutionOutcome(serde_json::Error),
-    #[error("Couldn't deserialize a transaction id, cause: [\"{0}\"]")]
-    DeserializeTransactionId(serde_json::Error),
-    #[error("Couldn't deserialize a view call result, cause [\"{0}\"]")]
-    DeserializeViewCall(serde_json::Error),
-    #[error("Couldn't deserialize a view response, cause [\"{0}\"]")]
-    DeserializeResponseView(serde_json::Error),
-    #[error("Couldn't deserialize a block, cause: [\"{0}\"]")]
-    DeserializeBlock(serde_json::Error),
-    #[error("Can't deserialize an access key response, cause: [\"{0}\"]")]
-    DeserializeAccessKeyViewCall(serde_json::Error),
-}

near-rpc/src/rpc/client.rs

@@ -1,150 +0,0 @@
-use reqwest::{
-    header::{HeaderMap, HeaderValue, CONTENT_TYPE},
-    Client, ClientBuilder, Response as Resp,
-};
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-
-use super::{Error, NearError};
-use std::borrow::Cow;
-use url::Url;
-
-type Result<T> = std::result::Result<T, Error>;
-
-pub(crate) struct RpcClient {
-    client: Client,
-    url: Url,
-}
-
-impl RpcClient {
-    /// Creates a [`reqwest`] client with headers:
-    /// [`CONTENT_TYPE`]: "application/json"
-    ///
-    /// Arguments
-    ///
-    /// - url - It's an RPC endpoint [`Url`]
-    pub(crate) fn new(url: Url) -> Result<Self> {
-        let mut headers = HeaderMap::new();
-        headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
-        let client = ClientBuilder::new()
-            .default_headers(headers)
-            .build()
-            .map_err(Error::RpcClientCreate)?;
-
-        Ok(Self { client, url })
-    }
-
-    /// RPC call to the NEAR network
-    ///
-    /// Arguments
-    ///
-    /// - method - RPC method
-    /// - params - method arguments, could be empty
-    ///
-    /// Response example:
-    /// ```json
-    /// {
-    ///   "id": "dontcare",
-    ///   "jsonrpc": "2.0",
-    ///   "result": "...",
-    /// }
-    ///
-    /// ```
-    pub(crate) async fn request(&self, method: &str, params: Option<Value>) -> Result<Value> {
-        let resp = self
-            .client
-            .post(self.url.clone())
-            .json(
-                &serde_json::to_value(&Request::new(method, params))
-                    .map_err(Error::SerializeRpcRequest)?,
-            )
-            .send()
-            .await
-            .and_then(Resp::error_for_status)
-            .map_err(Error::RpcRequest)?;
-
-        match resp
-            .json::<Response>()
-            .await
-            .map_err(Error::DeserializeRpcResponse)?
-        {
-            Response {
-                result: RpcResult::Ok(data),
-                ..
-            } => Ok(data),
-            Response {
-                result: RpcResult::Err(err),
-                ..
-            } => Err(err.into()),
-        }
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct Request<'a> {
-    /// JSON-RPC version.
-    pub jsonrpc: &'static str,
-    /// Request ID
-    pub id: &'static str,
-    /// Name of the method to be invoked.
-    #[serde(borrow)]
-    pub method: Cow<'a, str>,
-    /// Parameter values of the request.
-    pub params: Option<Value>,
-}
-
-impl<'a> Request<'a> {
-    fn new(method: &'a str, params: Option<Value>) -> Self {
-        Self {
-            jsonrpc: "2.0",
-            id: "dontcare",
-            method: Cow::from(method),
-            params,
-        }
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct Response {
-    /// JSON-RPC version.
-    pub jsonrpc: String,
-    /// Result.
-    #[serde(flatten)]
-    pub result: RpcResult,
-    /// Request ID
-    pub id: String,
-}
-
-/// Near result format
-#[derive(Debug, Serialize, Deserialize)]
-enum RpcResult {
-    #[serde(rename = "result")]
-    Ok(Value),
-    #[serde(rename = "error")]
-    Err(NearError),
-}
-
-#[cfg(test)]
-mod tests {
-
-    use super::*;
-
-    #[test]
-    fn response_sample() {
-        let resp = Response {
-            jsonrpc: "2.0".to_owned(),
-            result: RpcResult::Ok(Value::String("some value".to_owned())),
-            id: "dontcare".to_owned(),
-        };
-
-        assert_eq!(
-            serde_json::to_value(&resp).unwrap(),
-            serde_json::to_value(&serde_json::json!({
-                "id": "dontcare",
-                "jsonrpc": "2.0",
-                "result": "some value",
-            }))
-            .unwrap()
-        );
-    }
-}

near-rpc/src/rpc/mod.rs

@@ -1,78 +0,0 @@
-pub(crate) mod client;
-
-use std::fmt::Display;
-
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-
-#[derive(Debug, thiserror::Error)]
-pub enum Error {
-    #[error("Couldn't create a RpcClient: [\"{0}\"]")]
-    RpcClientCreate(reqwest::Error),
-    #[error("Rpc request failed with: [\"{0}\"]")]
-    RpcRequest(reqwest::Error),
-    #[error("Failed to serialize an RPC request: [\"{0}\"]")]
-    SerializeRpcRequest(serde_json::Error),
-    #[error("Failed to deserialize an RPC response: [\"{0}\"]")]
-    DeserializeRpcResponse(reqwest::Error),
-    #[error("Near protocol error: [\"{0}\"]")]
-    NearProtocol(NearError),
-}
-
-impl From<NearError> for Error {
-    fn from(err: NearError) -> Self {
-        Self::NearProtocol(err)
-    }
-}
-
-#[derive(Debug, Default, Serialize, Deserialize)]
-pub struct NearError {
-    name: String,
-    cause: Cause,
-    code: i32,
-    data: Value,
-    message: String,
-}
-
-impl NearError {
-    pub fn new_simple(cause: Value) -> Self {
-        Self {
-            data: cause,
-            ..Default::default()
-        }
-    }
-
-    pub fn new_with_msg(cause: Value, message: String) -> Self {
-        Self {
-            data: cause,
-            message,
-            ..Default::default()
-        }
-    }
-}
-
-impl Display for NearError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "Name: {}, Message: {}, Cause: {}, Descr: {}",
-            self.name, self.message, self.cause, self.data
-        )
-    }
-}
-
-#[derive(Debug, Default, Serialize, Deserialize)]
-pub struct Cause {
-    info: Option<Value>,
-    name: String,
-}
-
-impl Display for Cause {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if let Some(info) = &self.info {
-            return write!(f, "{info}");
-        }
-
-        Ok(())
-    }
-}

near-rpc/src/utils.rs

@@ -1,230 +0,0 @@
-use crate::{
-    client::{NearClient, Signer},
-    rpc::client::RpcClient,
-    Error, Result,
-};
-
-use near_primitives_core::{
-    account::id::AccountId,
-    hash::CryptoHash,
-    types::{BlockHeight, Nonce},
-};
-use near_primitives_light::{
-    transaction::{Action, SignedTransaction, Transaction},
-    types::Finality,
-    views::{AccessKeyPermissionView, AccessKeyView, ExecutionOutcomeWithIdView},
-};
-use serde::{
-    de::{self, Visitor},
-    Deserialize, Serialize,
-};
-use serde_json::Value;
-use std::fmt;
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum CallResult {
-    #[serde(rename = "result")]
-    Ok(Vec<u8>),
-    #[serde(rename = "error")]
-    Err(Value),
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ViewResult {
-    #[serde(flatten)]
-    pub result: CallResult,
-    pub logs: Vec<String>,
-}
-
-#[derive(Debug, Clone)]
-pub enum ViewAccessKeyResult {
-    Ok(AccessKeyView),
-    Err { error: String, logs: Vec<String> },
-}
-
-#[derive(Debug, Clone)]
-pub struct ViewAccessKey {
-    pub block_hash: CryptoHash,
-    pub block_height: BlockHeight,
-    pub result: ViewAccessKeyResult,
-}
-
-impl From<ViewAccessKey> for std::result::Result<Nonce, String> {
-    fn from(view: ViewAccessKey) -> Self {
-        match view.result {
-            ViewAccessKeyResult::Ok(AccessKeyView { nonce, .. }) => Ok(nonce),
-            ViewAccessKeyResult::Err { error, .. } => Err(error),
-        }
-    }
-}
-
-pub(crate) struct TransactionInfo<'a> {
-    client: &'a NearClient,
-    signer: &'a Signer,
-    contract_id: &'a AccountId,
-}
-
-impl<'a> TransactionInfo<'a> {
-    pub(crate) fn new(
-        client: &'a NearClient,
-        signer: &'a Signer,
-        contract_id: &'a AccountId,
-    ) -> Self {
-        Self {
-            client,
-            signer,
-            contract_id,
-        }
-    }
-
-    pub(crate) fn rpc(&self) -> &RpcClient {
-        &self.client.rpc_client
-    }
-
-    pub(crate) fn signer(&self) -> &Signer {
-        self.signer
-    }
-}
-
-pub(crate) fn extract_logs(
-    logs: impl IntoIterator<Item = ExecutionOutcomeWithIdView>,
-) -> Vec<String> {
-    logs.into_iter()
-        .find_map(|it| {
-            if it.outcome.logs.is_empty() {
-                None
-            } else {
-                Some(it.outcome.logs)
-            }
-        })
-        .unwrap_or_default()
-}
-
-/// Serialize and sign a transaction
-/// During call it requests the most recent block [`CryptoHash`]
-pub(crate) async fn serialize_transaction<'a>(
-    info: &'a TransactionInfo<'_>,
-    actions: Vec<Action>,
-    block_finality: Finality,
-) -> Result<Vec<u8>> {
-    let block_hash = info.client.block(block_finality).await?;
-
-    let transaction = Transaction {
-        signer_id: info.signer.account().clone(),
-        public_key: *info.signer.public_key(),
-        nonce: info.signer.nonce() + 1,
-        receiver_id: info.contract_id.clone(),
-        block_hash,
-        actions,
-    };
-
-    let signed_transaction = sign_transaction(info.signer, transaction);
-    borsh::to_vec(&signed_transaction).map_err(Error::TxSerialization)
-}
-
-#[allow(clippy::result_large_err)]
-pub(crate) fn serialize_arguments(args: Option<Value>) -> Result<Vec<u8>> {
-    Ok(args
-        .as_ref()
-        .map(serde_json::to_vec)
-        .transpose()
-        .map_err(Error::ArgsSerialization)?
-        .unwrap_or_default())
-}
-
-pub(crate) fn sign_transaction(signer: &Signer, transaction: Transaction) -> SignedTransaction {
-    let (hash, ..) = transaction.get_hash_and_size();
-    let signature = signer.sign(hash.0.as_ref());
-    SignedTransaction::new(signature, transaction)
-}
-
-impl<'de> Deserialize<'de> for ViewAccessKey {
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        struct Visit;
-
-        impl<'de> Visitor<'de> for Visit {
-            type Value = ViewAccessKey;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                write!(formatter, "Expecting an key-value map")
-            }
-
-            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
-            where
-                A: serde::de::MapAccess<'de>,
-            {
-                let block_hash = map
-                    .next_entry::<String, CryptoHash>()?
-                    .ok_or_else(|| de::Error::missing_field("block_hash"))
-                    .and_then(|(key, block_hash)| {
-                        if key != "block_hash" {
-                            Err(serde::de::Error::unknown_field(&key, &["block_hash"]))
-                        } else {
-                            Ok(block_hash)
-                        }
-                    })?;
-
-                let block_height = map
-                    .next_entry::<String, BlockHeight>()?
-                    .ok_or_else(|| de::Error::missing_field("block_height"))
-                    .and_then(|(key, block_hash)| {
-                        if key != "block_height" {
-                            Err(serde::de::Error::unknown_field(&key, &["block_height"]))
-                        } else {
-                            Ok(block_hash)
-                        }
-                    })?;
-
-                let next_key = map.next_key::<String>()?;
-
-                match next_key.as_deref() {
-                    Some("nonce") => {
-                        let nonce = map.next_value::<Nonce>()?;
-                        let permission = map
-                            .next_entry::<String, AccessKeyPermissionView>()?
-                            .ok_or_else(|| de::Error::missing_field("permission"))
-                            .and_then(|(key, permission)| {
-                                if key != "permission" {
-                                    Err(serde::de::Error::unknown_field(&key, &["permission"]))
-                                } else {
-                                    Ok(permission)
-                                }
-                            })?;
-
-                        Ok(ViewAccessKey {
-                            block_hash,
-                            block_height,
-                            result: ViewAccessKeyResult::Ok(AccessKeyView { nonce, permission }),
-                        })
-                    }
-                    Some("error") => {
-                        let error = map.next_value::<String>()?;
-                        let logs = map
-                            .next_entry::<String, Vec<String>>()?
-                            .ok_or_else(|| serde::de::Error::missing_field("logs"))
-                            .and_then(|(key, logs)| {
-                                if key != "logs" {
-                                    Err(serde::de::Error::unknown_field(&key, &["logs"]))
-                                } else {
-                                    Ok(logs)
-                                }
-                            })?;
-
-                        Ok(ViewAccessKey {
-                            block_hash,
-                            block_height,
-                            result: ViewAccessKeyResult::Err { error, logs },
-                        })
-                    }
-                    Some(field) => Err(serde::de::Error::unknown_field(field, &["nonce", "error"])),
-                    None => Err(serde::de::Error::missing_field("nonce or error")),
-                }
-            }
-        }
-
-        deserializer.deserialize_map(Visit)
-    }
-}

near-rpc/tests/rpc.rs

@@ -1,458 +0,0 @@
-use near_rpc::{
-    client::{NearClient, Signer},
-    utils::{ViewAccessKey, ViewAccessKeyResult},
-};
-
-use std::{
-    fs::{create_dir_all, write},
-    str::FromStr,
-};
-
-use common_api::crypto::prelude::*;
-use near_primitives_light::{types::Finality, views::AccessKeyView};
-use rand::{RngCore, SeedableRng};
-use rand_chacha::ChaChaRng;
-use reqwest::Url;
-use serde_json::json;
-use workspaces::{network::Sandbox, types::SecretKey, AccountId, Worker};
-
-// auxiliary structs and methods
-fn near_client(worker: &Worker<Sandbox>) -> NearClient {
-    let rpc_url = Url::parse(format!("http://localhost:{}", worker.rpc_port()).as_str()).unwrap();
-    NearClient::new(rpc_url).unwrap()
-}
-
-async fn create_signer(
-    worker: &Worker<Sandbox>,
-    client: &NearClient,
-    signer_acc_id: &AccountId,
-) -> Signer {
-    let sk = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
-    let pk = Ed25519PublicKey::from(&sk);
-    let keypair = Keypair::new(sk).to_string();
-    let workspaces_sk = SecretKey::from_str(&keypair).unwrap();
-    let _ = worker
-        .create_tla(signer_acc_id.clone(), workspaces_sk)
-        .await
-        .unwrap();
-
-    let view_access_key = client
-        .view_access_key(signer_acc_id, &pk, Finality::None)
-        .await
-        .unwrap();
-
-    match view_access_key.result {
-        ViewAccessKeyResult::Ok(AccessKeyView { nonce, .. }) => {
-            Signer::from_secret_str(&keypair, signer_acc_id.clone(), nonce).unwrap()
-        }
-        ViewAccessKeyResult::Err { error, .. } => panic!("{error}"),
-    }
-}
-
-async fn download_contract() -> Vec<u8> {
-    let target = "https://github.com/near-examples/FT/raw/master/res/fungible_token.wasm";
-    let target_path = temp_dir().into_path();
-    let fname = "contract.wasm";
-    let full_dest = format!("{}/{}", target_path.to_string_lossy(), fname);
-
-    let contract_bytes = reqwest::get(target).await.unwrap().bytes().await.unwrap();
-    write(full_dest, &contract_bytes).unwrap();
-    contract_bytes.to_vec()
-}
-
-async fn clone_and_compile_wasm() -> Vec<u8> {
-    let tmp_path = temp_dir().into_path();
-    let repo_path = format!("{}/near-smartcontracts", tmp_path.to_string_lossy());
-    let target_path = format!("{repo_path}/test-contract");
-
-    create_dir_all(repo_path.clone()).unwrap();
-
-    let status = std::process::Command::new("git")
-        .arg("clone")
-        .arg("git@github.com:Relayz-io/near-smartcontracts.git")
-        .arg(&repo_path)
-        .spawn()
-        .unwrap()
-        .wait()
-        .unwrap();
-
-    if !status.success() {
-        panic!("Failed to clone a near-smartcontracts");
-    }
-
-    workspaces::compile_project(target_path.as_str())
-        .await
-        .unwrap()
-}
-
-fn random_bits() -> [u8; ED25519_SECRET_KEY_LENGTH] {
-    let mut chacha = ChaChaRng::from_entropy();
-    let mut secret_bytes = [0_u8; ED25519_SECRET_KEY_LENGTH];
-    chacha.fill_bytes(&mut secret_bytes);
-    secret_bytes
-}
-
-// tests themselves
-#[tokio::test]
-async fn contract_creation() {
-    let worker = workspaces::sandbox().await.unwrap();
-    let client = near_client(&worker);
-    let signer_account_id = AccountId::from_str("alice.test.near").unwrap();
-    let signer = create_signer(&worker, &client, &signer_account_id).await;
-    let wasm = download_contract().await;
-
-    client
-        .deploy_contract(&signer, &signer_account_id, wasm)
-        .commit(Finality::None)
-        .await
-        .unwrap();
-}
-
-#[tokio::test]
-async fn contract_function_call() {
-    let worker = workspaces::sandbox().await.unwrap();
-    let client = near_client(&worker);
-    let signer_account_id = AccountId::from_str("alice.test.near").unwrap();
-    let signer = create_signer(&worker, &client, &signer_account_id).await;
-    let wasm = download_contract().await;
-
-    client
-        .deploy_contract(&signer, &signer_account_id, wasm)
-        .commit(Finality::None)
-        .await
-        .unwrap();
-
-    client
-        .function_call(&signer, &signer_account_id, "new_default_meta")
-        .args(json!({
-            "owner_id": &signer_account_id,
-            "total_supply": "100",
-        }))
-        .gas(near_units::parse_gas!("300 T") as u64)
-        .commit(Finality::None)
-        .await
-        .unwrap();
-}
-
-#[tokio::test]
-async fn contract_function_call_failed() {
-    let worker = workspaces::sandbox().await.unwrap();
-    let client = near_client(&worker);
-    let signer_account_id = AccountId::from_str("alice.test.near").unwrap();
-    let signer = create_signer(&worker, &client, &signer_account_id).await;
-    let wasm = download_contract().await;
-
-    client
-        .deploy_contract(&signer, &signer_account_id, wasm)
-        .commit(Finality::None)
-        .await
-        .unwrap();
-
-    assert!(client
-        .function_call(&signer, &signer_account_id, "new_default_meta")
-        .args(json!({
-            "owner_id": &signer_account_id,
-            "total_suppl": "100",
-        }))
-        .gas(near_units::parse_gas!("300 T") as u64)
-        .commit(Finality::None)
-        .await
-        .is_err());
-
-    client
-        .function_call(&signer, &signer_account_id, "new_default_meta")
-        .args(json!({
-            "owner_id": &signer_account_id,
-            "total_supply": "100",
-        }))
-        .gas(near_units::parse_gas!("300 T") as u64)
-        .commit(Finality::None)
-        .await
-        .unwrap();
-}
-
-#[tokio::test]
-async fn multiple_tests() {
-    let worker = workspaces::sandbox().await.unwrap();
-    let client = near_client(&worker);
-    let signer_account_id = AccountId::from_str("alice.test.near").unwrap();
-    let signer = create_signer(&worker, &client, &signer_account_id).await;
-
-    let wasm = clone_and_compile_wasm().await;
-
-    init_contract(&client, &signer_account_id, &signer, wasm).await;
-    fc_no_params(&client, &signer_account_id, &signer).await;
-    fc_with_one_param_and_result(&client, &signer_account_id, &signer).await;
-    fc_with_param_and_result(&client, &signer_account_id, &signer).await;
-    view_no_params(&client, &signer_account_id).await;
-    view_with_params(&client, &signer_account_id).await;
-}
-
-async fn init_contract(
-    client: &NearClient,
-    contract_id: &AccountId,
-    signer: &Signer,
-    wasm: Vec<u8>,
-) {
-    client
-        .deploy_contract(signer, contract_id, wasm)
-        .commit(Finality::None)
-        .await
-        .unwrap();
-}
-
-async fn view_no_params(client: &NearClient, contract_id: &AccountId) {
-    client
-        .view::<u64>(contract_id, Finality::None, "show_id", None)
-        .await
-        .unwrap();
-}
-
-async fn view_with_params(client: &NearClient, contract_id: &AccountId) {
-    client
-        .view::<String>(
-            contract_id,
-            Finality::None,
-            "show_type",
-            Some(json!({"is_message": true})),
-        )
-        .await
-        .unwrap();
-}
-
-// fc = function call
-async fn fc_no_params(client: &NearClient, contract_id: &AccountId, signer: &Signer) {
-    client
-        .function_call(signer, contract_id, "increment")
-        .gas(near_units::parse_gas!("300 T") as u64)
-        .commit(Finality::None)
-        .await
-        .unwrap();
-}
-
-async fn fc_with_one_param_and_result(
-    client: &NearClient,
-    contract_id: &AccountId,
-    signer: &Signer,
-) {
-    let expected_result = "change message";
-    let message = client
-        .function_call(signer, contract_id, "change_message")
-        .args(json!({ "message": expected_result }))
-        .gas(near_units::parse_gas!("300 T") as u64)
-        .commit(Finality::Final)
-        .await
-        .unwrap()
-        .output::<String>()
-        .unwrap();
-
-    assert_eq!(message, expected_result);
-}
-
-async fn fc_with_param_and_result(client: &NearClient, contract_id: &AccountId, signer: &Signer) {
-    let expected_id = 666u64;
-    let id = client
-        .function_call(signer, contract_id, "change_id")
-        .args(json!({ "id": expected_id }))
-        .gas(near_units::parse_gas!("300 T") as u64)
-        .commit(Finality::Final)
-        .await
-        .unwrap()
-        .output::<u64>()
-        .unwrap();
-
-    assert_eq!(id, expected_id);
-}
-
-#[tokio::test]
-async fn async_transaction() {
-    let worker = workspaces::sandbox().await.unwrap();
-    let client = near_client(&worker);
-    let signer_account_id = AccountId::from_str("alice.test.near").unwrap();
-    let signer = create_signer(&worker, &client, &signer_account_id).await;
-
-    let wasm = clone_and_compile_wasm().await;
-
-    client
-        .deploy_contract(&signer, &signer_account_id, wasm)
-        .commit(Finality::None)
-        .await
-        .unwrap();
-
-    let expected_result = "change message";
-    let transaction_id = client
-        .function_call(&signer, &signer_account_id, "change_message")
-        .args(json!({ "message": expected_result }))
-        .gas(near_units::parse_gas!("300 T") as u64)
-        .commit_async(Finality::Final)
-        .await
-        .unwrap();
-
-    let (tx, rx) = tokio::sync::oneshot::channel::<()>();
-
-    tokio::spawn(async move {
-        tokio::time::timeout(std::time::Duration::from_secs(3), rx)
-            .await
-            .expect("Wait async transaction timeout")
-    });
-
-    loop {
-        let res = client.view_transaction(&transaction_id, &signer).await;
-
-        if let Err(near_rpc::Error::ViewTransaction(_)) = &res {
-            // try one more time
-            continue;
-        }
-
-        // cancel timeout
-        tx.send(()).unwrap();
-        let msg = res.unwrap().output::<String>().unwrap();
-
-        assert_eq!(msg, expected_result);
-        break;
-    }
-}
-
-#[tokio::test]
-async fn view_access_key_success() {
-    let worker = workspaces::sandbox().await.unwrap();
-    let client = near_client(&worker);
-    let signer_account_id = AccountId::from_str("alice.test.near").unwrap();
-    let signer = create_signer(&worker, &client, &signer_account_id).await;
-
-    let new_acc = AccountId::from_str("one.alice.test.near").unwrap();
-    let secret_key = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
-    let pk = Ed25519PublicKey::from(&secret_key);
-
-    let _ = client
-        .create_account(&signer, &new_acc, pk, near_units::parse_near!("3 N"))
-        .commit(Finality::None)
-        .await
-        .unwrap()
-        .output::<serde_json::Value>();
-
-    let access_key = client
-        .view_access_key(&new_acc, &pk, Finality::None)
-        .await
-        .unwrap();
-    assert!(matches!(
-        access_key,
-        ViewAccessKey {
-            result: ViewAccessKeyResult::Ok { .. },
-            ..
-        }
-    ));
-}
-
-#[tokio::test]
-async fn view_access_key_failure() {
-    let worker = workspaces::sandbox().await.unwrap();
-    let client = near_client(&worker);
-
-    let new_acc = AccountId::from_str("one.alice.test.near").unwrap();
-    let secret_key = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
-    let pk = Ed25519PublicKey::from(&secret_key);
-
-    let access_key = client
-        .view_access_key(&new_acc, &pk, Finality::None)
-        .await
-        .unwrap();
-    assert!(matches!(
-        access_key,
-        ViewAccessKey {
-            result: ViewAccessKeyResult::Err { .. },
-            ..
-        }
-    ));
-}
-
-#[tokio::test]
-async fn create_account() {
-    let worker = workspaces::sandbox().await.unwrap();
-    let client = near_client(&worker);
-    let signer_account_id = AccountId::from_str("alice.test.near").unwrap();
-    let signer = create_signer(&worker, &client, &signer_account_id).await;
-
-    let new_acc = AccountId::from_str("one.alice.test.near").unwrap();
-    let secret_key = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
-    let pk = Ed25519PublicKey::from(&secret_key);
-
-    let _ = client
-        .create_account(&signer, &new_acc, pk, near_units::parse_near!("3 N"))
-        .commit(Finality::Final)
-        .await
-        .unwrap()
-        .output::<serde_json::Value>();
-
-    let access_key = client
-        .view_access_key(&new_acc, &pk, Finality::None)
-        .await
-        .unwrap();
-    assert!(matches!(
-        access_key,
-        ViewAccessKey {
-            result: ViewAccessKeyResult::Ok { .. },
-            ..
-        }
-    ));
-}
-
-#[tokio::test]
-async fn delete_account() {
-    let worker = workspaces::sandbox().await.unwrap();
-    let client = near_client(&worker);
-    let signer_account_id = AccountId::from_str("alice.test.near").unwrap();
-    let signer = create_signer(&worker, &client, &signer_account_id).await;
-
-    let new_acc = AccountId::from_str("one.alice.test.near").unwrap();
-    let secret_key = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
-    let pk = Ed25519PublicKey::from(&secret_key);
-
-    client
-        .create_account(&signer, &new_acc, pk, near_units::parse_near!("3 N"))
-        .commit(Finality::Final)
-        .await
-        .unwrap();
-
-    let access_key = client
-        .view_access_key(&new_acc, &pk, Finality::None)
-        .await
-        .unwrap();
-
-    let nonce = if let ViewAccessKey {
-        result: ViewAccessKeyResult::Ok(AccessKeyView { nonce, .. }),
-        ..
-    } = access_key
-    {
-        nonce
-    } else {
-        panic!("Can't view access key for just created account")
-    };
-
-    let acc_signer = Signer::from_secret(secret_key, new_acc.clone(), nonce);
-
-    client
-        .delete_account(&acc_signer, &new_acc, &signer_account_id)
-        .commit(Finality::Final)
-        .await
-        .unwrap();
-
-    let access_key = client
-        .view_access_key(&new_acc, &pk, Finality::None)
-        .await
-        .unwrap();
-    assert!(matches!(
-        access_key,
-        ViewAccessKey {
-            result: ViewAccessKeyResult::Err { .. },
-            ..
-        }
-    ));
-}
-
-fn temp_dir() -> tempfile::TempDir {
-    tempfile::Builder::new()
-        .prefix("near-client-test-")
-        .tempdir()
-        .unwrap()
-}

web-client/Cargo.toml

@@ -21,10 +21,9 @@ gloo-timers = { version = "0.2", features = ["futures-core", "futures"] }
 itertools = "0.10"
 js-sys = "0.3"
 log = "0.4"
-near-primitives-light = { path = "../near-primitives-light" }
+near-client = "0.1"
 near-primitives-core = "0.15"
 near-units = "0.2"
-near-rpc = { path = "../near-rpc" }
 rand = { version = "0.8" }
 rand_chacha = "0.3"
 reqwest = { version = "0.11", features = ["json"] }

web-client/src/contract.rs

@@ -1,10 +1,5 @@
-use near_rpc::{
-    client::{NearClient, Signer},
-    Finality,
-};
-
 use crate::{error::ApiError, Handler};
-use common_api::crypto::prelude::*;
+use near_client::{crypto::prelude::*, prelude::*, Finality};
 use near_primitives_core::{hash::CryptoHash, types::AccountId};
 use near_units::parse_gas;
 use std::collections::HashSet;

web-client/src/crypto.rs

@@ -1,6 +1,6 @@
 use crate::error::ApiError;
 use aes_gcm::{aead::Aead, Aes256Gcm, KeyInit, Nonce};
-use common_api::{crypto::prelude::*, crypto::Error};
+use near_client::{crypto::prelude::*, crypto::Error};
 use rand::{RngCore, SeedableRng};
 use rand_chacha::ChaChaRng;
 use uuid::Uuid;

web-client/src/error.rs

@@ -1,6 +1,5 @@
-use common_api::crypto::Error as CryptoErr;
+use near_client::{crypto::Error as CryptoErr, Error};
 use near_primitives_core::account::id::ParseAccountError;
-use near_rpc::Error;
 use reqwest::Error as ExchangeError;
 use serde::{Deserialize, Serialize};
 use serde_json::Error as SerializationError;

web-client/src/exchange_client.rs

@@ -9,8 +9,8 @@ use reqwest::{
 };
 
 use crate::{contract::view_server_key, error::ApiError, Handler};
+use near_client::prelude::*;
 use near_primitives_core::types::AccountId;
-use near_rpc::client::Signer;
 use std::{collections::HashSet, time::Duration};
 use uuid::Uuid;
 use wasm_bindgen::JsValue;

web-client/src/lib.rs

@@ -17,8 +17,8 @@ use gloo_timers::future::TimeoutFuture;
 use itertools::Itertools;
 use js_sys::Promise;
 use log::{info, warn};
+use near_client::prelude::*;
 use near_primitives_core::{account::id::AccountId, hash::CryptoHash, types::Nonce};
-use near_rpc::client::Signer;
 use serde::{Deserialize, Serialize};
 use std::{collections::HashSet, str::FromStr, sync::Arc};
 use url::Url;

web-client/tests/integration.rs

@@ -1,7 +1,5 @@
-use common_api::crypto::prelude::*;
+use near_client::{crypto::prelude::*, prelude::*, Finality};
 use near_primitives_core::account::id::AccountId;
-use near_primitives_light::types::Finality;
-use near_rpc::client::{NearClient, Signer};
 use serde::{Deserialize, Serialize};
 use std::str::FromStr;
 use url::Url;