From c13feffc56daadcd768ac971315de80418d4e0d9 Mon Sep 17 00:00:00 2001 From: Jozef Koval Date: Fri, 12 Jan 2024 22:50:42 +0100 Subject: [PATCH] Rename point to element in CryptoFacade --- .../scala/sigmastate/crypto/Platform.scala | 39 +++++++-------- .../crypto/CryptoFacadeJsSpec.scala | 5 +- .../scala/sigmastate/crypto/Platform.scala | 50 +++++++++---------- .../scala/sigmastate/crypto/BcDlogGroup.scala | 8 +-- .../sigmastate/crypto/CryptoFacade.scala | 32 ++++++------ .../scala/sigmastate/crypto/DlogGroup.scala | 2 +- .../sigmastate/eval/CostingDataContext.scala | 8 +-- .../scala/sigmastate/eval/Extensions.scala | 2 +- .../GroupElementSerializer.scala | 4 +- .../CryptoFacadeSpecification.scala | 10 ++-- .../crypto/GroupLawsSpecification.scala | 8 +-- .../GroupElementSerializerSpecification.scala | 8 +-- .../org/ergoplatform/sdk/js/ValueSpec.scala | 2 +- .../wallet/secrets/ExtendedPublicKey.scala | 4 +- 14 files changed, 91 insertions(+), 91 deletions(-) diff --git a/interpreter/js/src/main/scala/sigmastate/crypto/Platform.scala b/interpreter/js/src/main/scala/sigmastate/crypto/Platform.scala index fdb3b128fd..fae45f6d1e 100644 --- a/interpreter/js/src/main/scala/sigmastate/crypto/Platform.scala +++ b/interpreter/js/src/main/scala/sigmastate/crypto/Platform.scala @@ -1,6 +1,5 @@ package sigmastate.crypto -import sigma.data.RType import scorex.util.encode.Base16 import sigmastate._ import sigma.Coll @@ -72,7 +71,7 @@ object Platform { * @see [[CryptoFacade.getASN1Encoding]] */ def getASN1Encoding(p: Ecp, compressed: Boolean): Array[Byte] = { - val hex = if (isInfinityPoint(p)) "00" // to ensure equality with Java implementation + val hex = if (isIdentity(p)) "00" // to ensure equality with Java implementation else p.point.toHex(compressed) Base16.decode(hex).get } @@ -85,44 +84,44 @@ object Platform { * * @return a new ECPoint instance representing the same point, but with normalized coordinates */ - def normalizePoint(p: Ecp): Ecp = new Ecp(CryptoFacadeJs.normalizePoint(p.point)) + def normalize(e: Ecp): Ecp = new Ecp(CryptoFacadeJs.normalizePoint(e.point)) - /** Return simplified string representation of the point (used only for debugging) */ - def showPoint(p: Ecp): String = CryptoFacadeJs.showPoint(p.point) + /** Return simplified string representation of the element (used only for debugging) */ + def showElement(e: Ecp): String = CryptoFacadeJs.showPoint(e.point) - /** Multiply two points. + /** Multiply two elements. * - * @param p1 first point - * @param p2 second point - * @return group multiplication (p1 * p2) + * @param e1 first element + * @param e2 second element + * @return group multiplication (e1 * e2) */ - def multiplyPoints(p1: Ecp, p2: Ecp): Ecp = new Ecp(CryptoFacadeJs.addPoint(p1.point, p2.point)) + def multiplyElements(e1: Ecp, e2: Ecp): Ecp = new Ecp(CryptoFacadeJs.addPoint(e1.point, e2.point)) /** Exponentiate a point p. * The implementation mimics the Java implementation of `AbstractECMultiplier.multiply` * from BouncyCastle library. * - * @param p point to exponentiate + * @param e element to exponentiate * @param n exponent - * @return p to the power of n (`p^n`) i.e. `p + p + ... + p` (n times) + * @return e to the power of n (`e^n`) i.e. `e + e + ... + e` (n times) */ - def exponentiatePoint(p: Ecp, n: BigInteger): Ecp = { + def exponentiateElement(e: Ecp, n: BigInteger): Ecp = { val sign = n.signum() - if (sign == 0 || isInfinityPoint(p)) { + if (sign == 0 || isIdentity(e)) { val ctx = new CryptoContextJs() return new Ecp(ctx.getInfinity()) } val scalar = Convert.bigIntegerToBigInt(n.abs()) - val positive = CryptoFacadeJs.multiplyPoint(p.point, scalar) + val positive = CryptoFacadeJs.multiplyPoint(e.point, scalar) val result = if (sign > 0) positive else CryptoFacadeJs.negatePoint(positive) new Ecp(result) } - /** Check if a point is infinity. */ - def isInfinityPoint(p: Ecp): Boolean = CryptoFacadeJs.isInfinityPoint(p.point) + /** Check if a element is identity. */ + def isIdentity(e: Ecp): Boolean = CryptoFacadeJs.isInfinityPoint(e.point) - /** Negates the given point by negating its y coordinate. */ - def negatePoint(p: Ecp): Ecp = new Ecp(CryptoFacadeJs.negatePoint(p.point)) + /** Negates the given element by negating its y coordinate. */ + def inverse(e: Ecp): Ecp = new Ecp(CryptoFacadeJs.negatePoint(e.point)) /** JS implementation of Elliptic Curve. */ class Curve @@ -245,7 +244,7 @@ object Platform { def isCorrectType[T <: SType](value: Any, tpe: T): Boolean = value match { case c: Coll[_] => tpe match { case STuple(items) => c.tItem == sigma.AnyType && c.length == items.length - case tpeColl: SCollection[_] => true + case _: SCollection[_] => true case _ => sys.error(s"Collection value $c has unexpected type $tpe") } case _: Option[_] => tpe.isOption diff --git a/interpreter/js/src/test/scala/sigmastate/crypto/CryptoFacadeJsSpec.scala b/interpreter/js/src/test/scala/sigmastate/crypto/CryptoFacadeJsSpec.scala index 63839e67ef..a24e6e938c 100644 --- a/interpreter/js/src/test/scala/sigmastate/crypto/CryptoFacadeJsSpec.scala +++ b/interpreter/js/src/test/scala/sigmastate/crypto/CryptoFacadeJsSpec.scala @@ -17,12 +17,13 @@ class CryptoFacadeJsSpec extends AnyPropSpec with Matchers with CryptoTesting { } property("CryptoFacade.normalizePoint") { - CryptoFacade.normalizePoint(new Ecp(p1)) shouldBe new Ecp(p1) + CryptoFacadeJs.normalizePoint(p1).toHex(true) shouldBe + "0381c5275b1d50c39a0c36c4561c3a37bff1d87e37a9ad69eab029e426c0b1a8ac" } property("CryptoFacade.negatePoint") { CryptoFacadeJs.negatePoint(p1).toHex(true) shouldBe - "0281c5275b1d50c39a0c36c4561c3a37bff1d87e37a9ad69eab029e426c0b1a8ac" + "0281c5275b1d50c39a0c36c4561c3a37bff1d87e37a9ad69eab029e426c0b1a8ac" } property("CryptoFacade.isInfinityPoint") { diff --git a/interpreter/jvm/src/main/scala/sigmastate/crypto/Platform.scala b/interpreter/jvm/src/main/scala/sigmastate/crypto/Platform.scala index 1c5c63b197..fbdf502f36 100644 --- a/interpreter/jvm/src/main/scala/sigmastate/crypto/Platform.scala +++ b/interpreter/jvm/src/main/scala/sigmastate/crypto/Platform.scala @@ -73,48 +73,48 @@ object Platform { /** Normalization ensures that any projective coordinate is 1, and therefore that the x, y * coordinates reflect those of the equivalent point in an affine coordinate system. * - * @return a new ECPoint instance representing the same point, but with normalized coordinates + * @return a new ECPoint instance representing the same element, but with normalized coordinates */ - def normalizePoint(p: Ecp): Ecp = Ecp(p.value.normalize()) + def normalize(e: Ecp): Ecp = Ecp(e.value.normalize()) - /** Return simplified string representation of the point (used only for debugging) */ - def showPoint(p: Ecp): String = { - val rawX = p.value.getRawXCoord.toString.substring(0, 6) - val rawY = p.value.getRawYCoord.toString.substring(0, 6) + /** Return simplified string representation of element (used only for debugging) */ + def showElement(e: Ecp): String = { + val rawX = e.value.getRawXCoord.toString.substring(0, 6) + val rawY = e.value.getRawYCoord.toString.substring(0, 6) s"ECPoint($rawX,$rawY,...)" } - /** Multiply two points. + /** Multiply two elements. * - * @param p1 first point - * @param p2 second point - * @return group multiplication (p1 * p2) + * @param e1 first element + * @param e2 second element + * @return group multiplication (e1 * e2) */ - def multiplyPoints(p1: Ecp, p2: Ecp): Ecp = { + def multiplyElements(e1: Ecp, e2: Ecp): Ecp = { /* * BC treats EC as additive group while we treat that as multiplicative group. */ - Ecp(p1.value.add(p2.value)) + Ecp(e1.value.add(e2.value)) } - /** Exponentiate a point. - * @param p point to exponentiate + /** Exponentiate an element. + * @param e element to exponentiate * @param n exponent * @return p to the power of n (`p^n`) i.e. `p + p + ... + p` (n times) */ - def exponentiatePoint(p: Ecp, n: BigInteger): Ecp = { + def exponentiateElement(e: Ecp, n: BigInteger): Ecp = { /* * BC treats EC as additive group while we treat that as multiplicative group. * Therefore, exponentiate point is multiply. */ - Ecp(p.value.multiply(n)) + Ecp(e.value.multiply(n)) } - /** Check if a point is infinity. */ - def isInfinityPoint(p: Ecp): Boolean = p.value.isInfinity + /** Check if an element is infinity. */ + def isIdentity(e: Ecp): Boolean = e.value.isInfinity - /** Negates the given point by negating its y coordinate. */ - def negatePoint(p: Ecp): Ecp = Ecp(p.value.negate()) + /** Inverse the given element by negating its y coordinate. */ + def inverse(e: Ecp): Ecp = Ecp(e.value.negate()) /** Wrapper for curve descriptor. Serves as the concrete implementation of the * [[sigmastate.crypto.Curve]] type in JVM. @@ -199,11 +199,11 @@ object Platform { } /** This JVM specific methods are used in Ergo node which won't be JS cross-compiled. */ - implicit class EcpOps(val p: Ecp) extends AnyVal { - def getCurve: ECCurve = p.value.getCurve - def isInfinity: Boolean = CryptoFacade.isInfinityPoint(p) - def add(p2: Ecp): Ecp = CryptoFacade.multiplyPoints(p, p2) - def multiply(n: BigInteger): Ecp = CryptoFacade.exponentiatePoint(p, n) + implicit class EcpOps(val e: Ecp) extends AnyVal { + def getCurve: ECCurve = e.value.getCurve + def isIdentity: Boolean = CryptoFacade.isIdentity(e) + def add(e2: Ecp): Ecp = CryptoFacade.multiplyElements(e, e2) + def multiply(n: BigInteger): Ecp = CryptoFacade.exponentiateElement(e, n) } /** This JVM specific methods are used in Ergo node which won't be JS cross-compiled. */ diff --git a/interpreter/shared/src/main/scala/sigmastate/crypto/BcDlogGroup.scala b/interpreter/shared/src/main/scala/sigmastate/crypto/BcDlogGroup.scala index 030b333032..b0ddff4cba 100644 --- a/interpreter/shared/src/main/scala/sigmastate/crypto/BcDlogGroup.scala +++ b/interpreter/shared/src/main/scala/sigmastate/crypto/BcDlogGroup.scala @@ -139,7 +139,7 @@ abstract class BcDlogGroup(val ctx: CryptoContext) extends DlogGroup { * @throws IllegalArgumentException **/ override def inverseOf(groupElement: ElemType): ElemType = - CryptoFacade.negatePoint(groupElement) + CryptoFacade.inverse(groupElement) /** * Raises the base GroupElement to the exponent. The result is another GroupElement. @@ -151,12 +151,12 @@ abstract class BcDlogGroup(val ctx: CryptoContext) extends DlogGroup { */ override def exponentiate(base: ElemType, exponent: BigInteger): ElemType = { //infinity remains the same after any exponentiate - if (CryptoFacade.isInfinityPoint(base)) return base + if (CryptoFacade.isIdentity(base)) return base //If the exponent is negative, convert it to be the exponent modulus q. val exp = if (exponent.compareTo(BigInteger.ZERO) < 0) exponent.mod(order) else exponent - CryptoFacade.exponentiatePoint(base, exp) + CryptoFacade.exponentiateElement(base, exp) } @@ -197,7 +197,7 @@ abstract class BcDlogGroup(val ctx: CryptoContext) extends DlogGroup { * @throws IllegalArgumentException */ override def multiplyGroupElements(groupElement1: ElemType, groupElement2: ElemType): ElemType = - CryptoFacade.multiplyPoints(groupElement1, groupElement2) + CryptoFacade.multiplyElements(groupElement1, groupElement2) /** * Computes the product of several exponentiations of the same base diff --git a/interpreter/shared/src/main/scala/sigmastate/crypto/CryptoFacade.scala b/interpreter/shared/src/main/scala/sigmastate/crypto/CryptoFacade.scala index 3ce337d695..c540da3232 100644 --- a/interpreter/shared/src/main/scala/sigmastate/crypto/CryptoFacade.scala +++ b/interpreter/shared/src/main/scala/sigmastate/crypto/CryptoFacade.scala @@ -26,36 +26,36 @@ object CryptoFacade { def createCryptoContext(): CryptoContext = Platform.createContext() /** Normalization ensures that any projective coordinate is 1, and therefore that the x, y - * coordinates reflect those of the equivalent point in an affine coordinate system. + * coordinates reflect those of the equivalent element in an affine coordinate system. * - * @return a new ECPoint instance representing the same point, but with normalized coordinates + * @return a new ECPoint instance representing the same element, but with normalized coordinates */ - def normalizePoint(p: Ecp): Ecp = Platform.normalizePoint(p) + def normalize(e: Ecp): Ecp = Platform.normalize(e) - /** Negates the given point by negating its y coordinate. */ - def negatePoint(p: Ecp): Ecp = Platform.negatePoint(p) + /** Negates the given element by negating its y coordinate. */ + def inverse(e: Ecp): Ecp = Platform.inverse(e) - /** Check if a point is infinity. */ - def isInfinityPoint(p: Ecp): Boolean = Platform.isInfinityPoint(p) + /** Check if this is identity element. */ + def isIdentity(e: Ecp): Boolean = Platform.isIdentity(e) - /** Exponentiate a point. + /** Exponentiate an element. * - * @param p point to exponentiate + * @param e element to exponentiate * @param n exponent * @return p to the power of n (`p^n`) i.e. `p + p + ... + p` (n times) */ - def exponentiatePoint(p: Ecp, n: BigInteger): Ecp = Platform.exponentiatePoint(p, n) + def exponentiateElement(e: Ecp, n: BigInteger): Ecp = Platform.exponentiateElement(e, n) /** Multiply two points. * - * @param p1 first point - * @param p2 second point - * @return group multiplication (p1 * p2) + * @param e1 first element + * @param e2 second element + * @return group multiplication (e1 * e2) */ - def multiplyPoints(p1: Ecp, p2: Ecp): Ecp = Platform.multiplyPoints(p1, p2) + def multiplyElements(e1: Ecp, e2: Ecp): Ecp = Platform.multiplyElements(e1, e2) - /** Return simplified string representation of the point (used only for debugging) */ - def showPoint(p: Ecp): String = Platform.showPoint(p) + /** Return simplified string representation of element (used only for debugging) */ + def showElement(e: Ecp): String = Platform.showElement(e) /** Returns the sign of the field element. */ def signOf(p: ECFieldElem): Boolean = Platform.signOf(p) diff --git a/interpreter/shared/src/main/scala/sigmastate/crypto/DlogGroup.scala b/interpreter/shared/src/main/scala/sigmastate/crypto/DlogGroup.scala index 80ab2e372d..8a92300005 100644 --- a/interpreter/shared/src/main/scala/sigmastate/crypto/DlogGroup.scala +++ b/interpreter/shared/src/main/scala/sigmastate/crypto/DlogGroup.scala @@ -82,7 +82,7 @@ trait DlogGroup { // if the given element is the identity, get a new random element while ( { - CryptoFacade.isInfinityPoint(randGen) + CryptoFacade.isIdentity(randGen) }) randGen = createRandomElement() randGen diff --git a/interpreter/shared/src/main/scala/sigmastate/eval/CostingDataContext.scala b/interpreter/shared/src/main/scala/sigmastate/eval/CostingDataContext.scala index 870cbbb5bf..792fd87ef3 100644 --- a/interpreter/shared/src/main/scala/sigmastate/eval/CostingDataContext.scala +++ b/interpreter/shared/src/main/scala/sigmastate/eval/CostingDataContext.scala @@ -100,16 +100,16 @@ case class CGroupElement(override val wrappedValue: Ecp) extends GroupElement wi override def getEncoded: Coll[Byte] = dsl.Colls.fromArray(GroupElementSerializer.toBytes(wrappedValue)) - override def isIdentity: Boolean = CryptoFacade.isInfinityPoint(wrappedValue) + override def isIdentity: Boolean = CryptoFacade.isIdentity(wrappedValue) override def exp(k: BigInt): GroupElement = - dsl.GroupElement(CryptoFacade.exponentiatePoint(wrappedValue, k.asInstanceOf[CBigInt].wrappedValue)) + dsl.GroupElement(CryptoFacade.exponentiateElement(wrappedValue, k.asInstanceOf[CBigInt].wrappedValue)) override def multiply(that: GroupElement): GroupElement = - dsl.GroupElement(CryptoFacade.multiplyPoints(wrappedValue, that.asInstanceOf[CGroupElement].wrappedValue)) + dsl.GroupElement(CryptoFacade.multiplyElements(wrappedValue, that.asInstanceOf[CGroupElement].wrappedValue)) override def negate: GroupElement = - dsl.GroupElement(CryptoFacade.negatePoint(wrappedValue)) + dsl.GroupElement(CryptoFacade.inverse(wrappedValue)) } /** A default implementation of [[SigmaProp]] interface. diff --git a/interpreter/shared/src/main/scala/sigmastate/eval/Extensions.scala b/interpreter/shared/src/main/scala/sigmastate/eval/Extensions.scala index c7cac60d81..28921f3445 100644 --- a/interpreter/shared/src/main/scala/sigmastate/eval/Extensions.scala +++ b/interpreter/shared/src/main/scala/sigmastate/eval/Extensions.scala @@ -110,7 +110,7 @@ object Extensions { "IDENTITY" } else { - CryptoFacade.showPoint(p) + CryptoFacade.showElement(p) } } diff --git a/interpreter/shared/src/main/scala/sigmastate/serialization/GroupElementSerializer.scala b/interpreter/shared/src/main/scala/sigmastate/serialization/GroupElementSerializer.scala index e54c41e426..102d628b3e 100644 --- a/interpreter/shared/src/main/scala/sigmastate/serialization/GroupElementSerializer.scala +++ b/interpreter/shared/src/main/scala/sigmastate/serialization/GroupElementSerializer.scala @@ -22,10 +22,10 @@ object GroupElementSerializer extends SigmaSerializer[EcPointType, EcPointType] private lazy val identityPointEncoding = Array.fill(encodingSize)(0: Byte) override def serialize(point: EcPointType, w: SigmaByteWriter): Unit = { - val bytes = if (CryptoFacade.isInfinityPoint(point)) { + val bytes = if (CryptoFacade.isIdentity(point)) { identityPointEncoding } else { - val normed = CryptoFacade.normalizePoint(point) + val normed = CryptoFacade.normalize(point) val ySign = CryptoFacade.signOf(CryptoFacade.getAffineYCoord(normed)) val X = CryptoFacade.encodeFieldElem(CryptoFacade.getXCoord(normed)) val PO = safeNewArray[Byte](X.length + 1) diff --git a/interpreter/shared/src/test/scala/sigmastate/CryptoFacadeSpecification.scala b/interpreter/shared/src/test/scala/sigmastate/CryptoFacadeSpecification.scala index 49fa4534bd..8e6746b253 100644 --- a/interpreter/shared/src/test/scala/sigmastate/CryptoFacadeSpecification.scala +++ b/interpreter/shared/src/test/scala/sigmastate/CryptoFacadeSpecification.scala @@ -63,10 +63,10 @@ class CryptoFacadeSpecification extends AnyPropSpec with Matchers with ScalaChec val vectors = Table( ("point", "expectedHex"), (ctx.infinity(), "00"), - (CryptoFacade.exponentiatePoint(G, Q), "00"), + (CryptoFacade.exponentiateElement(G, Q), "00"), (G, G_hex), - (CryptoFacade.exponentiatePoint(G, BigInteger.ONE), G_hex), - (CryptoFacade.exponentiatePoint(G, Q.subtract(BigInteger.ONE)), "0379be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798") + (CryptoFacade.exponentiateElement(G, BigInteger.ONE), G_hex), + (CryptoFacade.exponentiateElement(G, Q.subtract(BigInteger.ONE)), "0379be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798") ) forAll (vectors) { (point, expectedHex) => val res = ErgoAlgos.encode(CryptoFacade.getASN1Encoding(point, true)) @@ -78,14 +78,14 @@ class CryptoFacadeSpecification extends AnyPropSpec with Matchers with ScalaChec val ctx = CryptoFacade.createCryptoContext() val inf = ctx.decodePoint(Array[Byte](0)) - CryptoFacade.isInfinityPoint(inf) shouldBe true + CryptoFacade.isIdentity(inf) shouldBe true val G = ctx.generator ctx.decodePoint(ErgoAlgos.decode(G_hex).get) shouldBe G val Q = ctx.order val Q_minus_1 = Q.subtract(BigInteger.ONE) - val maxExp = CryptoFacade.exponentiatePoint(G, Q_minus_1) + val maxExp = CryptoFacade.exponentiateElement(G, Q_minus_1) val maxExpBytes = ErgoAlgos.decode("0379be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798").get ctx.decodePoint(maxExpBytes) shouldBe maxExp } diff --git a/interpreter/shared/src/test/scala/sigmastate/crypto/GroupLawsSpecification.scala b/interpreter/shared/src/test/scala/sigmastate/crypto/GroupLawsSpecification.scala index d177a26e4c..de563207e7 100644 --- a/interpreter/shared/src/test/scala/sigmastate/crypto/GroupLawsSpecification.scala +++ b/interpreter/shared/src/test/scala/sigmastate/crypto/GroupLawsSpecification.scala @@ -91,16 +91,16 @@ class GroupLawsSpecification extends AnyPropSpec with ScalaCheckPropertyChecks w // } property("check test vectors") { - CryptoFacade.multiplyPoints(p1, p2) shouldBe + CryptoFacade.multiplyElements(p1, p2) shouldBe Helpers.decodeECPoint("03de5e9c2806c05cd45a57d18c469743f42a0d2c84370b6662eb39d8a2990abed8") - CryptoFacade.exponentiatePoint(p1, group.order) shouldBe + CryptoFacade.exponentiateElement(p1, group.order) shouldBe Helpers.decodeECPoint("000000000000000000000000000000000000000000000000000000000000000000") - CryptoFacade.exponentiatePoint(p1, group.order.add(BigInteger.ONE)) shouldBe + CryptoFacade.exponentiateElement(p1, group.order.add(BigInteger.ONE)) shouldBe Helpers.decodeECPoint("0381c5275b1d50c39a0c36c4561c3a37bff1d87e37a9ad69eab029e426c0b1a8ac") - CryptoFacade.negatePoint(p1) shouldBe + CryptoFacade.inverse(p1) shouldBe Helpers.decodeECPoint("0281c5275b1d50c39a0c36c4561c3a37bff1d87e37a9ad69eab029e426c0b1a8ac") } } diff --git a/interpreter/shared/src/test/scala/sigmastate/serialization/GroupElementSerializerSpecification.scala b/interpreter/shared/src/test/scala/sigmastate/serialization/GroupElementSerializerSpecification.scala index 04c4a8e128..e0691aea9c 100644 --- a/interpreter/shared/src/test/scala/sigmastate/serialization/GroupElementSerializerSpecification.scala +++ b/interpreter/shared/src/test/scala/sigmastate/serialization/GroupElementSerializerSpecification.scala @@ -21,10 +21,10 @@ class GroupElementSerializerSpecification extends SerializationSpecification { val bytes = GroupElementSerializer.toBytes(ge.value) bytes.length shouldBe CryptoConstants.EncodedGroupElementLength val restored = GroupElementSerializer.parse(SigmaSerializer.startReader(bytes, 0)) - CryptoFacade.getAffineXCoord(CryptoFacade.normalizePoint(restored)) shouldBe - CryptoFacade.getAffineXCoord(CryptoFacade.normalizePoint(ge.value)) - CryptoFacade.getAffineYCoord(CryptoFacade.normalizePoint(restored)) shouldBe - CryptoFacade.getAffineYCoord(CryptoFacade.normalizePoint(ge.value)) + CryptoFacade.getAffineXCoord(CryptoFacade.normalize(restored)) shouldBe + CryptoFacade.getAffineXCoord(CryptoFacade.normalize(ge.value)) + CryptoFacade.getAffineYCoord(CryptoFacade.normalize(restored)) shouldBe + CryptoFacade.getAffineYCoord(CryptoFacade.normalize(ge.value)) } } } diff --git a/sdk/js/src/test/scala/org/ergoplatform/sdk/js/ValueSpec.scala b/sdk/js/src/test/scala/org/ergoplatform/sdk/js/ValueSpec.scala index be0997fcc6..0139c13631 100644 --- a/sdk/js/src/test/scala/org/ergoplatform/sdk/js/ValueSpec.scala +++ b/sdk/js/src/test/scala/org/ergoplatform/sdk/js/ValueSpec.scala @@ -44,7 +44,7 @@ class ValueSpec extends AnyPropSpec with Matchers with SigmaTestingData with Sca } property("GroupElement toHex()/fromHex()") { - val ge = CryptoFacade.exponentiatePoint(dlogGroup.generator, BigInteger.valueOf(2)) + val ge = CryptoFacade.exponentiateElement(dlogGroup.generator, BigInteger.valueOf(2)) test(GroupElementConstant(ge), "0702c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5") } diff --git a/sdk/shared/src/main/scala/org/ergoplatform/sdk/wallet/secrets/ExtendedPublicKey.scala b/sdk/shared/src/main/scala/org/ergoplatform/sdk/wallet/secrets/ExtendedPublicKey.scala index 2ad287972e..e7a88144c3 100644 --- a/sdk/shared/src/main/scala/org/ergoplatform/sdk/wallet/secrets/ExtendedPublicKey.scala +++ b/sdk/shared/src/main/scala/org/ergoplatform/sdk/wallet/secrets/ExtendedPublicKey.scala @@ -53,8 +53,8 @@ object ExtendedPublicKey { .hashHmacSHA512(parentKey.chainCode, parentKey.keyBytes ++ Index.serializeIndex(idx)) .splitAt(CryptoFacade.SecretKeyLength) val childKeyProtoDecoded = BigIntegers.fromUnsignedByteArray(childKeyProto) - val childKey = CryptoFacade.multiplyPoints(DLogProverInput(childKeyProtoDecoded).publicImage.value, parentKey.key.value) - if (childKeyProtoDecoded.compareTo(CryptoConstants.groupOrder) >= 0 || CryptoFacade.isInfinityPoint(childKey)) { + val childKey = CryptoFacade.multiplyElements(DLogProverInput(childKeyProtoDecoded).publicImage.value, parentKey.key.value) + if (childKeyProtoDecoded.compareTo(CryptoConstants.groupOrder) >= 0 || CryptoFacade.isIdentity(childKey)) { deriveChildPublicKey(parentKey, idx + 1) } else { new ExtendedPublicKey(CryptoFacade.getASN1Encoding(childKey, true), childChainCode, parentKey.path.extended(idx))