Migrate Tezos to Rust

rust/Cargo.toml

@@ -21,6 +21,7 @@ members = [
  "chains/tw_ronin",
  "chains/tw_solana",
  "chains/tw_sui",
+ "chains/tw_tezos",
  "chains/tw_thorchain",
  "chains/tw_ton",
  "chains/tw_zcash",

rust/chains/tw_tezos/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "tw_tezos"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+tw_base58_address = { path = "../../tw_base58_address" }
+tw_coin_entry = { path = "../../tw_coin_entry" }
+tw_encoding = { path = "../../tw_encoding" }
+tw_keypair = { path = "../../tw_keypair" }
+tw_hash = { path = "../../tw_hash" }
+tw_memory = { path = "../../tw_memory" }
+tw_misc = { path = "../../tw_misc", features = ["serde"] }
+tw_proto = { path = "../../tw_proto" }
+zeroize = "1.8.1"
+
+[dev-dependencies]
+tw_coin_entry = { path = "../../tw_coin_entry", features = ["test-utils"] }
+tw_number = { path = "../../tw_number", features = ["helpers"] }

rust/chains/tw_tezos/src/address.rs

@@ -0,0 +1,160 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use std::fmt;
+use std::str::FromStr;
+use tw_base58_address::Base58Address;
+use tw_coin_entry::coin_entry::CoinAddress;
+use tw_coin_entry::error::prelude::*;
+use tw_encoding::base58::Alphabet;
+use tw_hash::blake2::blake2_b;
+use tw_hash::sha2::Sha256d;
+use tw_hash::H160;
+use tw_keypair::{
+ ecdsa, ed25519,
+ tw::{PublicKey, PublicKeyType},
+};
+use tw_memory::Data;
+
+use crate::forging::forge_public_key_hash;
+
+pub const TEZOS_ADDRESS_SIZE: usize = 23;
+pub const TEZOS_ADDRESS_PREFIX_SIZE: usize = 3;
+pub const TEZOS_ADDRESS_PUBLIC_KEY_HASH_SIZE: usize = 20;
+pub const TEZOS_ADDRESS_CHECKSUM_SIZE: usize = 4;
+
+pub const TEZOS_ADDRESS_SECP256K1_PREFIX: [u8; TEZOS_ADDRESS_PREFIX_SIZE] = [0x06, 0xa1, 0xa1];
+pub const TEZOS_ADDRESS_ED25519_PREFIX: [u8; TEZOS_ADDRESS_PREFIX_SIZE] = [0x06, 0xa1, 0x9f];
+pub const TEZOS_ADDRESS_OTHER_PREFIX: [u8; TEZOS_ADDRESS_PREFIX_SIZE] = [0x06, 0xa1, 0xa4];
+pub const TEZOS_ADDRESS_KT1_PREFIX: [u8; TEZOS_ADDRESS_PREFIX_SIZE] = [0x02, 0x5a, 0x79];
+
+pub const ACCOUNT_ZERO_BYTES: [u8; TEZOS_ADDRESS_SIZE] = [0; TEZOS_ADDRESS_SIZE];
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct TezosAddress(Base58Address<TEZOS_ADDRESS_SIZE, TEZOS_ADDRESS_CHECKSUM_SIZE, Sha256d>);
+
+impl TezosAddress {
+ fn new(public_key_hash: &[u8], prefix: &[u8]) -> AddressResult<TezosAddress> {
+ if prefix.len() != TEZOS_ADDRESS_PREFIX_SIZE {
+ return Err(AddressError::InvalidInput);
+ }
+ if public_key_hash.len() != TEZOS_ADDRESS_PUBLIC_KEY_HASH_SIZE {
+ return Err(AddressError::InvalidInput);
+ }
+ let mut bytes: Data = Vec::with_capacity(prefix.len() + public_key_hash.len());
+ bytes.extend_from_slice(prefix);
+ bytes.extend_from_slice(public_key_hash);
+ Base58Address::new(&bytes, Alphabet::Bitcoin).map(TezosAddress)
+ }
+
+ pub fn with_public_key(public_key: &PublicKey) -> AddressResult<TezosAddress> {
+ if public_key.public_key_type() == PublicKeyType::Secp256k1 {
+ TezosAddress::with_secp256k1_public_key(
+ public_key
+ .to_secp256k1()
+ .ok_or(AddressError::PublicKeyTypeMismatch)?,
+ )
+ } else if public_key.public_key_type() == PublicKeyType::Ed25519 {
+ TezosAddress::with_ed25519_public_key(
+ public_key
+ .to_ed25519()
+ .ok_or(AddressError::PublicKeyTypeMismatch)?,
+ )
+ } else {
+ Err(AddressError::InvalidInput)
+ }
+ }
+
+ pub fn with_secp256k1_public_key(
+ public_key: &ecdsa::secp256k1::PublicKey,
+ ) -> AddressResult<TezosAddress> {
+ let bytes = blake2_b(
+ public_key.compressed().as_slice(),
+ TEZOS_ADDRESS_PUBLIC_KEY_HASH_SIZE,
+ )?;
+ TezosAddress::new(&bytes, &TEZOS_ADDRESS_SECP256K1_PREFIX)
+ }
+
+ pub fn with_ed25519_public_key(
+ public_key: &ed25519::sha512::PublicKey,
+ ) -> AddressResult<TezosAddress> {
+ let bytes = blake2_b(public_key.as_slice(), TEZOS_ADDRESS_PUBLIC_KEY_HASH_SIZE)?;
+ TezosAddress::new(&bytes, &TEZOS_ADDRESS_ED25519_PREFIX)
+ }
+
+ /// Address bytes excluding the prefix (skip first 3 bytes).
+ pub fn bytes(&self) -> &[u8] {
+ &self.0.as_ref()[TEZOS_ADDRESS_PREFIX_SIZE..]
+ }
+
+ /// Returns public key hash associated with the address.
+ pub fn public_key_hash(&self) -> H160 {
+ H160::try_from(&self.0.as_ref()[TEZOS_ADDRESS_PREFIX_SIZE..])
+ .expect("Expected exactly 20 bytes public key hash")
+ }
+
+ pub fn forge(&self) -> AddressResult<Data> {
+ // normal address
+ // https://github.com/ecadlabs/taquito/blob/master/packages/taquito-local-forging/src/codec.ts#L183
+ let prefix = &self.0.bytes[..TEZOS_ADDRESS_PREFIX_SIZE];
+ if prefix == TEZOS_ADDRESS_SECP256K1_PREFIX
+ || prefix == TEZOS_ADDRESS_ED25519_PREFIX
+ || prefix == TEZOS_ADDRESS_OTHER_PREFIX
+ {
+ let mut forged = vec![0x00];
+ let forged_public_key_hash =
+ forge_public_key_hash(&self.to_string()).map_err(|_| AddressError::InvalidInput)?;
+ forged.extend_from_slice(&forged_public_key_hash);
+ Ok(forged)
+ }
+ // contract address
+ // https://github.com/ecadlabs/taquito/blob/master/packages/taquito-local-forging/src/codec.ts#L183
+ else if prefix == TEZOS_ADDRESS_KT1_PREFIX {
+ let mut forged = vec![0x01];
+ forged.extend_from_slice(self.bytes());
+ forged.push(0x00);
+ Ok(forged)
+ } else {
+ Err(AddressError::InvalidInput)
+ }
+ }
+}
+
+impl Default for TezosAddress {
+ fn default() -> Self {
+ Base58Address::new(ACCOUNT_ZERO_BYTES.as_slice(), Alphabet::Bitcoin)
+ .map(TezosAddress)
+ .expect("'ACCOUNT_ZERO_BYTES' is expected to be valid address bytes")
+ }
+}
+
+impl CoinAddress for TezosAddress {
+ #[inline]
+ fn data(&self) -> Data {
+ self.bytes().to_vec()
+ }
+}
+
+impl FromStr for TezosAddress {
+ type Err = AddressError;
+
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
+ let base58_addr = Base58Address::<TEZOS_ADDRESS_SIZE, TEZOS_ADDRESS_CHECKSUM_SIZE, Sha256d>::from_str_with_alphabet(s, Alphabet::Bitcoin)?;
+ let prefix = &base58_addr.bytes[..TEZOS_ADDRESS_PREFIX_SIZE];
+ if prefix != TEZOS_ADDRESS_SECP256K1_PREFIX
+ && prefix != TEZOS_ADDRESS_ED25519_PREFIX
+ && prefix != TEZOS_ADDRESS_OTHER_PREFIX
+ && prefix != TEZOS_ADDRESS_KT1_PREFIX
+ {
+ return Err(AddressError::UnexpectedAddressPrefix);
+ }
+ Ok(TezosAddress(base58_addr))
+ }
+}
+
+impl fmt::Display for TezosAddress {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "{}", self.0)
+ }
+}

rust/chains/tw_tezos/src/binary_coding.rs

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use tw_encoding::{
+ base58::{self, Alphabet, CHECKSUM_LEN},
+ hex, EncodingError,
+};
+use tw_hash::sha2::sha256_d;
+use tw_keypair::{ecdsa, ed25519, KeyPairError};
+use tw_memory::Data;
+use zeroize::Zeroizing;
+
+use crate::address::TEZOS_ADDRESS_PREFIX_SIZE;
+
+const TEZOS_KEY_PREFIX_SIZE: usize = 4;
+
+pub fn decode_check(input: &str, alphabet: Alphabet) -> Result<Data, EncodingError> {
+ let data = base58::decode(input, alphabet)?;
+ if data.len() < CHECKSUM_LEN {
+ return Err(EncodingError::InvalidInput);
+ }
+
+ let checksum = &data[data.len() - CHECKSUM_LEN..];
+ let hash = sha256_d(&data[..data.len() - CHECKSUM_LEN]);
+ if checksum != &hash[..CHECKSUM_LEN] {
+ return Err(EncodingError::InvalidInput);
+ }
+ Ok(Data::from(&data[..data.len() - CHECKSUM_LEN]))
+}
+
+pub fn encode_check(data: &[u8], alphabet: Alphabet) -> String {
+ let hash = sha256_d(data);
+ let mut to_be_encoded = Vec::from(data);
+ to_be_encoded.extend_from_slice(&hash[..CHECKSUM_LEN]);
+ base58::encode(&to_be_encoded, alphabet)
+}
+
+pub fn base58_to_hex(input: &str, prefix_length: usize) -> Result<String, EncodingError> {
+ let decoded = match decode_check(input, Alphabet::Bitcoin) {
+ Ok(d) => d,
+ Err(_) => return Err(EncodingError::InvalidInput),
+ };
+
+ if decoded.len() < prefix_length {
+ return Err(EncodingError::InvalidInput);
+ }
+
+ Ok(hex::encode(&decoded[prefix_length..], false))
+}
+
+pub fn parse_public_key(public_key: &str) -> Result<tw_keypair::tw::PublicKey, KeyPairError> {
+ let decoded =
+ decode_check(public_key, Alphabet::Bitcoin).map_err(|_| KeyPairError::InvalidPublicKey)?;
+
+ let ed25519_prefix = [13, 15, 37, 217];
+ let secp256k1_prefix = [3, 254, 226, 86];
+
+ if decoded.starts_with(&ed25519_prefix) {
+ if decoded.len() != 32 + TEZOS_KEY_PREFIX_SIZE {
+ return Err(KeyPairError::InvalidPublicKey);
+ }
+ Ok(tw_keypair::tw::PublicKey::Ed25519(
+ ed25519::sha512::PublicKey::try_from(&decoded[TEZOS_KEY_PREFIX_SIZE..])?,
+ ))
+ } else if decoded.starts_with(&secp256k1_prefix) {
+ if decoded.len() != 33 + TEZOS_KEY_PREFIX_SIZE {
+ return Err(KeyPairError::InvalidPublicKey);
+ }
+ Ok(tw_keypair::tw::PublicKey::Secp256k1(
+ ecdsa::secp256k1::PublicKey::try_from(&decoded[TEZOS_KEY_PREFIX_SIZE..])?,
+ ))
+ } else {
+ Err(KeyPairError::InvalidPublicKey)
+ }
+}
+
+pub fn parse_private_key(private_key: &str) -> Result<tw_keypair::tw::PrivateKey, KeyPairError> {
+ let decoded = Zeroizing::new(
+ decode_check(private_key, Alphabet::Bitcoin).map_err(|_| KeyPairError::InvalidSecretKey)?,
+ );
+
+ if decoded.len() != 32 + TEZOS_KEY_PREFIX_SIZE {
+ return Err(KeyPairError::InvalidSecretKey);
+ }
+
+ tw_keypair::tw::PrivateKey::new((decoded[TEZOS_KEY_PREFIX_SIZE..]).to_vec())
+}
+
+pub fn encode_prefix(address: &str, forged: &mut Data) -> Result<(), EncodingError> {
+ let decoded = decode_check(address, Alphabet::Bitcoin)?;
+ forged.extend_from_slice(&decoded[TEZOS_ADDRESS_PREFIX_SIZE..]);
+ Ok(())
+}