test: passing swift tests

Author: joe-p

packages/swift/AlgoKitTransact/Tests/AlgoKitTransactTests/GenericTransactionTests.swift

@@ -13,8 +13,11 @@ func genericTransactionMalformedBytes() throws {
   let simplePayment = testData.simplePayment
   let badBytes = Data(simplePayment.unsignedBytes[13..<37])
   do {
-    _ = try decodeTransaction(bytes: badBytes)
+    _ = try decodeTransaction(encodedTx: badBytes)
     #expect(Bool(false), "Expected DecodingError to be thrown")
+  } catch AlgoKitTransactError.InputError {
+    // Success - expected error was thrown
+    #expect(Bool(true))
   } catch AlgoKitTransactError.DecodingError {
     // Success - expected error was thrown
     #expect(Bool(true))
@@ -24,9 +27,9 @@ func genericTransactionMalformedBytes() throws {
 @Test("Generic Transaction: encode 0 bytes")
 func genericTransactionEncode0Bytes() throws {
   do {
-    _ = try decodeTransaction(bytes: Data())
+    _ = try decodeTransaction(encodedTx: Data())
     #expect(Bool(false), "Expected DecodingError to be thrown")
-  } catch AlgoKitTransactError.DecodingError(let message) {
+  } catch AlgoKitTransactError.InputError(let message) {
     #expect(message == "attempted to decode 0 bytes")
   }
 }

packages/swift/AlgoKitTransact/Tests/AlgoKitTransactTests/PaymentTests.swift

@@ -11,10 +11,8 @@ import ed25519swift
 @Test("Payment: example")
 func paymentExample() throws {
   let aliceKeyPair = Ed25519.generateKeyPair()
-  let alice = try addressFromPubKey(pubKey: Data(aliceKeyPair.publicKey))
-  let bob = try addressFromString(
-    address: "B72WNFFEZ7EOGMQPP7ROHYS3DSLL5JW74QASYNWGZGQXWRPJECJJLJIJ2Y"
-  )
+  let alice = try addressFromPublicKey(publicKey: Data(aliceKeyPair.publicKey))
+  let bob = "B72WNFFEZ7EOGMQPP7ROHYS3DSLL5JW74QASYNWGZGQXWRPJECJJLJIJ2Y"
 
   let txn: Transaction = Transaction(
     transactionType: .payment,
@@ -31,21 +29,23 @@ func paymentExample() throws {
   )
 
   let sig = Ed25519.sign(
-    message: [UInt8](try encodeTransaction(tx: txn)), secretKey: aliceKeyPair.secretKey)
+    message: [UInt8](try encodeTransaction(transaction: txn)), secretKey: aliceKeyPair.secretKey)
 
-  let signedTxn = try attachSignature(
-    encodedTx: try encodeTransaction(tx: txn),
+  let signedTxn = SignedTransaction(
+    transaction: txn,
     signature: Data(sig)
   )
 
-  #expect(signedTxn.count > 0)
+  let encodedSignedTxn = try encodeSignedTransaction(signedTransaction: signedTxn)
+
+  #expect(!encodedSignedTxn.isEmpty)
 }
 
 @Test("Payment: get encoded transaction type")
 func paymentGetEncodedTransactionType() throws {
   let testData = try loadTestData()
   let simplePayment = testData.simplePayment
-  let txType = try getEncodedTransactionType(bytes: Data(simplePayment.unsignedBytes))
+  let txType = try getEncodedTransactionType(encodedTransaction: Data(simplePayment.unsignedBytes))
   #expect(txType == .payment)
 }
 
@@ -55,7 +55,7 @@ func paymentDecodeWithoutPrefix() throws {
   let simplePayment = testData.simplePayment
   let transaction = makeTransaction(from: simplePayment)
   let bytesWithoutPrefix = Data(simplePayment.unsignedBytes.dropFirst(2))
-  let decoded = try decodeTransaction(bytes: bytesWithoutPrefix)
+  let decoded = try decodeTransaction(encodedTx: bytesWithoutPrefix)
   #expect(decoded == transaction)
 }
 
@@ -64,7 +64,7 @@ func paymentDecodeWithPrefix() throws {
   let testData = try loadTestData()
   let simplePayment = testData.simplePayment
   let transaction = makeTransaction(from: simplePayment)
-  let decoded = try decodeTransaction(bytes: Data(simplePayment.unsignedBytes))
+  let decoded = try decodeTransaction(encodedTx: Data(simplePayment.unsignedBytes))
   #expect(decoded == transaction)
 }
 
@@ -74,10 +74,14 @@ func paymentEncodeWithSignature() throws {
   let simplePayment = testData.simplePayment
   let signature = Ed25519.sign(
     message: simplePayment.unsignedBytes, secretKey: simplePayment.signingPrivateKey)
-  let signedTx = try attachSignature(
-    encodedTx: Data(simplePayment.unsignedBytes),
-    signature: Data(signature)
+
+  let signedTx = try encodeSignedTransaction(
+    signedTransaction: SignedTransaction(
+      transaction: makeTransaction(from: simplePayment),
+      signature: Data(signature)
+    )
   )
+
   #expect([UInt8](signedTx) == simplePayment.signedBytes)
 }
 
@@ -86,6 +90,6 @@ func paymentEncode() throws {
   let testData = try loadTestData()
   let simplePayment = testData.simplePayment
   let transaction = makeTransaction(from: simplePayment)
-  let encoded = try encodeTransaction(tx: transaction)
+  let encoded = try encodeTransaction(transaction: transaction)
   #expect([UInt8](encoded) == simplePayment.unsignedBytes)
 }

packages/swift/AlgoKitTransact/Tests/AlgoKitTransactTests/TestUtils.swift

@@ -9,22 +9,22 @@ struct TransactionTestData: Codable {
   }
 
   struct TransactionData: Codable {
-    let sender: AddressData
+    let sender: String
     let fee: UInt64
     let transactionType: String
     let firstValid: UInt64
     let lastValid: UInt64
     let genesisHash: [UInt8]
     let genesisId: String
     let note: [UInt8]?
-    let rekeyTo: AddressData?
+    let rekeyTo: String?
     let lease: [UInt8]?
     let group: [UInt8]?
     let payment: PaymentFieldsData
   }
 
   struct PaymentFieldsData: Codable {
-    let receiver: AddressData
+    let receiver: String
     let amount: UInt64
   }
 
@@ -50,28 +50,18 @@ func loadTestData() throws -> TestData {
 func makeTransaction(from testData: TransactionTestData) -> Transaction {
   return Transaction(
     transactionType: .payment,
-    sender: Address(
-      address: testData.transaction.sender.address,
-      pubKey: Data(testData.transaction.sender.pubKey)
-    ),
+    sender: testData.transaction.sender,
     fee: testData.transaction.fee,
     firstValid: testData.transaction.firstValid,
     lastValid: testData.transaction.lastValid,
     genesisHash: Data(testData.transaction.genesisHash),
     genesisId: testData.transaction.genesisId,
     note: testData.transaction.note != nil ? Data(testData.transaction.note!) : nil,
-    rekeyTo: testData.transaction.rekeyTo != nil
-      ? Address(
-        address: testData.transaction.rekeyTo!.address,
-        pubKey: Data(testData.transaction.rekeyTo!.pubKey)
-      ) : nil,
+    rekeyTo: testData.transaction.rekeyTo,
     lease: testData.transaction.lease != nil ? Data(testData.transaction.lease!) : nil,
     group: testData.transaction.group != nil ? Data(testData.transaction.group!) : nil,
     payment: PaymentTransactionFields(
-      receiver: Address(
-        address: testData.transaction.payment.receiver.address,
-        pubKey: Data(testData.transaction.payment.receiver.pubKey)
-      ),
+      receiver: testData.transaction.payment.receiver,
       amount: testData.transaction.payment.amount,
       closeRemainderTo: nil
     ),