DDD (Domain Driven Design) Can I use inheritance ?

Consider the following example:

• We have Order, and any order can be of diffrent types.
• The order has transactions, and each type of order can assign n-transaction.

For example:

OrderA must have one transaction.

OrderB must have two transaction.

OrderC can have n-transaction.

When we update the value of the Order, we need calculate the value of the transaction according to the algorithm -specific order type.

How can we design a model for this case ? Can we use inheritance in aggregateRoot or maybe we should use composition ? For Example ?

 /// <summary>
///     AggregateRoot
/// </summary>
public abstract class Order
{
    protected ISet<Transaction> _transactions;

    public IEnumerable<Transaction> Transactions
    {
        get { return _transactions; }
    }

    public abstract OrderType OrderType { get; }
    public decimal? Value { get; protected set; }

    public void SetValue(decimal? value)
    {
        Value = value;
        UpdateReleatedTransaction();
    }

    protected abstract void UpdateReleatedTransaction();
}

public class OrderA : Order
{
    public OrderA()
    {
        _transactions.Add(new Transaction(this));
    }

    public override OrderType OrderType
    {
        get { return OrderType.OrderTypeA; }
    }

    protected override void UpdateReleatedTransaction()
    {
        EnumerableExtensions.ForEach(_transactions, tran => { tran.SetValue(Value); });
    }
}

public class OrderB : Order
{
    public OrderB()
    {
        _transactions.Add(new Transaction(this)
        {
            Status = Status.Open
        });
        _transactions.Add(new Transaction(this)
        {
            Status = Status.Close
        });
    }

    public override OrderType OrderType
    {
        get { return OrderType.OrderTypeB; }
    }

    protected override void UpdateReleatedTransaction()
    {
        EnumerableExtensions.ForEach(_transactions, tran =>
        {
            if (tran.Status == Status.Open)
                tran.SetValue(Value);
            if (tran.Status == Status.Close)
                tran.SetValue(-1*Value);
        });
    }
}