#![cfg_attr(not(feature = "std"), no_std)]#![cfg_attr(not(feature = "std"), no_std)]

#![allow(clippy::too_many_arguments, clippy::type_complexity)]

extern crate alloc;

use frame_support::traits::StorageVersion;

pub use pallet::*;

use sp_io::crypto::secp256k1_ecdsa_recover_compressed;

use sp_io::KillStorageResult;

use sp_runtime::KeyTypeId;

use sp_std::prelude::*;

#[cfg(test)]

mod mock;

#[allow(clippy::unnecessary_cast)]

pub mod weights;

mod benchmarking;

#[cfg(test)]

mod tests;

#[macro_use]

mod helpers;

mod migrations;

pub mod ocw;

mod types;

use ocw::tasks::collect_coins::GCreContract;

pub use types::*;

pub const KEY_TYPE: KeyTypeId = KeyTypeId(*b"ctcs");

pub mod crypto {

  use crate::KEY_TYPE;

  use sp_runtime::{

    app_crypto::{app_crypto, sr25519},

    MultiSignature, MultiSigner,

  };

  app_crypto!(sr25519, KEY_TYPE);

  pub struct CtcAuthId;

  impl frame_system::offchain::AppCrypto<MultiSigner, MultiSignature> for CtcAuthId {

    type RuntimeAppPublic = Public;

    type GenericPublic = sp_core::sr25519::Public;

    type GenericSignature = sp_core::sr25519::Signature;

  }

}

pub type BalanceFor<T> = <T as pallet_balances::Config>::Balance;

pub const STORAGE_VERSION: StorageVersion = StorageVersion::new(6);

#[fr
ame_support::pallet0
]370

pub mod pallet {

  use crate::helpers::non_paying_error;

  use super::*;

  use frame_support::{

    dispatch::DispatchResult,

    pallet_prelude::*,

    traits::tokens::{currency::Currency as CurrencyT, fungible::Mutate, ExistenceRequirement},

    transactional,

    weights::PostDispatchInfo,

  };

  use frame_system::{

    ensure_signed,

    offchain::{AppCrypto, CreateSignedTransaction},

    pallet_prelude::*,

  };

  use ocw::errors::VerificationFailureCause;

  use sp_runtime::offchain::storage_lock::{BlockAndTime, StorageLock};

  use sp_runtime::offchain::Duration;

  use sp_runtime::traits::{

    IdentifyAccount, SaturatedConversion, Saturating, UniqueSaturatedFrom, UniqueSaturatedInto,

    Verify,

  };

  use tracing as log;

  /// Configure the pallet by specifying the parameters and types on which it depends.

  #[pallet::config]

  pub trait Config:

    frame_system::Config

    + pallet_balances::Config

    + pallet_timestamp::Config

    + CreateSignedTransaction<Call<Self>>

  where

    <Self as frame_system::Config>::BlockNumber: UniqueSaturatedInto<u64>,

    <Self as pallet_timestamp::Config>::Moment:

      UniqueSaturatedInto<u64> + UniqueSaturatedFrom<u64>,

  {

    /// Because this pallet emits events, it depends on the runtime's definition of an event.

    type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;

    type Call: From<Call<Self>>;

    type AuthorityId: AppCrypto<

      Self::Public,

      <Self as frame_system::offchain::SigningTypes>::Signature,

    >;

    type Signer: From<sp_core::ecdsa::Public>

      + IdentifyAccount<AccountId = <Self as frame_system::Config>::AccountId>

      + Parameter;

    type SignerSignature: Verify<Signer = Self::Signer>

      + From<sp_core::ecdsa::Signature>

      + Parameter;

    type FromAccountId: From<sp_core::sr25519::Public>

      + IsType<Self::AccountId>

      + Clone

      + core::fmt::Debug

      + PartialEq<Self::FromAccountId>

      + AsRef<[u8; 32]>;

    type InternalPublic: sp_core::crypto::UncheckedFrom<[u8; 32]>;

    type PublicSigning: From<Self::InternalPublic> + Into<Self::Public>;

    // in order to turn a `Hash` into a U256 for checking the nonces on

    // ethless transfers we need the `Hash` type to implement

    // the BigEndianHash trait. This effectively constrains the Hash

    // type to H256, which sort of defeats the purpose of it being an associated type.

    // However a lot of code refers to Config::Hash, so right now this is the least invasive way

    // to get the compiler to let us do the Config::Hash -> U256 conversion

    type HashIntoNonce: IsType<<Self as frame_system::Config>::Hash>

      + ethereum_types::BigEndianHash<Uint = sp_core::U256>

      + Clone;

    type UnverifiedTaskTimeout: Get<<Self as frame_system::Config>::BlockNumber>;

    type WeightInfo: WeightInfo;

  }

  pub trait WeightInfo {

    fn on_initialize(a: u32, b: u32, o: u32, d: u32, f: u32, u: u32, c: u32) -> Weight;

    fn register_address() -> Weight;

    fn claim_legacy_wallet() -> Weight;

    fn add_ask_order() -> Weight;

    fn add_bid_order() -> Weight;

    fn add_offer() -> Weight;

    fn add_deal_order() -> Weight;

    fn add_authority() -> Weight;

    fn persist_transfer() -> Weight;

    fn fail_transfer() -> Weight;

    fn fund_deal_order() -> Weight;

    fn lock_deal_order() -> Weight;

    fn register_funding_transfer() -> Weight;

    fn register_repayment_transfer() -> Weight;

    fn register_funding_transfer_legacy() -> Weight;

    fn register_repayment_transfer_legacy() -> Weight;

    fn close_deal_order() -> Weight;

    fn exempt() -> Weight;

    fn register_deal_order() -> Weight;

    fn request_collect_coins() -> Weight;

    fn persist_collect_coins() -> Weight;

    fn fail_collect_coins() -> Weight;

    fn remove_authority() -> Weight;

    fn set_collect_coins_contract() -> Weight;

    fn register_currency() -> Weight;

  }

  #[pallet::pallet]

  #[pallet::storage_version(STORAGE_VERSION)]

  #[pallet::generate_store(pub(super) trait Store)]

  pub struct Pallet<T>(_);

  #[pallet::storage]

  #[pallet::getter(fn authorities)]

  pub type Authorities<T: Config> = StorageMap<_, Blake2_128Concat, T::AccountId, ()>;

  #[pallet::storage]

  pub type LegacyWallets<T: Config> = StorageMap<_, Twox128, LegacySighash, T::Balance>;

  #[pallet::storage]

  pub type LegacyBalanceKeeper<T: Config> = StorageValue<_, T::AccountId>;

  #[pallet::storage]

  #[pallet::getter(fn pending_tasks)]

  pub type PendingTasks<T: Config> = StorageDoubleMap<

    _,

    Identity,

    T::BlockNumber,

    Identity,

    TaskId<T::Hash>,

    Task<T::AccountId, T::BlockNumber, T::Hash, T::Moment>,

  >;

  #[pallet::storage]

  #[pallet::getter(fn deal_orders)]

  pub type DealOrders<T: Config> = StorageDoubleMap<

    _,

    Twox64Concat,

    T::BlockNumber,

    Identity,

    T::Hash,

    DealOrder<T::AccountId, T::BlockNumber, T::Hash, T::Moment>,

  >;

  #[pallet::storage]

  #[pallet::getter(fn addresses)]

  pub type Addresses<T: Config> =

    StorageMap<_, Blake2_128Concat, AddressId<T::Hash>, Address<T::AccountId>>;

  #[pallet::storage]

  #[pallet::getter(fn used_guids)]

  pub type UsedGuids<T: Config> = StorageMap<_, Blake2_128Concat, Guid, ()>;

  #[pallet::storage]

  #[pallet::getter(fn ask_orders)]

  pub type AskOrders<T: Config> = StorageDoubleMap<

    _,

    Twox64Concat,

    T::BlockNumber,

    Identity,

    T::Hash,

    AskOrder<T::AccountId, T::BlockNumber, T::Hash>,

  >;

  #[pallet::storage]

  #[pallet::getter(fn bid_orders)]

  pub type BidOrders<T: Config> = StorageDoubleMap<

    _,

    Twox64Concat,

    T::BlockNumber,

    Identity,

    T::Hash,

    BidOrder<T::AccountId, T::BlockNumber, T::Hash>,

  >;

  #[pallet::storage]

  #[pallet::getter(fn offers)]

  pub type Offers<T: Config> = StorageDoubleMap<

    _,

    Twox64Concat,

    T::BlockNumber,

    Identity,

    T::Hash,

    Offer<T::AccountId, T::BlockNumber, T::Hash>,

  >;

  #[pallet::storage]

  #[pallet::getter(fn transfers)]

  pub type Transfers<T: Config> = StorageMap<

    _,

    Identity,

    TransferId<T::Hash>,

    Transfer<T::AccountId, T::BlockNumber, T::Hash, T::Moment>,

  >;

  #[pallet::storage]

  #[pallet::getter(fn collected_coins)]

  pub type CollectedCoins<T: Config> = StorageMap<

    _,

    Identity,

    CollectedCoinsId<T::Hash>,

    types::CollectedCoins<T::Hash, T::Balance>,

  >;

  #[pallet::storage]

  pub type Currencies<T: Config> = StorageMap<_, Identity, CurrencyId<T::Hash>, Currency>;

  #[pallet::storage]

  #[pallet::getter(fn collect_coins_contract)]

  pub type CollectCoinsContract<T: Config> = StorageValue<_, GCreContract, ValueQuery>;

  #[pallet::event]

  #[pallet::generate_deposit(pub(super) fn deposit_event)]

  pub enum Event<T: Config> {

    /// An address on an external chain has been registered.

    /// [registered_address_id, registered_address]

    AddressRegistered(AddressId<T::Hash>, Address<T::AccountId>),

    /// Collecting coins from Eth ERC-20 has been registered and will be verified.

    /// [collected_coins_id, registered_collect_coins]

    CollectCoinsRegistered(CollectedCoinsId<T::Hash>, types::UnverifiedCollectedCoins),

    /// An external transfer has been registered and will be verified.

    /// [registered_transfer_id, registered_transfer]

    TransferRegistered(

      TransferId<T::Hash>,

      Transfer<T::AccountId, T::BlockNumber, T::Hash, T::Moment>,

    ),

    /// An external transfer has been successfully verified.

    /// [verified_transfer_id]

    TransferVerified(TransferId<T::Hash>),

    /// CollectCoins has been successfully verified and minted.

    /// [collected_coins_id, collected_coins]

    CollectedCoinsMinted(

      types::CollectedCoinsId<T::Hash>,

      types::CollectedCoins<T::Hash, T::Balance>,

    ),

    /// An external transfer has been processed and marked as part of a loan.

    /// [processed_transfer_id]

    TransferProcessed(TransferId<T::Hash>),

    /// An ask order has been added by a prospective lender. This indicates that the lender

    /// is looking to issue a loan with certain terms.

    /// [ask_order_id, ask_order]

    AskOrderAdded(

      AskOrderId<T::BlockNumber, T::Hash>,

      AskOrder<T::AccountId, T::BlockNumber, T::Hash>,

    ),

    /// A bid order has been added by a prospective borrower. This indicates that the borrower

    /// is looking for a loan with certain terms.

    /// [bid_order_id, bid_order]

    BidOrderAdded(

      BidOrderId<T::BlockNumber, T::Hash>,

      BidOrder<T::AccountId, T::BlockNumber, T::Hash>,

    ),

    /// An offer has been added by a lender. This indicates that the lender

    /// is interested in entering a loan with the owner of the bid order.

    /// [offer_id, offer]

    OfferAdded(OfferId<T::BlockNumber, T::Hash>, Offer<T::AccountId, T::BlockNumber, T::Hash>),

    /// A deal order has been added by a borrower. This indicates that the borrower

    /// has accepted a lender's offer and intends to enter the loan.

    /// [deal_order_id, deal_order]

    DealOrderAdded(

      DealOrderId<T::BlockNumber, T::Hash>,

      DealOrder<T::AccountId, T::BlockNumber, T::Hash, T::Moment>,

    ),

    /// A deal order has been funded by a lender. This indicates that the lender

    /// has initiated the actual loan by transferring the loan amount to the borrower

    /// on an external chain.

    /// [funded_deal_order_id]

    DealOrderFunded(DealOrderId<T::BlockNumber, T::Hash>),

    /// A deal order has been locked by a borrower. This indicates that the borrower

    /// is preparing to make a repayment and locks the loan from being sold or transferred

    /// to another party.

    /// [deal_order_id]

    DealOrderLocked(DealOrderId<T::BlockNumber, T::Hash>),

    /// A deal order has been closed by a borrower. This indicates that the borrower

    /// has repaid the loan in full and is now closing out the loan.

    /// [closed_deal_order_id]

    DealOrderClosed(DealOrderId<T::BlockNumber, T::Hash>),

    /// A loan exemption has been granted by a lender. This indicates that the lender

    /// is releasing all of the outstanding debt on the loan. The borrower

    /// is no longer responsible for repaying the amount.

    /// [exempted_deal_order_id]

    LoanExempted(DealOrderId<T::BlockNumber, T::Hash>),

    /// A legacy wallet from Creditcoin 1.X has been claimed. The balance of the legacy wallet

    /// has been transferred to the owner's Creditcoin 2.0 account.

    /// [legacy_wallet_claimer, legacy_wallet_sighash, legacy_wallet_balance]

    LegacyWalletClaimed(T::AccountId, LegacySighash, T::Balance),

    TransferFailedVerification(TransferId<T::Hash>, VerificationFailureCause),

    /// exchanging vested ERC-20 CC for native CC failed.

    /// [collected_coins_id, cause]

    CollectCoinsFailedVerification(CollectedCoinsId<T::Hash>, VerificationFailureCause),

    /// A currency has been registered and can now be used in loan terms.

    /// [currency_id, currency]

    CurrencyRegistered(CurrencyId<T::Hash>, Currency),

  }

  // Errors inform users that something went wrong.

  #[derive(PartialEq, Eq)]

  #[pallet::error]

  pub enum Error<T> {

    /// The specified address has already been registered to another account

    AddressAlreadyRegistered,

    /// The specified address does not exist.

    NonExistentAddress,

    /// The specified deal order does not exist.

    NonExistentDealOrder,

    /// The specified ask order does not exist.

    NonExistentAskOrder,

    /// The specified bid order does not exist.

    NonExistentBidOrder,

    /// The specified offer does not exist.

    NonExistentOffer,

    /// The specified transfer does not exist.

    NonExistentTransfer,

    /// The transfer has already been registered.

    TransferAlreadyRegistered,

    /// The coin collection has already been registered.

    CollectCoinsAlreadyRegistered,

    /// The account that registered the transfer does

    /// not match the account attempting to use the transfer.

    TransferAccountMismatch,

    ///The specified deal order ID does not match the transfer deal order ID.

    TransferDealOrderMismatch,

    ///The amount on the deal order does not match the transfer amount.

    TransferAmountMismatch,

    /// The transfer has already been processed and cannot be used.

    TransferAlreadyProcessed,

    /// The transfer amount is less than the amount in the loan terms.

    TransferAmountInsufficient,

    /// The transfer is malformed and has a block number greater than the

    /// tip. This is an internal error.

    MalformedTransfer,

    /// The specified transfer type is not currently supported by

    /// the blockchain the loan is executed on.

    UnsupportedTransferKind,

    /// The node does not have sufficient authority to verify a transfer.

    InsufficientAuthority,

    /// The specified ID has already been used.

    DuplicateId,

    /// The address cannot be used because the user does not own it.

    NotAddressOwner,

    /// Failed to send an offchain callback transaction. This is likely

    /// an internal error.

    OffchainSignedTxFailed,

    /// The node is an authority but there is no account to create a

    /// callback transaction. This is likely an internal error.

    NoLocalAcctForSignedTx,

    RepaymentOrderNonZeroGain,

    /// The addresses specified are not on compatible external chains.

    AddressBlockchainMismatch,

    /// The account is already an authority.

    AlreadyAuthority,

    /// The account you are trying to remove is not  an authority.

    NotAnAuthority,

    /// The offer has already been made.

    DuplicateOffer,

    /// The deal cannot be locked because it is not funded yet.

    DealNotFunded,

    /// The deal order is already funded and cannot be funded again.

    DealOrderAlreadyFunded,

    /// The deal order is already closed and cannot be closed again.

    DealOrderAlreadyClosed,

    /// The deal order is already locked and cannot be locked again.

    DealOrderAlreadyLocked,

    /// The deal order must be locked before it can be closed.

    DealOrderMustBeLocked,

    /// The deal order already exists.

    DuplicateDealOrder,

    /// The deal order has expired and is no longer valid.

    DealOrderExpired,

    /// The ask order has expired and is no longer valid.

    AskOrderExpired,

    /// The bid order has expired and is no longer valid.

    BidOrderExpired,

    /// The offer order has expired and is no longer valid.

    OfferExpired,

    /// The terms of the ask and bid order do not agree.

    AskBidMismatch,

    /// The bid order is owned by the user, a user cannot lend to themself.

    SameOwner,

    /// The signature does not match the public key and message.

    InvalidSignature,

    /// Only the borrower can perform the action.

    NotBorrower,

    /// The deal order is malformed and has a block number greater than the

    /// tip. This is an internal error.

    MalformedDealOrder,

    /// Only the lender can perform the action.

    NotLender,

    /// Repayment orders are not currently supported.

    RepaymentOrderUnsupported,

    /// The legacy wallet is not owned by the user.

    NotLegacyWalletOwner,

    /// There is no legacy wallet corresponding to the public key.

    LegacyWalletNotFound,

    /// There is no legacy balance keeper, so no legacy wallets can be claimed.

    /// This is a configuration error and should only occur during local development.

    LegacyBalanceKeeperMissing,

    /// The specified guid has already been used and cannot be re-used.

    GuidAlreadyUsed,

    /// The value of the loan term's term length is zero, which is invalid.

    InvalidTermLength,

    /// The external address is malformed or otherwise invalid for the platform.

    MalformedExternalAddress,

    /// The address format was not recognized for the given blockchain and external address.

    AddressFormatNotSupported,

    /// The address retrieved from the proof-of-ownership signature did not match the external address being registered.

    OwnershipNotSatisfied,

    /// The currency has already been registered.

    CurrencyAlreadyRegistered,

    /// The legacy/deprecated version of an extrinsic was called, the new version should be used instead.

    DeprecatedExtrinsic,

    /// The currency with the given ID has not been registered.

    CurrencyNotRegistered,

  }

  #[pallet::genesis_config]

  pub struct GenesisConfig<T: Config> {

    pub authorities: Vec<T::AccountId>,

    pub legacy_wallets: Vec<(LegacySighash, T::Balance)>,

    pub legacy_balance_keeper: Option<T::AccountId>,

  }

  #[cfg(feature = "std")]

  impl<T: Config> Default for GenesisConfig<T> {

    fn default() -> Self {

      Self {

        authorities: Vec::new(),

        legacy_wallets: Vec::new(),

        legacy_balance_keeper: None,

      }

    }

  }

  #[pallet::genesis_build]

  impl<T: Config> GenesisBuild<T> for GenesisConfig<T> {

    fn build(&self) {

      for 
authority30
 in &self.authorities {

        Authorities::<T>::insert(authority.clone(), ());

      }

      for (
sighash, balance1
) in &self.legacy_wallets {

        LegacyWallets::<T>::insert(sighash, balance);

      }

      if let Some(
acct1
) = &self.legacy_balance_keeper {

        LegacyBalanceKeeper::<T>::put(acct.clone());

      }

    }

  }

  #[pallet::hooks]

  impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {

    fn on_initialize(block_number: T::BlockNumber) -> Weight {

      log::debug!("Cleaning up expired entries");

      let unverified_task_count = match PendingTasks::<T>::remove_prefix(block_number, None) {

        KillStorageResult::SomeRemaining(
u0
) | KillStorageResult::AllRemoved(u) => u,

      };

      let ask_count = match AskOrders::<T>::remove_prefix(block_number, None) {

        KillStorageResult::SomeRemaining(
u0
) | KillStorageResult::AllRemoved(u) => u,

      };

      let bid_count = match BidOrders::<T>::remove_prefix(block_number, None) {

        KillStorageResult::SomeRemaining(
u0
) | KillStorageResult::AllRemoved(u) => u,

      };

      let offer_count = match Offers::<T>::remove_prefix(block_number, None) {

        KillStorageResult::SomeRemaining(
u0
) | KillStorageResult::AllRemoved(u) => u,

      };

      let mut deals_count = 0u32;

      let deals_to_keep: Vec<_> = DealOrders::<T>::drain_prefix(block_number)

        .filter_map(|(hash, deal)| {

          deals_count = deals_count.saturating_add(1);

          if deal.funding_transfer_id.is_some() {

            Some((DealOrderId::with_expiration_hash::<T>(block_number, hash), deal))

          } else {

            None

          }

        })

        .collect();

      let funded_deals_count = deals_to_keep.len().unique_saturated_into();

      let deals_count = deals_count.saturating_sub(funded_deals_count);

      for (
key, deal7
) in deals_to_keep {

        DealOrders::<T>::insert_id(key, deal);

      }

      <T as Config>::WeightInfo::on_initialize(

        ask_count,

        bid_count,

        offer_count,

        deals_count,

        funded_deals_count,

        unverified_task_count,

        0,

      )

    }

    fn offchain_worker(block_number: T::BlockNumber) {

      let 
auth_id29
 = match Self::authority_id() {

        None => {

          log::debug!(target: "OCW", "Not authority, skipping off chain work");

          return;

        },

        Some(auth) => T::FromAccountId::from(auth),

      };

      for (
deadline, id, task30
) in PendingTasks::<T>::iter() {

        let storage_key = crate::ocw::tasks::storage_key(&id);

        let offset =

          T::UnverifiedTaskTimeout::get().saturated_into::<u32>().saturating_sub(2u32);

        let mut lock = StorageLock::<BlockAndTime<frame_system::Pallet<T>>>::with_block_and_time_deadline(

          &storage_key,

          offset,

          Duration::from_millis(0),

        );

        let 
guard16
 = match lock.try_lock() {

          Ok(g) => g,

          Err(_) => continue,

        };

        if match &id {

          TaskId::VerifyTransfer(id) => Transfers::<T>::contains_key(id),

          TaskId::CollectCoins(id) => CollectedCoins::<T>::contains_key(id),

        } {

          log::debug!("Already handled Task ({:?}, {:?})", deadline, id);

          guard.forget();

          continue;

        }

        let result = task.verify_ocw::<T>();

        log::trace!(target: "OCW", "@{block_number:?} Task {:8?}", id);

        match result {

          Ok(task_data) => {

            let output = task_data.into_output::<T>();

            match Self::submit_txn_with_synced_nonce(auth_id.clone(), |_| {

              Call::persist_task_output { deadline, task_output: output.clone() }

            }) {

              Ok(_) => guard.forget(),

              Err(e) => {

                log::error!(

                  "Failed to send persist dispatchable transaction: {:?}",

                  e

                )

              },

            }

          },

          Err((task, ocw::OffchainError::InvalidTask(cause))) => {

            log::warn!("Failed to verify pending task {:?} : {:?}", task, cause);

            if cause.is_fatal() {

              match Self::submit_txn_with_synced_nonce(auth_id.clone(), |_| {

                Call::fail_task { deadline, task_id: id.clone(), cause }

              }) {

                Err(e) => log::error!(

                  "Failed to send fail dispatchable transaction: {:?}",

                  e

                ),

                Ok(_) => guard.forget(),

              }

            }

          },

          Err(error) => {

            log::error!("Task verification encountered an error {:?}", error);

          },

        }

      }

    }

    fn on_runtime_upgrade() -> Weight {

      migrations::migrate::<T>()

    }

  }

  #[pallet::
c1
all]

  impl<T: Config> Pallet<T> {

    /// Claims legacy wallet and transfers the balance to the sender's account.

    #[pallet::weight(<T as Config>::WeightInfo::claim_legacy_wallet())]

    pub fn claim_legacy_wallet(

      origin: OriginFor<T>,

      public_key: sp_core::ecdsa::Public,

    ) -> DispatchResultWithPostInfo {

      let who = ensure_signed(origin)
?0
;

      let account_id_of_key = T::Signer::from(public_key.clone()).into_account();

      ensure!(account_id_of_key == who, 
Error::<T>::NotLegacyWalletOwner0
);

      let sighash = LegacySighash::from(&public_key);

      let legacy_balance =

        LegacyWallets::<T>::get(&sighash).ok_or(Error::<T>::LegacyWalletNotFound)
?0
;

      let legacy_keeper =

        LegacyBalanceKeeper::<T>::get().ok_or(Error::<T>::LegacyBalanceKeeperMissing)
?0
;

      <pallet_balances::Pallet<T> as CurrencyT<T::AccountId>>::transfer(

        &legacy_keeper,

        &who,

        legacy_balance,

        ExistenceRequirement::AllowDeath,

      )
?0
;

      LegacyWallets::<T>::remove(&sighash);

      Self::deposit_event(Event::<T>::LegacyWalletClaimed(who, sighash, legacy_balance));

      Ok(PostDispatchInfo { actual_weight: None, pays_fee: Pays::No })

    }

    /// Registers an external address on `blockchain` and `network` with value `address`

    #[pallet::weight(<T as Config>::WeightInfo::register_address())]

    pub fn register_address(

      origin: OriginFor<T>,

      blockchain: Blockchain,

      address: ExternalAddress,

      ownership_proof: sp_core::ecdsa::Signature,

    ) -> DispatchResult {

      let 
who426
 = ensure_signed(origin)
?1
;

      let message = sp_io::hashing::sha2_256(who.encode().as_slice());

      let message = &sp_io::hashing::blake2_256(message.as_ref());

      let signature = <[u8; 65]>::from(ownership_proof);

      let 
raw_pubkey425
 = secp256k1_ecdsa_recover_compressed(&signature, message)

        .map_err(|_| 
Error::<T>::InvalidSignature1
)
?1
;

      let 
recreated_address424
 = helpers::generate_external_address(

        &blockchain,

        &address,

        sp_core::ecdsa::Public::from_raw(raw_pubkey),

      )

      .ok_or(Error::<T>::AddressFormatNotSupported)
?1
;

      ensure!(recreated_address == address, 
Error::<T>::OwnershipNotSatisfied1
);

      let address_id = AddressId::new::<T>(&blockchain, &address);

      ensure!(

        !Addresses::<T>::contains_key(&address_id),

        Error::<T>::AddressAlreadyRegistered

      );

      // note: this error condition is unreachable!

      // AddressFormatNotSupported or OwnershipNotSatisfied will error out first

      ensure!(

        helpers::address_is_well_formed(&blockchain, &address),

        Error::<T>::MalformedExternalAddress

      );

      let entry = Address { blockchain, value: address, owner: who };

      Self::deposit_event(Event::<T>::AddressRegistered(address_id.clone(), entry.clone()));

      <Addresses<T>>::insert(address_id, entry);

      Ok(())

    }

    #[pallet::weight(<T as Config>::WeightInfo::add_ask_order())]

    pub fn add_ask_order(

      origin: OriginFor<T>,

      address_id: AddressId<T::Hash>,

      terms: LoanTerms<T::Hash>,

      expiration_block: BlockNumberFor<T>,

      guid: Guid,

    ) -> DispatchResult {

      let who = ensure_signed(origin)
?0
;

      let head = Self::block_number();

      ensure!(expiration_block >= head, 
Error::<T>::AskOrderExpired1
);

      let ask_order_id = AskOrderId::new::<T>(expiration_block, &guid);

      ensure!(!AskOrders::<T>::contains_id(&ask_order_id), 
Error::<T>::DuplicateId1
);

      let address = Self::get_address(&address_id)
?0
;

      ensure!(address.owner == who, 
Error::<T>::NotAddressOwner0
);

      let currency =

        Currencies::<T>::get(&terms.currency).ok_or(Error::<T>::CurrencyNotRegistered)
?2
;

      ensure!(

        address.blockchain == currency.blockchain(),

        Error::<T>::AddressBlockchainMismatch

      );

      Self::use_guid(&guid)
?2
;

      let ask_order = AskOrder {

        lender_address_id: address_id,

        terms: terms.try_into().map_err(Error::<T>::from)
?0
,

        expiration_block,

        block: <frame_system::Pallet<T>>::block_number(),

        lender: who,

      };

      Self::deposit_event(Event::<T>::AskOrderAdded(ask_order_id.clone(), ask_order.clone()));

      AskOrders::<T>::insert_id(ask_order_id, ask_order);

      Ok(())

    }

    #[pallet::weight(<T as Config>::WeightInfo::add_bid_order())]

    pub fn add_bid_order(

      origin: OriginFor<T>,

      address_id: AddressId<T::Hash>,

      terms: LoanTerms<T::Hash>,

      expiration_block: BlockNumberFor<T>,

      guid: Guid,

    ) -> DispatchResult {

      let who = ensure_signed(origin)
?0
;

      let head = Self::block_number();

      ensure!(expiration_block >= head, 
Error::<T>::BidOrderExpired1
);

      let bid_order_id = BidOrderId::new::<T>(expiration_block, &guid);

      ensure!(!BidOrders::<T>::contains_id(&bid_order_id), 
Error::<T>::DuplicateId1
);

      let address = Self::get_address(&address_id)
?0
;

      ensure!(address.owner == who, 
Error::<T>::NotAddressOwner0
);

      let currency =

        Currencies::<T>::get(&terms.currency).ok_or(Error::<T>::CurrencyNotRegistered)
?1
;

      ensure!(

        address.blockchain == currency.blockchain(),

        Error::<T>::AddressBlockchainMismatch

      );

      Self::use_guid(&guid)
?0
;

      let bid_order = BidOrder {

        borrower_address_id: address_id,

        terms: terms.try_into().map_err(Error::<T>::from)
?1
,

        expiration_block,

        block: <frame_system::Pallet<T>>::block_number(),

        borrower: who,

      };

      Self::deposit_event(Event::<T>::BidOrderAdded(bid_order_id.clone(), bid_order.clone()));

      BidOrders::<T>::insert_id(bid_order_id, bid_order);

      Ok(())

    }

    #[pallet::weight(<T as Config>::WeightInfo::add_offer())]

    pub fn add_offer(

      origin: OriginFor<T>,

      ask_order_id: AskOrderId<T::BlockNumber, T::Hash>,

      bid_order_id: BidOrderId<T::BlockNumber, T::Hash>,

      expiration_block: BlockNumberFor<T>,

    ) -> DispatchResult {

      let who = ensure_signed(origin)
?0
;

      let ask_order = try_get_id!(AskOrders<T>, &ask_order_id, NonExistentAskOrder)
?0
;

      ensure!(ask_order.lender == who, 
Error::<T>::NotLender0
);

      let head = Self::block_number();

      ensure!(ask_order.expiration_block >= head, 
Error::<T>::AskOrderExpired0
);

      let bid_order = try_get_id!(BidOrders<T>, &bid_order_id, NonExistentBidOrder)
?0
;

      ensure!(bid_order.borrower != who, 
Error::<T>::SameOwner0
);

      ensure!(bid_order.expiration_block >= head, 
Error::<T>::BidOrderExpired0
);

      let lender_address = Self::get_address(&ask_order.lender_address_id)
?0
;

      let borrower_address = Self::get_address(&bid_order.borrower_address_id)
?0
;

      ensure!(

        lender_address.blockchain == borrower_address.blockchain,

        Error::<T>::AddressBlockchainMismatch

      );

      ensure!(ask_order.terms.match_with(&bid_order.terms), 
Error::<T>::AskBidMismatch0
);

      let offer_id = OfferId::new::<T>(expiration_block, &ask_order_id, &bid_order_id);

      ensure!(!Offers::<T>::contains_id(&offer_id), 
Error::<T>::DuplicateOffer1
);

      let offer = Offer {

        ask_id: ask_order_id,

        bid_id: bid_order_id,

        block: Self::block_number(),

        expiration_block,

        lender: who,

      };

      Self::deposit_event(Event::<T>::OfferAdded(offer_id.clone(), offer.clone()));