/home/runner/work/creditcoin/creditcoin/pallets/creditcoin/src/migrations/v3.rs

Source (jump to first uncovered line)
// `interest_type` added to `LoanTerms`

use super::v2;
use codec::{Decode, Encode};
use frame_support::dispatch::Weight;
use frame_support::{generate_storage_alias, traits::Get, Identity, Twox64Concat};

use crate::{AddressId, Config, Duration, ExternalAmount, OfferId, TransferId};

pub use v2::AskOrder as OldAskOrder;
pub use v2::AskTerms as OldAskTerms;
pub use v2::BidOrder as OldBidOrder;
pub use v2::BidTerms as OldBidTerms;
pub use v2::Blockchain;
pub use v2::DealOrder as OldDealOrder;
pub use v2::InterestRate as OldInterestRate;
pub use v2::LoanTerms as OldLoanTerms;
pub use v2::{OrderId, Transfer, TransferKind};

use crate::InterestRate;

#[derive(Encode, Decode)]
#[cfg_attr(test, derive(Debug0, PartialEq, Eq))]
pub struct LoanTerms {
  pub amount: ExternalAmount,
  pub interest_rate: InterestRate,
  pub term_length: Duration,
}

#[derive(Encode, Decode)]
#[cfg_attr(test, derive(Debug0, PartialEq, Eq))]
pub struct AskTerms(pub(super) LoanTerms);
#[derive(Encode, Decode)]
#[cfg_attr(test, derive(Debug0, PartialEq, Eq))]
pub struct BidTerms(pub(super) LoanTerms);

#[derive(Encode3, Decode)]
#[cfg_attr(test, derive(Debug0, PartialEq, Eq))]
pub struct AskOrder<AccountId, BlockNum, Hash> {
  pub blockchain: Blockchain,
  pub lender_address_id: AddressId<Hash>,
  pub terms: AskTerms,
  pub expiration_block: BlockNum,
  pub block: BlockNum,
  pub lender: AccountId,
}

#[derive(Encode3, Decode)]
#[cfg_attr(test, derive(Debug0, PartialEq, Eq))]
pub struct BidOrder<AccountId, BlockNum, Hash> {
  pub blockchain: Blockchain,
  pub borrower_address_id: AddressId<Hash>,
  pub terms: BidTerms,
  pub expiration_block: BlockNum,
  pub block: BlockNum,
  pub borrower: AccountId,
}

#[derive(Encode, Decode)]
#[cfg_attr(test, derive(Debug0, PartialEq, Eq))]
pub struct DealOrder<AccountId, BlockNum, Hash, Moment> {
  pub blockchain: Blockchain,
  pub offer_id: OfferId<BlockNum, Hash>,
  pub lender_address_id: AddressId<Hash>,
  pub borrower_address_id: AddressId<Hash>,
  pub terms: LoanTerms,
  pub expiration_block: BlockNum,
  pub timestamp: Moment,
  pub block: Option<BlockNum>,
  pub funding_transfer_id: Option<TransferId<Hash>>,
  pub repayment_transfer_id: Option<TransferId<Hash>>,
  pub lock: Option<AccountId>,
  pub borrower: AccountId,
}

impl From<OldInterestRate> for InterestRate {
  fn from(old: OldInterestRate) -> Self {
    Self {
      decimals: old.decimals,
      rate_per_period: old.rate_per_period,
      period: old.period,
      interest_type: crate::InterestType::Simple,
    }
  }
}

impl From<OldLoanTerms> for LoanTerms {
  fn from(old: OldLoanTerms) -> Self {
    Self {
      amount: old.amount,
      interest_rate: InterestRate::from(old.interest_rate),
      term_length: old.term_length,
    }
  }
}

impl From<LoanTerms> for AskTerms {
  fn from(terms: LoanTerms) -> Self {
    Self(terms)
  }
}

impl From<LoanTerms> for BidTerms {
  fn from(terms: LoanTerms) -> Self {
    Self(terms)
  }
}

impl From<OldAskTerms> for AskTerms {
  fn from(old: OldAskTerms) -> Self {
    AskTerms(LoanTerms::from(old.0))
  }
}

impl From<OldBidTerms> for BidTerms {
  fn from(old: OldBidTerms) -> Self {
    BidTerms(LoanTerms::from(old.0))
  }
}

generate_storage_alias!(
  Creditcoin,
  DealOrders<T: Config> => DoubleMap<(Twox64Concat, T::BlockNumber), (Identity, T::Hash), DealOrder<T::AccountId, T::BlockNumber, T::Hash, T::Moment>>
);

generate_storage_alias!(
  Creditcoin,
  AskOrders<T: Config> => DoubleMap<(Twox64Concat, T::BlockNumber), (Identity, T::Hash), AskOrder<T::AccountId, T::BlockNumber, T::Hash>>
);

generate_storage_alias!(
  Creditcoin,
  BidOrders<T: Config> => DoubleMap<(Twox64Concat, T::BlockNumber), (Identity, T::Hash), BidOrder<T::AccountId, T::BlockNumber, T::Hash>>
);

pub(crate) fn migrate<T: Config>() -> Weight {
  let mut weight: Weight = 0;
  let weight_each = T::DbWeight::get().reads_writes(1, 1);

  DealOrders::<T>::translate::<OldDealOrder<T::AccountId, T::BlockNumber, T::Hash, T::Moment>, _>(
    |_exp, _hash, old_deal| {
      weight = weight.saturating_add(weight_each);
      Some(DealOrder {
        blockchain: old_deal.blockchain,
        offer_id: old_deal.offer_id,
        lender_address_id: old_deal.lender_address_id,
        borrower_address_id: old_deal.borrower_address_id,
        terms: LoanTerms::from(old_deal.terms),
        expiration_block: old_deal.expiration_block,
        timestamp: old_deal.timestamp,
        block: old_deal.block,
        funding_transfer_id: old_deal.funding_transfer_id,
        repayment_transfer_id: old_deal.repayment_transfer_id,
        lock: old_deal.lock,
        borrower: old_deal.borrower,
      })
    },
  );

  AskOrders::<T>::translate::<OldAskOrder<T::AccountId, T::BlockNumber, T::Hash>, _>(
    |_exp, _hash, old_ask| {
      weight = weight.saturating_add(weight_each);
      Some(AskOrder {
        blockchain: old_ask.blockchain,
        lender_address_id: old_ask.lender_address_id,
        terms: AskTerms::from(old_ask.terms),
        expiration_block: old_ask.expiration_block,
        block: old_ask.block,
        lender: old_ask.lender,
      })
    },
  );

  BidOrders::<T>::translate::<OldBidOrder<T::AccountId, T::BlockNumber, T::Hash>, _>(
    |_exp, _hash, old_bid| {
      weight = weight.saturating_add(weight_each);
      Some(BidOrder {
        blockchain: old_bid.blockchain,
        borrower_address_id: old_bid.borrower_address_id,
        terms: BidTerms::from(old_bid.terms),
        expiration_block: old_bid.expiration_block,
        block: old_bid.block,
        borrower: old_bid.borrower,
      })
    },
  );

  weight
}

#[cfg(test)]
mod tests {
  use core::convert::TryFrom;

  use crate::{
    mock::{ExtBuilder, Test},
    tests::TestInfo,
    AskOrderId, BidOrderId, DealOrderId, DoubleMapExt, Duration, InterestRate, OfferId,
  };

  use super::{
    generate_storage_alias, AskOrder, AskTerms, BidOrder, BidTerms, Blockchain, Config,
    DealOrder, Identity, LoanTerms, OldAskOrder, OldAskTerms, OldBidOrder, OldBidTerms,
    OldDealOrder, OldInterestRate, OldLoanTerms, Twox64Concat,
  };

  generate_storage_alias!(
    Creditcoin,
    DealOrders<T: Config> => DoubleMap<(Twox64Concat, T::BlockNumber), (Identity, T::Hash), OldDealOrder<T::AccountId, T::BlockNumber, T::Hash, T::Moment>>
  );

  type OldDealOrders = DealOrders<Test>;

  generate_storage_alias!(
    Creditcoin,
    AskOrders<T: Config> => DoubleMap<(Twox64Concat, T::BlockNumber), (Identity, T::Hash), OldAskOrder<T::AccountId, T::BlockNumber, T::Hash>>
  );

  type OldAskOrders = AskOrders<Test>;

  generate_storage_alias!(
    Creditcoin,
    BidOrders<T: Config> => DoubleMap<(Twox64Concat, T::BlockNumber), (Identity, T::Hash), OldBidOrder<T::AccountId, T::BlockNumber, T::Hash>>
  );

  type OldBidOrders = BidOrders<Test>;

  #[test]
  fn ask_order_migrates() {
    ExtBuilder::default().build_and_execute(|| {
      let ask_order_id = AskOrderId::new::<Test>(100, "asdf".as_bytes());
      let test_info = TestInfo::new_defaults();

      let old_ask_order = OldAskOrder {
        blockchain: Blockchain::Ethereum,
        lender_address_id: test_info.lender.address_id,
        terms: OldAskTerms(OldLoanTerms {
          amount: 100u64.into(),
          interest_rate: OldInterestRate {
            rate_per_period: 100,
            decimals: 4,
            period: Duration::from_millis(1000),
          },
          term_length: Duration::from_millis(2000),
        }),
        expiration_block: 100,
        block: 1,
        lender: test_info.lender.account_id,
      };

      OldAskOrders::insert_id(&ask_order_id, &old_ask_order);

      super::migrate::<Test>();

      let ask_order = super::AskOrders::<Test>::try_get_id(&ask_order_id).unwrap();

      assert_eq!(
        ask_order,
        AskOrder {
          blockchain: old_ask_order.blockchain,
          lender_address_id: old_ask_order.lender_address_id,
          terms: AskTerms::try_from(LoanTerms {
            amount: old_ask_order.terms.0.amount,
            interest_rate: InterestRate {
              rate_per_period: old_ask_order.terms.0.interest_rate.rate_per_period,
              decimals: old_ask_order.terms.0.interest_rate.decimals,
              period: old_ask_order.terms.0.interest_rate.period,
              interest_type: crate::InterestType::Simple,
            },
            term_length: old_ask_order.terms.0.term_length,
          })
          .unwrap(),
          expiration_block: old_ask_order.expiration_block,
          block: old_ask_order.block,
          lender: old_ask_order.lender,
        }
      );
    });
  }

  #[test]
  fn bid_order_migrates() {
    ExtBuilder::default().build_and_execute(|| {
      let bid_order_id = BidOrderId::new::<Test>(100, "asdf".as_bytes());
      let test_info = TestInfo::new_defaults();

      let old_bid_order = OldBidOrder {
        blockchain: Blockchain::Ethereum,
        borrower_address_id: test_info.borrower.address_id,
        terms: OldBidTerms(OldLoanTerms {
          amount: 100u64.into(),
          interest_rate: OldInterestRate {
            rate_per_period: 100,
            decimals: 4,
            period: Duration::from_millis(1000),
          },
          term_length: Duration::from_millis(2000),
        }),
        expiration_block: 100,
        block: 1,
        borrower: test_info.borrower.account_id,
      };

      OldBidOrders::insert_id(&bid_order_id, &old_bid_order);

      super::migrate::<Test>();

      let bid_order = super::BidOrders::<Test>::try_get_id(&bid_order_id).unwrap();

      assert_eq!(
        bid_order,
        BidOrder {
          blockchain: old_bid_order.blockchain,
          borrower_address_id: old_bid_order.borrower_address_id,
          terms: BidTerms::try_from(LoanTerms {
            amount: old_bid_order.terms.0.amount,
            interest_rate: InterestRate {
              rate_per_period: old_bid_order.terms.0.interest_rate.rate_per_period,
              decimals: old_bid_order.terms.0.interest_rate.decimals,
              period: old_bid_order.terms.0.interest_rate.period,
              interest_type: crate::InterestType::Simple,
            },
            term_length: old_bid_order.terms.0.term_length,
          })
          .unwrap(),
          expiration_block: old_bid_order.expiration_block,
          block: old_bid_order.block,
          borrower: old_bid_order.borrower,
        }
      );
    });
  }

  #[test]
  fn deal_order_migrates() {
    ExtBuilder::default().build_and_execute(|| {
      let test_info = TestInfo::new_defaults();

      let deal_id = DealOrderId::with_expiration_hash::<Test>(100, [0u8; 32].into());
      let offer_id = OfferId::with_expiration_hash::<Test>(100, [1u8; 32].into());

      let old_deal = OldDealOrder {
        blockchain: Blockchain::Ethereum,
        offer_id,
        lender_address_id: test_info.lender.address_id,
        borrower_address_id: test_info.borrower.address_id,
        terms: OldLoanTerms {
          amount: 100u64.into(),
          interest_rate: OldInterestRate {
            rate_per_period: 100,
            decimals: 4,
            period: Duration::from_millis(2000),
          },
          term_length: Duration::from_millis(10000),
        },
        expiration_block: 100,
        timestamp: 0,
        funding_transfer_id: None,
        repayment_transfer_id: None,
        lock: None,
        block: None,
        borrower: test_info.borrower.account_id,
      };

      OldDealOrders::insert_id(&deal_id, &old_deal);

      super::migrate::<Test>();

      let deal = super::DealOrders::<Test>::try_get_id(&deal_id).unwrap();

      assert_eq!(
        deal,
        DealOrder {
          blockchain: old_deal.blockchain,
          offer_id: old_deal.offer_id,
          lender_address_id: old_deal.lender_address_id,
          borrower_address_id: old_deal.borrower_address_id,
          terms: LoanTerms {
            amount: old_deal.terms.amount,
            interest_rate: InterestRate {
              rate_per_period: old_deal.terms.interest_rate.rate_per_period,
              decimals: old_deal.terms.interest_rate.decimals,
              period: old_deal.terms.interest_rate.period,
              interest_type: crate::InterestType::Simple
            },
            term_length: old_deal.terms.term_length,
          },
          expiration_block: old_deal.expiration_block,
          timestamp: old_deal.timestamp,
          funding_transfer_id: old_deal.funding_transfer_id,
          repayment_transfer_id: old_deal.repayment_transfer_id,
          lock: old_deal.lock,
          borrower: old_deal.borrower,
          block: old_deal.block,
        }
      );
    });
  }
}

Coverage Report

Created: 2022-11-10 19:56

Line	Count	Source (jump to first uncovered line)
1		// `interest_type` added to `LoanTerms`
2
3		use super::v2;
4		use codec::{Decode, Encode};
5		use frame_support::dispatch::Weight;
6		use frame_support::{generate_storage_alias, traits::Get, Identity, Twox64Concat};
7
8		use crate::{AddressId, Config, Duration, ExternalAmount, OfferId, TransferId};
9
10		pub use v2::AskOrder as OldAskOrder;
11		pub use v2::AskTerms as OldAskTerms;
12		pub use v2::BidOrder as OldBidOrder;
13		pub use v2::BidTerms as OldBidTerms;
14		pub use v2::Blockchain;
15		pub use v2::DealOrder as OldDealOrder;
16		pub use v2::InterestRate as OldInterestRate;
17		pub use v2::LoanTerms as OldLoanTerms;
18		pub use v2::{OrderId, Transfer, TransferKind};
19
20		use crate::InterestRate;
21
22	11	#[derive(Encode, Decode)]
23	3	#[cfg_attr(test, derive( Debug0 , PartialEq, Eq))]
24		pub struct LoanTerms {
25		pub amount: ExternalAmount,
26		pub interest_rate: InterestRate,
27		pub term_length: Duration,
28		}
29
30	3	#[derive(Encode, Decode)]
31	1	#[cfg_attr(test, derive( Debug0 , PartialEq, Eq))]
32	3	pub struct AskTerms(pub(super) LoanTerms);
33	3	#[derive(Encode, Decode)]
34	1	#[cfg_attr(test, derive( Debug0 , PartialEq, Eq))]
35	3	pub struct BidTerms(pub(super) LoanTerms);
36
37	6	#[derive( Encode3 , Decode)]
38	1	#[cfg_attr(test, derive( Debug0 , PartialEq, Eq))]
39		pub struct AskOrder<AccountId, BlockNum, Hash> {
40		pub blockchain: Blockchain,
41		pub lender_address_id: AddressId<Hash>,
42		pub terms: AskTerms,
43		pub expiration_block: BlockNum,
44		pub block: BlockNum,
45		pub lender: AccountId,
46		}
47
48	6	#[derive( Encode3 , Decode)]
49	1	#[cfg_attr(test, derive( Debug0 , PartialEq, Eq))]
50		pub struct BidOrder<AccountId, BlockNum, Hash> {
51		pub blockchain: Blockchain,
52		pub borrower_address_id: AddressId<Hash>,
53		pub terms: BidTerms,
54		pub expiration_block: BlockNum,
55		pub block: BlockNum,
56		pub borrower: AccountId,
57		}
58
59	5	#[derive(Encode, Decode)]
60	1	#[cfg_attr(test, derive( Debug0 , PartialEq, Eq))]
61		pub struct DealOrder<AccountId, BlockNum, Hash, Moment> {
62		pub blockchain: Blockchain,
63		pub offer_id: OfferId<BlockNum, Hash>,
64		pub lender_address_id: AddressId<Hash>,
65		pub borrower_address_id: AddressId<Hash>,
66		pub terms: LoanTerms,
67		pub expiration_block: BlockNum,
68		pub timestamp: Moment,
69		pub block: Option<BlockNum>,
70		pub funding_transfer_id: Option<TransferId<Hash>>,
71		pub repayment_transfer_id: Option<TransferId<Hash>>,
72		pub lock: Option<AccountId>,
73		pub borrower: AccountId,
74		}
75
76		impl From<OldInterestRate> for InterestRate {
77	3	fn from(old: OldInterestRate) -> Self {
78	3	Self {
79	3	decimals: old.decimals,
80	3	rate_per_period: old.rate_per_period,
81	3	period: old.period,
82	3	interest_type: crate::InterestType::Simple,
83	3	}
84	3	}
85		}
86
87		impl From<OldLoanTerms> for LoanTerms {
88	3	fn from(old: OldLoanTerms) -> Self {
89	3	Self {
90	3	amount: old.amount,
91	3	interest_rate: InterestRate::from(old.interest_rate),
92	3	term_length: old.term_length,
93	3	}
94	3	}
95		}
96
97		impl From<LoanTerms> for AskTerms {
98	1	fn from(terms: LoanTerms) -> Self {
99	1	Self(terms)
100	1	}
101		}
102
103		impl From<LoanTerms> for BidTerms {
104	1	fn from(terms: LoanTerms) -> Self {
105	1	Self(terms)
106	1	}
107		}
108
109		impl From<OldAskTerms> for AskTerms {
110	1	fn from(old: OldAskTerms) -> Self {
111	1	AskTerms(LoanTerms::from(old.0))
112	1	}
113		}
114
115		impl From<OldBidTerms> for BidTerms {
116	1	fn from(old: OldBidTerms) -> Self {
117	1	BidTerms(LoanTerms::from(old.0))
118	1	}
119		}
120
121		generate_storage_alias!(
122		Creditcoin,
123		DealOrders<T: Config> => DoubleMap<(Twox64Concat, T::BlockNumber), (Identity, T::Hash), DealOrder<T::AccountId, T::BlockNumber, T::Hash, T::Moment>>
124		);
125
126		generate_storage_alias!(
127		Creditcoin,
128		AskOrders<T: Config> => DoubleMap<(Twox64Concat, T::BlockNumber), (Identity, T::Hash), AskOrder<T::AccountId, T::BlockNumber, T::Hash>>
129		);
130
131		generate_storage_alias!(
132		Creditcoin,
133		BidOrders<T: Config> => DoubleMap<(Twox64Concat, T::BlockNumber), (Identity, T::Hash), BidOrder<T::AccountId, T::BlockNumber, T::Hash>>
134		);
135
136	3	pub(crate) fn migrate<T: Config>() -> Weight {
137	3	let mut weight: Weight = 0;
138	3	let weight_each = T::DbWeight::get().reads_writes(1, 1);
139	3
140	3	DealOrders::<T>::translate::<OldDealOrder<T::AccountId, T::BlockNumber, T::Hash, T::Moment>, _>(
141	3	\|_exp, _hash, old_deal\| {
142	1	weight = weight.saturating_add(weight_each);
143	1	Some(DealOrder {
144	1	blockchain: old_deal.blockchain,
145	1	offer_id: old_deal.offer_id,
146	1	lender_address_id: old_deal.lender_address_id,
147	1	borrower_address_id: old_deal.borrower_address_id,
148	1	terms: LoanTerms::from(old_deal.terms),
149	1	expiration_block: old_deal.expiration_block,
150	1	timestamp: old_deal.timestamp,
151	1	block: old_deal.block,
152	1	funding_transfer_id: old_deal.funding_transfer_id,
153	1	repayment_transfer_id: old_deal.repayment_transfer_id,
154	1	lock: old_deal.lock,
155	1	borrower: old_deal.borrower,
156	1	})
157	3	},
158	3	);
159	3
160	3	AskOrders::<T>::translate::<OldAskOrder<T::AccountId, T::BlockNumber, T::Hash>, _>(
161	3	\|_exp, _hash, old_ask\| {
162	1	weight = weight.saturating_add(weight_each);
163	1	Some(AskOrder {
164	1	blockchain: old_ask.blockchain,
165	1	lender_address_id: old_ask.lender_address_id,
166	1	terms: AskTerms::from(old_ask.terms),
167	1	expiration_block: old_ask.expiration_block,
168	1	block: old_ask.block,
169	1	lender: old_ask.lender,
170	1	})
171	3	},
172	3	);
173	3
174	3	BidOrders::<T>::translate::<OldBidOrder<T::AccountId, T::BlockNumber, T::Hash>, _>(
175	3	\|_exp, _hash, old_bid\| {
176	1	weight = weight.saturating_add(weight_each);
177	1	Some(BidOrder {
178	1	blockchain: old_bid.blockchain,
179	1	borrower_address_id: old_bid.borrower_address_id,
180	1	terms: BidTerms::from(old_bid.terms),
181	1	expiration_block: old_bid.expiration_block,
182	1	block: old_bid.block,
183	1	borrower: old_bid.borrower,
184	1	})
185	3	},
186	3	);
187	3
188	3	weight
189	3	}
190
191		#[cfg(test)]
192		mod tests {
193		use core::convert::TryFrom;
194
195		use crate::{
196		mock::{ExtBuilder, Test},
197		tests::TestInfo,
198		AskOrderId, BidOrderId, DealOrderId, DoubleMapExt, Duration, InterestRate, OfferId,
199		};
200
201		use super::{
202		generate_storage_alias, AskOrder, AskTerms, BidOrder, BidTerms, Blockchain, Config,
203		DealOrder, Identity, LoanTerms, OldAskOrder, OldAskTerms, OldBidOrder, OldBidTerms,
204		OldDealOrder, OldInterestRate, OldLoanTerms, Twox64Concat,
205		};
206
207		generate_storage_alias!(
208		Creditcoin,
209		DealOrders<T: Config> => DoubleMap<(Twox64Concat, T::BlockNumber), (Identity, T::Hash), OldDealOrder<T::AccountId, T::BlockNumber, T::Hash, T::Moment>>
210		);
211
212		type OldDealOrders = DealOrders<Test>;
213
214		generate_storage_alias!(
215		Creditcoin,
216		AskOrders<T: Config> => DoubleMap<(Twox64Concat, T::BlockNumber), (Identity, T::Hash), OldAskOrder<T::AccountId, T::BlockNumber, T::Hash>>
217		);
218
219		type OldAskOrders = AskOrders<Test>;
220
221		generate_storage_alias!(
222		Creditcoin,
223		BidOrders<T: Config> => DoubleMap<(Twox64Concat, T::BlockNumber), (Identity, T::Hash), OldBidOrder<T::AccountId, T::BlockNumber, T::Hash>>
224		);
225
226		type OldBidOrders = BidOrders<Test>;
227
228	1	#[test]
229	1	fn ask_order_migrates() {
230	1	ExtBuilder::default().build_and_execute(\|\| {
231	1	let ask_order_id = AskOrderId::new::<Test>(100, "asdf".as_bytes());
232	1	let test_info = TestInfo::new_defaults();
233	1
234	1	let old_ask_order = OldAskOrder {
235	1	blockchain: Blockchain::Ethereum,
236	1	lender_address_id: test_info.lender.address_id,
237	1	terms: OldAskTerms(OldLoanTerms {
238	1	amount: 100u64.into(),
239	1	interest_rate: OldInterestRate {
240	1	rate_per_period: 100,
241	1	decimals: 4,
242	1	period: Duration::from_millis(1000),
243	1	},
244	1	term_length: Duration::from_millis(2000),
245	1	}),
246	1	expiration_block: 100,
247	1	block: 1,
248	1	lender: test_info.lender.account_id,
249	1	};
250	1
251	1	OldAskOrders::insert_id(&ask_order_id, &old_ask_order);
252	1
253	1	super::migrate::<Test>();
254	1
255	1	let ask_order = super::AskOrders::<Test>::try_get_id(&ask_order_id).unwrap();
256	1
257	1	assert_eq!(
258	1	ask_order,
259	1	AskOrder {
260	1	blockchain: old_ask_order.blockchain,
261	1	lender_address_id: old_ask_order.lender_address_id,
262	1	terms: AskTerms::try_from(LoanTerms {
263	1	amount: old_ask_order.terms.0.amount,
264	1	interest_rate: InterestRate {
265	1	rate_per_period: old_ask_order.terms.0.interest_rate.rate_per_period,
266	1	decimals: old_ask_order.terms.0.interest_rate.decimals,
267	1	period: old_ask_order.terms.0.interest_rate.period,
268	1	interest_type: crate::InterestType::Simple,
269	1	},
270	1	term_length: old_ask_order.terms.0.term_length,
271	1	})
272	1	.unwrap(),
273	1	expiration_block: old_ask_order.expiration_block,
274	1	block: old_ask_order.block,
275	1	lender: old_ask_order.lender,
276	1	}
277	1	);
278	1	});
279	1	}
280
281	1	#[test]
282	1	fn bid_order_migrates() {
283	1	ExtBuilder::default().build_and_execute(\|\| {
284	1	let bid_order_id = BidOrderId::new::<Test>(100, "asdf".as_bytes());
285	1	let test_info = TestInfo::new_defaults();
286	1
287	1	let old_bid_order = OldBidOrder {
288	1	blockchain: Blockchain::Ethereum,
289	1	borrower_address_id: test_info.borrower.address_id,
290	1	terms: OldBidTerms(OldLoanTerms {
291	1	amount: 100u64.into(),
292	1	interest_rate: OldInterestRate {
293	1	rate_per_period: 100,
294	1	decimals: 4,
295	1	period: Duration::from_millis(1000),
296	1	},
297	1	term_length: Duration::from_millis(2000),
298	1	}),
299	1	expiration_block: 100,
300	1	block: 1,
301	1	borrower: test_info.borrower.account_id,
302	1	};
303	1
304	1	OldBidOrders::insert_id(&bid_order_id, &old_bid_order);
305	1
306	1	super::migrate::<Test>();
307	1
308	1	let bid_order = super::BidOrders::<Test>::try_get_id(&bid_order_id).unwrap();
309	1
310	1	assert_eq!(
311	1	bid_order,
312	1	BidOrder {
313	1	blockchain: old_bid_order.blockchain,
314	1	borrower_address_id: old_bid_order.borrower_address_id,
315	1	terms: BidTerms::try_from(LoanTerms {
316	1	amount: old_bid_order.terms.0.amount,
317	1	interest_rate: InterestRate {
318	1	rate_per_period: old_bid_order.terms.0.interest_rate.rate_per_period,
319	1	decimals: old_bid_order.terms.0.interest_rate.decimals,
320	1	period: old_bid_order.terms.0.interest_rate.period,
321	1	interest_type: crate::InterestType::Simple,
322	1	},
323	1	term_length: old_bid_order.terms.0.term_length,
324	1	})
325	1	.unwrap(),
326	1	expiration_block: old_bid_order.expiration_block,
327	1	block: old_bid_order.block,
328	1	borrower: old_bid_order.borrower,
329	1	}
330	1	);
331	1	});
332	1	}
333
334	1	#[test]
335	1	fn deal_order_migrates() {
336	1	ExtBuilder::default().build_and_execute(\|\| {
337	1	let test_info = TestInfo::new_defaults();
338	1
339	1	let deal_id = DealOrderId::with_expiration_hash::<Test>(100, [0u8; 32].into());
340	1	let offer_id = OfferId::with_expiration_hash::<Test>(100, [1u8; 32].into());
341	1
342	1	let old_deal = OldDealOrder {
343	1	blockchain: Blockchain::Ethereum,
344	1	offer_id,
345	1	lender_address_id: test_info.lender.address_id,
346	1	borrower_address_id: test_info.borrower.address_id,
347	1	terms: OldLoanTerms {
348	1	amount: 100u64.into(),
349	1	interest_rate: OldInterestRate {
350	1	rate_per_period: 100,
351	1	decimals: 4,
352	1	period: Duration::from_millis(2000),
353	1	},
354	1	term_length: Duration::from_millis(10000),
355	1	},
356	1	expiration_block: 100,
357	1	timestamp: 0,
358	1	funding_transfer_id: None,
359	1	repayment_transfer_id: None,
360	1	lock: None,
361	1	block: None,
362	1	borrower: test_info.borrower.account_id,
363	1	};
364	1
365	1	OldDealOrders::insert_id(&deal_id, &old_deal);
366	1
367	1	super::migrate::<Test>();
368	1
369	1	let deal = super::DealOrders::<Test>::try_get_id(&deal_id).unwrap();
370	1
371	1	assert_eq!(
372	1	deal,
373	1	DealOrder {
374	1	blockchain: old_deal.blockchain,
375	1	offer_id: old_deal.offer_id,
376	1	lender_address_id: old_deal.lender_address_id,
377	1	borrower_address_id: old_deal.borrower_address_id,
378	1	terms: LoanTerms {
379	1	amount: old_deal.terms.amount,
380	1	interest_rate: InterestRate {
381	1	rate_per_period: old_deal.terms.interest_rate.rate_per_period,
382	1	decimals: old_deal.terms.interest_rate.decimals,
383	1	period: old_deal.terms.interest_rate.period,
384	1	interest_type: crate::InterestType::Simple
385	1	},
386	1	term_length: old_deal.terms.term_length,
387	1	},
388	1	expiration_block: old_deal.expiration_block,
389	1	timestamp: old_deal.timestamp,
390	1	funding_transfer_id: old_deal.funding_transfer_id,
391	1	repayment_transfer_id: old_deal.repayment_transfer_id,
392	1	lock: old_deal.lock,
393	1	borrower: old_deal.borrower,
394	1	block: old_deal.block,
395	1	}
396	1	);
397	1	});
398	1	}
399		}