From 34d90330b72c7b4541135ee995f0510d6db6e20a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=B6ren?= <hello@soerenschwert.de>
Date: Thu, 23 Nov 2023 11:30:49 -0600
Subject: [PATCH] Avoid using 1.0 Nimiq lib for transaction handling

---
 public/index.html                    | 14 ++++----
 src/lib/BufferUtils.ts               | 15 +++++++++
 src/lib/NetworkClient.ts             | 15 +++------
 src/views/SignStakingSuccess.vue     | 50 ++++++++++++++++------------
 src/views/SignTransactionSuccess.vue | 43 ++++++++++++++++--------
 5 files changed, 85 insertions(+), 52 deletions(-)
 create mode 100644 src/lib/BufferUtils.ts

diff --git a/public/index.html b/public/index.html
index 5ddf43bd..5eb74fe5 100644
--- a/public/index.html
+++ b/public/index.html
@@ -23,14 +23,16 @@
     <link rel="icon" href="<%= htmlWebpackPlugin.options.domain %>/favicon.ico">
 
     <script type="module">
-        import init, { Client, ClientConfiguration } from '/albatross-client/web/index.js';
+        import init, * as Nimiq from '/albatross-client/web/index.js';
+
+        /** @type {Promise<Nimiq> | undefined} */
+        let initPromise;
 
         window.loadAlbatross = async function() {
-            await init();
-            return {
-                Client,
-                ClientConfiguration,
-            };
+            return initPromise || (initPromise = new Promise(async resolve => {
+                await init();
+                resolve(Nimiq);
+            }));
         }
     </script>
 </head>
diff --git a/src/lib/BufferUtils.ts b/src/lib/BufferUtils.ts
new file mode 100644
index 00000000..a16d0ed0
--- /dev/null
+++ b/src/lib/BufferUtils.ts
@@ -0,0 +1,15 @@
+export function hexToBytes(hex: string) {
+    return new Uint8Array((hex.match(/.{2}/g) || []).map(byte => parseInt(byte, 16)));
+}
+
+export function bytesToHex(bytes: Uint8Array) {
+    const HEX_ALPHABET = '0123456789abcdef';
+
+    let hex = '';
+    for (let i = 0; i < bytes.length; i++) {
+        const code = bytes[i];
+        hex += HEX_ALPHABET[code >>> 4];
+        hex += HEX_ALPHABET[code & 0x0F];
+    }
+    return hex;
+}
diff --git a/src/lib/NetworkClient.ts b/src/lib/NetworkClient.ts
index 9c311526..3371acb0 100644
--- a/src/lib/NetworkClient.ts
+++ b/src/lib/NetworkClient.ts
@@ -1,16 +1,9 @@
-import type {
-    Client as AlbatrossClient,
-    ClientConfiguration as AlbatrossClientConfiguration,
-    PlainVestingContract,
-} from '@nimiq/albatross-wasm';
+import type * as Nimiq from '@nimiq/albatross-wasm';
 import Config from 'config';
 
 declare global {
     interface Window {
-        loadAlbatross: () => Promise<{
-            Client: typeof AlbatrossClient,
-            ClientConfiguration: typeof AlbatrossClientConfiguration,
-        }>;
+        loadAlbatross: () => Promise<typeof Nimiq>;
     }
 }
 
@@ -22,7 +15,7 @@ export class NetworkClient {
         return this._instance;
     }
 
-    private _clientPromise?: Promise<AlbatrossClient>;
+    private _clientPromise?: Promise<Nimiq.Client>;
 
     // constructor() {}
 
@@ -62,7 +55,7 @@ export class NetworkClient {
     }
 
     public async getGenesisVestingContracts() {
-        return [] as Array<PlainVestingContract & { address: string }>; // TODO
+        return [] as Array<Nimiq.PlainVestingContract & { address: string }>; // TODO
     }
 
     public get innerClient() {
diff --git a/src/views/SignStakingSuccess.vue b/src/views/SignStakingSuccess.vue
index d350a579..2047f6b4 100644
--- a/src/views/SignStakingSuccess.vue
+++ b/src/views/SignStakingSuccess.vue
@@ -1,35 +1,43 @@
-<template>
-    <Network ref="network" :visible="false"/>
-</template>
-
 <script lang="ts">
 import { Component, Vue } from 'vue-property-decorator';
-import Network from '@/components/Network.vue';
 import { SignedTransaction } from '../../client/PublicRequestTypes';
 import { State } from 'vuex-class';
-import { Static } from '../lib/StaticStore';
 import KeyguardClient from '@nimiq/keyguard-client';
-import { StakingSignallingTypes, StakingTransactionType } from '../lib/Constants';
+import { bytesToHex, hexToBytes } from '../lib/BufferUtils';
 
-@Component({components: {Network}})
+@Component({})
 export default class SignStakingSuccess extends Vue {
-    @Static private keyguardRequest!: KeyguardClient.SignStakingRequest;
     @State private keyguardResult!: KeyguardClient.SignStakingResult;
 
     private async mounted() {
-        const tx = await (this.$refs.network as Network).createTx(Object.assign(
-            { signerPubKey: this.keyguardResult.publicKey },
-            this.keyguardRequest,
-            this.keyguardResult,
-            StakingSignallingTypes.includes(this.keyguardRequest.type) ? { value: 0, flags: 0b10 } : {},
-            this.keyguardRequest.type === StakingTransactionType.UNSTAKE
-                ? { proofPrefix: new Uint8Array([StakingTransactionType.UNSTAKE])}
-                : {},
-        ));
-        const result: SignedTransaction = await (this.$refs.network as Network).makeSignTransactionResult(tx);
+        const { Transaction } = await window.loadAlbatross();
+
+        const hex = bytesToHex(this.keyguardResult.serializedTx);
+        const tx = Transaction.fromAny(hex);
+        const plain = tx.toPlain();
 
-        // Overwrite serializedTx with Albatross serialization format
-        result.serializedTx = Nimiq.BufferUtils.toHex(this.keyguardResult.serializedTx);
+        const result: SignedTransaction = {
+            serializedTx: hex,
+            hash: plain.transactionHash,
+            raw: {
+                ...plain,
+                senderType: tx.senderType,
+                recipientType: tx.recipientType,
+                proof: tx.proof,
+                signerPublicKey: 'publicKey' in plain.proof
+                    ? hexToBytes(plain.proof.publicKey)
+                    : 'creatorPublicKey' in plain.proof
+                        ? hexToBytes(plain.proof.creatorPublicKey)
+                        : new Uint8Array(0),
+                signature: 'signature' in plain.proof
+                    ? hexToBytes(plain.proof.signature)
+                    : 'creatorSignature' in plain.proof
+                        ? hexToBytes(plain.proof.creatorSignature)
+                        : new Uint8Array(0),
+                extraData: tx.data,
+                networkId: tx.networkId,
+            },
+        };
 
         this.$rpc.resolve(result);
     }
diff --git a/src/views/SignTransactionSuccess.vue b/src/views/SignTransactionSuccess.vue
index 6ee7f6b5..570f0833 100644
--- a/src/views/SignTransactionSuccess.vue
+++ b/src/views/SignTransactionSuccess.vue
@@ -1,28 +1,43 @@
-<template>
-    <Network ref="network" :visible="false"/>
-</template>
-
 <script lang="ts">
 import { Component, Vue } from 'vue-property-decorator';
-import Network from '@/components/Network.vue';
 import { SignedTransaction } from '../../client/PublicRequestTypes';
 import { State } from 'vuex-class';
-import { Static } from '../lib/StaticStore';
 import KeyguardClient from '@nimiq/keyguard-client';
+import { bytesToHex, hexToBytes } from '../lib/BufferUtils';
 
-@Component({components: {Network}})
+@Component({})
 export default class SignTransactionSuccess extends Vue {
-    @Static private keyguardRequest!: KeyguardClient.SignTransactionRequest;
     @State private keyguardResult!: KeyguardClient.SignTransactionResult;
 
     private async mounted() {
-        const tx = await (this.$refs.network as Network).createTx(Object.assign({
-            signerPubKey: this.keyguardResult.publicKey,
-        }, this.keyguardResult, this.keyguardRequest));
-        const result: SignedTransaction = await (this.$refs.network as Network).makeSignTransactionResult(tx);
+        const { Transaction } = await window.loadAlbatross();
+
+        const hex = bytesToHex(this.keyguardResult.serializedTx);
+        const tx = Transaction.fromAny(hex);
+        const plain = tx.toPlain();
 
-        // Overwrite serializedTx with Albatross serialization format
-        result.serializedTx = Nimiq.BufferUtils.toHex(this.keyguardResult.serializedTx);
+        const result: SignedTransaction = {
+            serializedTx: hex,
+            hash: plain.transactionHash,
+            raw: {
+                ...plain,
+                senderType: tx.senderType,
+                recipientType: tx.recipientType,
+                proof: tx.proof,
+                signerPublicKey: 'publicKey' in plain.proof
+                    ? hexToBytes(plain.proof.publicKey)
+                    : 'creatorPublicKey' in plain.proof
+                        ? hexToBytes(plain.proof.creatorPublicKey)
+                        : new Uint8Array(0),
+                signature: 'signature' in plain.proof
+                    ? hexToBytes(plain.proof.signature)
+                    : 'creatorSignature' in plain.proof
+                        ? hexToBytes(plain.proof.creatorSignature)
+                        : new Uint8Array(0),
+                extraData: tx.data,
+                networkId: tx.networkId,
+            },
+        };
 
         this.$rpc.resolve(result);
     }