/// <summary> /// Pushes the number of stack items onto the stack. Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { opData.Push(OpHelper.IntToByteArray(opData.ItemCount)); error = null; return(true); }
/// <summary> /// Removes top three stack items and converts them to <see cref="long"/>s: value, Min, Max. /// Pushes 1 if value was in range, otherwise 0. /// Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.ItemCount < 3) { error = Err.OpNotEnoughItems; return(false); } // Stack is: x then min then max => pop max first byte[][] numbers = opData.Pop(3); if (!TryConvertToLong(numbers[2], out long max, opData.StrictNumberEncoding)) { error = "Invalid number format (max)."; return(false); } if (!TryConvertToLong(numbers[1], out long min, opData.StrictNumberEncoding)) { error = "Invalid number format (min)."; return(false); } if (!TryConvertToLong(numbers[0], out long x, opData.StrictNumberEncoding)) { error = "Invalid number format (x)."; return(false); } opData.Push(x >= min && x < max); error = null; return(true); }
/// <summary> /// Removes top three stack items and converts them to <see cref="long"/>s: value, Min, Max. /// Pushes 1 if value was in range, otherwise 0. /// Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.ItemCount < 3) { error = "Invalid number of elements in stack."; return(false); } // Stack is: x then min then max so we pop max first if (!OpHelper.TryConvertByteArrayToInt(opData.Pop(), out long max, true)) { error = "Couldn't convert to number."; return(false); } if (!OpHelper.TryConvertByteArrayToInt(opData.Pop(), out long min, true)) { error = "Couldn't convert to number."; return(false); } if (!OpHelper.TryConvertByteArrayToInt(opData.Pop(), out long x, true)) { error = "Couldn't convert to number."; return(false); } int c = (x >= min && x < max) ? 1 : 0; opData.Push(OpHelper.IntToByteArray(c)); error = null; return(true); }
/// <summary> /// Duplicates the top stack item. Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.ItemCount < 1) { error = Err.OpNotEnoughItems; return(false); } opData.Push(opData.Peek()); return(CheckItemCount(opData, out error)); }
/// <summary> /// Pushes the specified data of this instance at the top of the stack. /// </summary> /// <param name="opData">Stack to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (OpValue == OP._0) { opData.Push(new byte[0]); } else if (OpValue == OP.Negative1) { opData.Push(new byte[1] { 0b1000_0001 });
/// <summary> /// Replaces top two stack items interpreted as <see cref="long"/>s with their subtract result. Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (!TrySetValues(opData, out error)) { return(false); } opData.Push(OpHelper.IntToByteArray(a - b)); error = null; return(true); }
/// <summary> /// Replaces top two stack items interpreted as <see cref="long"/>s with 1 if first one was bigger or equal, otherwise with 0. /// Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (!TrySetValues(opData, out error)) { return(false); } opData.Push(a >= b); error = null; return(true); }
/// <summary> /// Removes top alt-stack item and puts it in stack. Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.AltItemCount < 1) { error = Err.OpNotEnoughItems + "(alt stack)"; return(false); } opData.Push(opData.AltPop()); error = null; return(true); }
/// <summary> /// Copies the second item from top of the stack to the top. Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.ItemCount < 2) { error = Err.OpNotEnoughItems; return(false); } byte[] data = opData.PeekAtIndex(1); opData.Push(data); return(CheckItemCount(opData, out error)); }
/// <summary> /// Pushes the size of the top stack item to the stack without removing the item. Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.ItemCount < 1) { error = Err.OpNotEnoughItems; return(false); } byte[] temp = opData.Peek(); opData.Push(IntToByteArray(temp.Length)); return(CheckItemCount(opData, out error)); }
/// <summary> /// Duplicates the top stack item. Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.ItemCount < 1) { error = "There was no item left in the stack to duplicate."; return(false); } opData.Push(opData.Peek()); error = null; return(true); }
/// <summary> /// Replaces top stack item with its hash digest. Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.ItemCount < 1) { error = "Not enough items in stack."; return(false); } opData.Push(Hash.ComputeHash(opData.Pop())); error = null; return(true); }
/// <summary> /// Removes top alt-stack item and puts it in stack. Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.AltItemCount < 1) { error = "There was not enough items left in the alt-stack to copy to stack."; return(false); } opData.Push(opData.AltPop()); error = null; return(true); }
/// <summary> /// Removes top two stack item and pushes (true for equality and false otherwiwe) onto the stack. Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.ItemCount < 2) { error = "There was not enough items left in the stack to check."; return(false); } byte[] item1 = opData.Pop(); byte[] item2 = opData.Pop(); if (item1.IsEqualTo(item2)) { opData.Push(new byte[] { 1 }); } else { opData.Push(new byte[0]); } error = null; return(true); }
/// <summary> /// Removes top two stack items (signature and public key) and verifies the transaction signature. /// </summary> /// <param name="opData">Stack to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { bool b = ExtractAndVerify(opData, out error); if (error is null) { opData.Push(b); return(true); } else { return(false); } }
/// <summary> /// Pushes the size of the top stack item to the stack. Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public bool Run(IOpData opData, out string error) { if (opData.ItemCount < 1) { error = "There was not enough items left in the stack."; return(false); } byte[] temp = opData.Peek(); opData.Push(OpHelper.IntToByteArray(temp.Length)); error = null; return(true); }
/// <summary> /// Swaps the position of top 2 items on top of the stack. Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.ItemCount < 2) { error = Err.OpNotEnoughItems; return(false); } byte[][] data = opData.Pop(2); opData.Push(new byte[2][] { data[1], data[0] }); error = null; return(true); }
/// <summary> /// Copies 2 items from stack to top of the stack like this: x1 x2 x3 x4 -> x1 x2 x3 x4 x1 x2 /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.ItemCount < 4) { error = Err.OpNotEnoughItems; return(false); } byte[] data1 = opData.PeekAtIndex(3); byte[] data2 = opData.PeekAtIndex(2); opData.Push(new byte[2][] { data1, data2 }); return(CheckItemCount(opData, out error)); }
/// <summary> /// Copies the second item from top of the stack to the top. Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.ItemCount < 2) { error = "There was not enough items left in the stack to copy over."; return(false); } byte[] data = opData.PeekAtIndex(1); opData.Push(data); error = null; return(true); }
/// <summary> /// Swaps the position of top 2 items on top of the stack. Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.ItemCount < 2) { error = "There was not enough items left in the stack to swap."; return(false); } byte[][] data = opData.Pop(2); opData.Push(new byte[2][] { data[1], data[0] }); error = null; return(true); }
/// <summary> /// Replaces top stack item with its hash digest. Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.ItemCount < 1) { error = Err.OpNotEnoughItems; return(false); } using Sha256 hash = new Sha256(); opData.Push(hash.ComputeHash(opData.Pop())); error = null; return(true); }
/// <summary> /// Replaces top two stack items interpreted as <see cref="long"/>s with the bigger of the two. /// Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (!TrySetValues(opData, out error)) { return(false); } long c = (a > b) ? a : b; opData.Push(IntToByteArray(c)); error = null; return(true); }
/// <summary> /// Replaces top two stack items interpreted as <see cref="long"/>s with 1 if either one is not 0, otherwise with 0. /// Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (!TrySetValues(opData, out error)) { return(false); } int c = (a != 0 || b != 0) ? 1 : 0; opData.Push(OpHelper.IntToByteArray(c)); error = null; return(true); }
/// <summary> /// Swaps top two item pairs on top of the stack: x1 x2 x3 x4 -> x3 x4 x1 x2 /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.ItemCount < 4) { error = Err.OpNotEnoughItems; return(false); } byte[][] data = opData.Pop(4); // x0 x1 x2 x3 -> x2 x3 x0 x1 opData.Push(new byte[4][] { data[2], data[3], data[0], data[1] }); error = null; return(true); }
/// <summary> /// Swaps top two item pairs on top of the stack: x1 x2 x3 x4 -> x3 x4 x1 x2 /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.ItemCount < 4) { error = "There was not enough items left in the stack to swap."; return(false); } byte[][] data = opData.Pop(4); // x0 x1 x2 x3 -> x2 x3 x0 x1 opData.Push(new byte[4][] { data[2], data[3], data[0], data[1] }); error = null; return(true); }
/// <summary> /// Rotates top 3 items on top of the stack to the left. Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.ItemCount < 3) { error = "There was not enough items left in the stack to rotate."; return(false); } byte[][] data = opData.Pop(3); // (x0 x1 x2 -> x1 x2 x0) opData.Push(new byte[3][] { data[1], data[2], data[0] }); error = null; return(true); }
/// <summary> /// Rotates top 3 items on top of the stack to the left. Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.ItemCount < 3) { error = Err.OpNotEnoughItems; return(false); } byte[][] data = opData.Pop(3); // (x0 x1 x2 -> x1 x2 x0) opData.Push(new byte[3][] { data[1], data[2], data[0] }); error = null; return(true); }
/// <summary> /// Removes top two stack item and pushes the result of their equality check (true for equality and false otherwiwe) /// onto the stack. Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.ItemCount < 2) { error = Err.OpNotEnoughItems; return(false); } ReadOnlySpan <byte> item1 = opData.Pop(); ReadOnlySpan <byte> item2 = opData.Pop(); opData.Push(item1.SequenceEqual(item2)); error = null; return(true); }
/// <summary> /// Copies 2 items from stack to top of the stack like this: x1 x2 x3 x4 -> x1 x2 x3 x4 x1 x2 /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (opData.ItemCount < 4) { error = "There was not enough items left in the stack to copy over."; return(false); } byte[] data1 = opData.PeekAtIndex(3); byte[] data2 = opData.PeekAtIndex(2); opData.Push(new byte[2][] { data1, data2 }); error = null; return(true); }
/// <summary> /// Replaces top stack item interpreted as a <see cref="long"/> with its absolute value. Return value indicates success. /// </summary> /// <param name="opData">Data to use</param> /// <param name="error">Error message (null if sucessful, otherwise will contain information about the failure)</param> /// <returns>True if operation was successful, false if otherwise</returns> public override bool Run(IOpData opData, out string error) { if (!TrySetValue(opData, out error)) { return(false); } if (a < 0) { a = -a; } opData.Push(IntToByteArray(a)); error = null; return(true); }