public void DemonstrateCreationOfBond()
{
// CREATE the flow conventions for bond
var flowConventions = new FlowConventions(
scope: null,
code: null,
currency: "GBP",
paymentFrequency: "6M",
rollConvention: "MF",
dayCountConvention: "Act365",
paymentCalendars: new List <string>(),
resetCalendars: new List <string>(),
settleDays: 2,
resetDays: 2
);
var bond = new Bond(
startDate: new DateTimeOffset(2020, 2, 7, 0, 0, 0, TimeSpan.Zero),
maturityDate: new DateTimeOffset(2020, 9, 18, 0, 0, 0, TimeSpan.Zero),
domCcy: "GBP",
principal: 100m,
couponRate: 0.05m,
flowConventions: flowConventions,
identifiers: new Dictionary <string, string>(),
instrumentType: LusidInstrument.InstrumentTypeEnum.Bond
);
// ASSERT that it was created
Assert.That(bond, Is.Not.Null);
// CAN NOW UPSERT TO LUSID
string uniqueId = "id-bond-1";
UpsertOtcToLusid(bond, "some-name-for-this-bond", uniqueId);
// CAN NOW QUERY FROM LUSID
var retrieved = QueryOtcFromLusid(uniqueId);
Assert.That(retrieved.InstrumentType == LusidInstrument.InstrumentTypeEnum.Bond);
var roundTripBond = retrieved as Bond;
Assert.That(roundTripBond, Is.Not.Null);
Assert.That(roundTripBond.Principal, Is.EqualTo(bond.Principal));
Assert.That(roundTripBond.CouponRate, Is.EqualTo(bond.CouponRate));
Assert.That(roundTripBond.DomCcy, Is.EqualTo(bond.DomCcy));
Assert.That(roundTripBond.MaturityDate, Is.EqualTo(bond.MaturityDate));
Assert.That(roundTripBond.StartDate, Is.EqualTo(bond.StartDate));
Assert.That(roundTripBond.FlowConventions.Currency, Is.EqualTo(bond.FlowConventions.Currency));
Assert.That(roundTripBond.FlowConventions.PaymentFrequency, Is.EqualTo(bond.FlowConventions.PaymentFrequency));
Assert.That(roundTripBond.FlowConventions.ResetDays, Is.EqualTo(bond.FlowConventions.ResetDays));
Assert.That(roundTripBond.FlowConventions.SettleDays, Is.EqualTo(bond.FlowConventions.SettleDays));
Assert.That(roundTripBond.FlowConventions.PaymentCalendars.Count, Is.EqualTo(bond.FlowConventions.PaymentCalendars.Count));
Assert.That(roundTripBond.FlowConventions.PaymentCalendars, Is.EquivalentTo(bond.FlowConventions.PaymentCalendars));
}
public void UpsertConventions()
{
string scope = "TestConventionsScope";
string flowConventionsCode = "GBP-6M";
string indexConventionCode = "GBP-6M-Libor";
// CREATE the flow conventions, index convention for swap
var flowConventions = new FlowConventions(
scope: scope,
code: flowConventionsCode,
currency: "GBP",
paymentFrequency: "6M",
rollConvention: "ModifiedFollowing",
dayCountConvention: "Actual365",
paymentCalendars: new List <string>(),
resetCalendars: new List <string>(),
settleDays: 2,
resetDays: 2
);
var indexConvention = new IndexConvention(
scope: scope,
code: indexConventionCode,
publicationDayLag: 0,
currency: "GBP",
paymentTenor: "6M",
dayCountConvention: "Actual365",
fixingReference: "BP00"
);
var flowConventionsResponse = _conventionsApi.UpsertFlowConventions(new UpsertFlowConventionsRequest(flowConventions));
Assert.That(flowConventionsResponse, Is.Not.Null);
Assert.That(flowConventionsResponse.Value, Is.Not.Null);
var indexConventionsResponse = _conventionsApi.UpsertIndexConvention(new UpsertIndexConventionRequest(indexConvention));
Assert.That(indexConventionsResponse, Is.Not.Null);
Assert.That(indexConventionsResponse.Value, Is.Not.Null);
var retrievedFlowConventions = _conventionsApi.GetFlowConventions(scope, flowConventionsCode);
Assert.That(retrievedFlowConventions, Is.Not.Null);
Assert.That(retrievedFlowConventions.Value.Scope, Is.EqualTo(flowConventions.Scope));
Assert.That(retrievedFlowConventions.Value.Code, Is.EqualTo(flowConventions.Code));
var retrievedIndexConvention = _conventionsApi.GetIndexConvention(scope, indexConventionCode);
Assert.That(retrievedIndexConvention, Is.Not.Null);
Assert.That(retrievedIndexConvention.Value.Scope, Is.EqualTo(indexConvention.Scope));
Assert.That(retrievedIndexConvention.Value.Code, Is.EqualTo(indexConvention.Code));
}
public void DemonstrateCreationOfSwaption()
{
// CREATE an Interest Rate Swap (IRS)
var startDate = new DateTimeOffset(2020, 2, 7, 0, 0, 0, TimeSpan.Zero);
var maturityDate = new DateTimeOffset(2030, 2, 7, 0, 0, 0, TimeSpan.Zero);
// CREATE the flow conventions, index convention for swap
var flowConventions = new FlowConventions(
scope: null,
code: null,
currency: "GBP",
paymentFrequency: "6M",
rollConvention: FlowConventions.RollConventionEnum.MF,
dayCountConvention: FlowConventions.DayCountConventionEnum.Act365,
holidayCalendars: new List <string>(),
settleDays: 2,
resetDays: 2
);
var idxConvention = new IndexConvention(
code: "GbpLibor6m",
publicationDayLag: 0,
currency: "GBP",
paymentTenor: "6M",
dayCountConvention: IndexConvention.DayCountConventionEnum.Act365,
fixingReference: "BP00"
);
// CREATE the leg definitions
var fixedLegDef = new LegDefinition(
rateOrSpread: 0.05m, // fixed leg rate (swap rate)
stubType: LegDefinition.StubTypeEnum.Front,
payReceive: LegDefinition.PayReceiveEnum.Pay,
notionalExchangeType: LegDefinition.NotionalExchangeTypeEnum.None,
conventions: flowConventions
);
var floatLegDef = new LegDefinition(
rateOrSpread: 0.002m, // float leg spread over curve rate, often zero
stubType: LegDefinition.StubTypeEnum.Front,
payReceive: LegDefinition.PayReceiveEnum.Pay,
notionalExchangeType: LegDefinition.NotionalExchangeTypeEnum.None,
conventions: flowConventions,
indexConvention: idxConvention
);
// CREATE the fixed leg
var fixedLeg = new FixedLeg(
notional: 100m,
startDate: startDate,
maturityDate: maturityDate,
legDefinition: fixedLegDef,
instrumentType: LusidInstrument.InstrumentTypeEnum.FixedLeg
);
// CREATE the floating leg
var floatLeg = new FloatingLeg(
notional: 100m,
startDate: startDate,
maturityDate: maturityDate,
legDefinition: floatLegDef,
instrumentType: LusidInstrument.InstrumentTypeEnum.FloatingLeg
);
var swap = new InterestRateSwap(
startDate: startDate,
maturityDate: maturityDate,
legs: new List <InstrumentLeg>
{
floatLeg,
fixedLeg
},
instrumentType: LusidInstrument.InstrumentTypeEnum.InterestRateSwap
);
// CREATE swaption to upsert to LUSID
var swaption = new InterestRateSwaption(
startDate: new DateTimeOffset(2020, 1, 15, 0, 0, 0, TimeSpan.Zero),
payOrReceiveFixed: InterestRateSwaption.PayOrReceiveFixedEnum.Pay,
deliveryMethod: InterestRateSwaption.DeliveryMethodEnum.Cash,
swap: swap,
instrumentType: LusidInstrument.InstrumentTypeEnum.InterestRateSwaption);
// ASSERT that it was created
Assert.That(swaption, Is.Not.Null);
Assert.That(swaption.Swap, Is.Not.Null);
// CAN NOW UPSERT TO LUSID
string uniqueId = "id-swaption-1";
UpsertOtcToLusid(swaption, "some-name-for-this-swaption", uniqueId);
// CAN NOW QUERY FROM LUSID
var retrieved = QueryOtcFromLusid(uniqueId);
Assert.That(retrieved.InstrumentType == LusidInstrument.InstrumentTypeEnum.InterestRateSwaption);
var roundTripSwaption = retrieved as InterestRateSwaption;
Assert.That(roundTripSwaption, Is.Not.Null);
Assert.That(roundTripSwaption.DeliveryMethod, Is.EqualTo(swaption.DeliveryMethod));
Assert.That(roundTripSwaption.StartDate, Is.EqualTo(swaption.StartDate));
Assert.That(roundTripSwaption.PayOrReceiveFixed, Is.EqualTo(swaption.PayOrReceiveFixed));
Assert.That(roundTripSwaption.Swap, Is.Not.Null);
Assert.That(roundTripSwaption.Swap.InstrumentType, Is.EqualTo(LusidInstrument.InstrumentTypeEnum.InterestRateSwap));
}
public void DemonstrateCreationOfSwap()
{
// CREATE an Interest Rate Swap (IRS) (that can then be upserted into LUSID)
var startDate = new DateTimeOffset(2020, 2, 7, 0, 0, 0, TimeSpan.Zero);
var maturityDate = new DateTimeOffset(2030, 2, 7, 0, 0, 0, TimeSpan.Zero);
// CREATE the flow conventions, index convention
var flowConventions = new FlowConventions(
scope: null,
code: null,
currency: "GBP",
paymentFrequency: "6M",
rollConvention: "MF",
dayCountConvention: "Act365",
paymentCalendars: new List <string>(),
resetCalendars: new List <string>(),
settleDays: 2,
resetDays: 2
);
var idxConvention = new IndexConvention(
code: "GbpLibor6m",
publicationDayLag: 0,
currency: "GBP",
paymentTenor: "6M",
dayCountConvention: "Act365",
fixingReference: "BP00"
);
// CREATE the leg definitions
var fixedLegDef = new LegDefinition(
rateOrSpread: 0.05m, // fixed leg rate (swap rate)
stubType: "Front",
payReceive: "Pay",
notionalExchangeType: "None",
conventions: flowConventions
);
var floatLegDef = new LegDefinition(
rateOrSpread: 0.002m, // float leg spread over curve rate, often zero
stubType: "Front",
payReceive: "Pay",
notionalExchangeType: "None",
conventions: flowConventions,
indexConvention: idxConvention
);
// CREATE the fixed leg
var fixedLeg = new FixedLeg(
notional: 100m,
startDate: startDate,
maturityDate: maturityDate,
legDefinition: fixedLegDef,
instrumentType: LusidInstrument.InstrumentTypeEnum.FixedLeg
);
// CREATE the floating leg
var floatLeg = new FloatingLeg(
notional: 100m,
startDate: startDate,
maturityDate: maturityDate,
legDefinition: floatLegDef,
instrumentType: LusidInstrument.InstrumentTypeEnum.FloatingLeg
);
var irs = new InterestRateSwap(
startDate: startDate,
maturityDate: maturityDate,
legs: new List <InstrumentLeg>
{
floatLeg,
fixedLeg
},
instrumentType: LusidInstrument.InstrumentTypeEnum.InterestRateSwap
);
// ASSERT that it was created
Assert.That(irs, Is.Not.Null);
// CAN NOW UPSERT TO LUSID
string uniqueId = "id-swap-1";
UpsertOtcToLusid(irs, "some-name-for-this-swap", uniqueId);
// CAN NOW QUERY FROM LUSID
var retrieved = QueryOtcFromLusid(uniqueId);
Assert.That(retrieved.InstrumentType == LusidInstrument.InstrumentTypeEnum.InterestRateSwap);
var retrSwap = retrieved as InterestRateSwap;
Assert.That(retrSwap, Is.Not.Null);
Assert.That(retrSwap.MaturityDate, Is.EqualTo(irs.MaturityDate));
Assert.That(retrSwap.StartDate, Is.EqualTo(irs.StartDate));
Assert.That(retrSwap.Legs.Count, Is.EqualTo(irs.Legs.Count));
}
