diff --git a/client/PublicPaymentOptions.ts b/client/PublicPaymentOptions.ts
index d9b7bae2f..85b08e0b3 100644
--- a/client/PublicPaymentOptions.ts
+++ b/client/PublicPaymentOptions.ts
@@ -9,7 +9,7 @@ export interface NimiqSpecifics {
     sender?: string;
     forceSender?: boolean;
     recipient?: string;
-    recipientType?: Nimiq.Account.Type;
+    recipientType?: Nimiq.AccountType;
 }
 
 export type NimiqDirectPaymentOptions = PaymentOptions<Currency.NIM, PaymentType.DIRECT>;
diff --git a/client/PublicRequestTypes.ts b/client/PublicRequestTypes.ts
index 2adc7d3c3..2648e0bfa 100644
--- a/client/PublicRequestTypes.ts
+++ b/client/PublicRequestTypes.ts
@@ -92,7 +92,7 @@ export interface ChooseAddressResult extends Address {
 export interface SignTransactionRequest extends BasicRequest {
     sender: string;
     recipient: string;
-    recipientType?: Nimiq.Account.Type | 3;
+    recipientType?: Nimiq.AccountType;
     recipientLabel?: string;
     value: number;
     fee?: number;
@@ -113,7 +113,7 @@ export interface NimiqCheckoutRequest extends BasicRequest {
     sender?: string;
     forceSender?: boolean;
     recipient: string;
-    recipientType?: Nimiq.Account.Type;
+    recipientType?: Nimiq.AccountType;
     value: number;
     fee?: number;
     extraData?: Bytes;
@@ -236,9 +236,9 @@ export interface SignedTransaction {
         signature: Uint8Array;
 
         sender: string; // Userfriendly address
-        senderType: Nimiq.Account.Type | 3;
+        senderType: Nimiq.AccountType;
         recipient: string; // Userfriendly address
-        recipientType: Nimiq.Account.Type | 3;
+        recipientType: Nimiq.AccountType;
         value: number; // Luna
         fee: number; // Luna
         validityStartHeight: number;
@@ -460,19 +460,19 @@ export interface Address {
 }
 
 export interface VestingContract {
-    type: Nimiq.Account.Type.VESTING;
+    type: Nimiq.AccountType.Vesting;
     address: string; // Userfriendly address
     label: string;
 
     owner: string; // Userfriendly address
-    start: number;
+    startTime: number;
     stepAmount: number;
-    stepBlocks: number;
+    timeStep: number;
     totalAmount: number;
 }
 
 export interface HashedTimeLockedContract {
-    type: Nimiq.Account.Type.HTLC;
+    type: Nimiq.AccountType.HTLC;
     address: string; // Userfriendly address
     label: string;
 
diff --git a/client/dist/src/PublicPaymentOptions.d.ts b/client/dist/src/PublicPaymentOptions.d.ts
index ac0204eea..40a121481 100644
--- a/client/dist/src/PublicPaymentOptions.d.ts
+++ b/client/dist/src/PublicPaymentOptions.d.ts
@@ -8,7 +8,7 @@ export interface NimiqSpecifics {
     sender?: string;
     forceSender?: boolean;
     recipient?: string;
-    recipientType?: Nimiq.Account.Type;
+    recipientType?: Nimiq.AccountType;
 }
 export declare type NimiqDirectPaymentOptions = PaymentOptions<Currency.NIM, PaymentType.DIRECT>;
 export interface BitcoinSpecifics {
diff --git a/client/dist/src/PublicRequestTypes.d.ts b/client/dist/src/PublicRequestTypes.d.ts
index dd9bf3884..b3146ea00 100644
--- a/client/dist/src/PublicRequestTypes.d.ts
+++ b/client/dist/src/PublicRequestTypes.d.ts
@@ -34,7 +34,7 @@ export declare enum AccountType {
     BIP39 = 2,
     LEDGER = 3
 }
-export { 
+export {
 /** @deprecated Use AccountType instead */
 AccountType as WalletType, };
 export interface BasicRequest {
@@ -72,7 +72,7 @@ export interface ChooseAddressResult extends Address {
 export interface SignTransactionRequest extends BasicRequest {
     sender: string;
     recipient: string;
-    recipientType?: Nimiq.Account.Type | 3;
+    recipientType?: Nimiq.AccountType | 3;
     recipientLabel?: string;
     value: number;
     fee?: number;
@@ -91,7 +91,7 @@ export interface NimiqCheckoutRequest extends BasicRequest {
     sender?: string;
     forceSender?: boolean;
     recipient: string;
-    recipientType?: Nimiq.Account.Type;
+    recipientType?: Nimiq.AccountType;
     value: number;
     fee?: number;
     extraData?: Bytes;
@@ -190,9 +190,9 @@ export interface SignedTransaction {
         signerPublicKey: Uint8Array;
         signature: Uint8Array;
         sender: string;
-        senderType: Nimiq.Account.Type | 3;
+        senderType: Nimiq.AccountType | 3;
         recipient: string;
-        recipientType: Nimiq.Account.Type | 3;
+        recipientType: Nimiq.AccountType | 3;
         value: number;
         fee: number;
         validityStartHeight: number;
@@ -375,7 +375,7 @@ export interface Address {
     label: string;
 }
 export interface VestingContract {
-    type: Nimiq.Account.Type.VESTING;
+    type: Nimiq.AccountType.VESTING;
     address: string;
     label: string;
     owner: string;
@@ -385,7 +385,7 @@ export interface VestingContract {
     totalAmount: number;
 }
 export interface HashedTimeLockedContract {
-    type: Nimiq.Account.Type.HTLC;
+    type: Nimiq.AccountType.HTLC;
     address: string;
     label: string;
     sender: string;
diff --git a/docs/api-methods/10_checkout.md b/docs/api-methods/10_checkout.md
index 153e20ed0..edd70d378 100644
--- a/docs/api-methods/10_checkout.md
+++ b/docs/api-methods/10_checkout.md
@@ -77,7 +77,7 @@ const signedTransaction = await hubApi.checkout(options);
 | `forceSender` | boolean | no | Whether to force the submitted sender address. If this option is `true`, an exception is thrown when either the sender address does not exist or does not have sufficient balance. When `false` (default), the user will be shown the address selector instead. (Only relevant in connection with the `sender` option.) |
 | `validityDuration` | number | no | The duration (in number of blocks) that the signed transaction should be valid for. The maximum and default is 120. |
 | `flags` | number | no | A [`Nimiq.Transaction.Flag`](https://nimiq-network.github.io/developer-reference/chapters/transactions.html#extended-transaction), only required if the transaction should create a contract. |
-| `recipientType` | number | no | The [`Nimiq.Account.Type`](https://nimiq-network.github.io/developer-reference/chapters/accounts-and-contracts.html#contracts) of the recipient. Only required if the transaction should create a contract. |
+| `recipientType` | number | no | The [`Nimiq.AccountType`](https://nimiq-network.github.io/developer-reference/chapters/accounts-and-contracts.html#contracts) of the recipient. Only required if the transaction should create a contract. |
 
 ## Result
 
@@ -93,10 +93,10 @@ interface SignedTransaction {
         signature: Uint8Array;             // Serialized signature of the signer
 
         sender: string;                    // Human-readable address of sender
-        senderType: Nimiq.Account.Type;    // 0, 1, 2 - see recipientType above
+        senderType: Nimiq.AccountType;    // 0, 1, 2, 3 - see recipientType above
 
         recipient: string;                 // Human-readable address of recipient
-        recipientType: Nimiq.Account.Type; // 0, 1, 2 - see above
+        recipientType: Nimiq.AccountType; // 0, 1, 2, 3 - see above
 
         value: number;
         fee: number;
diff --git a/docs/api-methods/40_sign-transaction.md b/docs/api-methods/40_sign-transaction.md
index a586b68ff..fe93a589f 100644
--- a/docs/api-methods/40_sign-transaction.md
+++ b/docs/api-methods/40_sign-transaction.md
@@ -102,7 +102,7 @@ const signedTransaction = await hubApi.signTransaction(options);
 | `fee` | number | no | Transaction fee in luna. Default: 0 |
 | `extraData` | string or Uint8Array | no | Extra data that should be sent with the transaction. |
 | `flags` | number | no | A [`Nimiq.Transaction.Flag`](https://nimiq-network.github.io/developer-reference/chapters/transactions.html#extended-transaction), only required if the transaction should create a contract. |
-| `recipientType` | number | no | The [`Nimiq.Account.Type`](https://nimiq-network.github.io/developer-reference/chapters/accounts-and-contracts.html#contracts) of the recipient. Only required if the transaction should create a contract. |
+| `recipientType` | number | no | The [`Nimiq.AccountType`](https://nimiq-network.github.io/developer-reference/chapters/accounts-and-contracts.html#contracts) of the recipient. Only required if the transaction should create a contract. |
 
 ## Result
 
@@ -118,10 +118,10 @@ interface SignedTransaction {
         signature: Uint8Array;             // Serialized signature of the signer
 
         sender: string;                    // Human-readable address of sender
-        senderType: Nimiq.Account.Type;    // 0, 1, 2 - see recipientType above
+        senderType: Nimiq.AccountType;    // 0, 1, 2, 3 - see recipientType above
 
         recipient: string;                 // Human-readable address of recipient
-        recipientType: Nimiq.Account.Type; // 0, 1, 2 - see above
+        recipientType: Nimiq.AccountType; // 0, 1, 2, 3 - see above
 
         value: number;
         fee: number;
diff --git a/package.json b/package.json
index d695c394e..7ac100ee9 100644
--- a/package.json
+++ b/package.json
@@ -26,7 +26,7 @@
         "@nimiq/fastspot-api": "^1.8.0",
         "@nimiq/iqons": "^1.5.2",
         "@nimiq/keyguard-client": "https://gitpkg.vercel.app/nimiq/keyguard?scripts.postinstall=cd%20client%20%26%26%20.%2Fbuild-gitpkg.sh&239c43cc712da603ce744eeede76f3b9d56d16b2",
-        "@nimiq/ledger-api": "^3.0.0",
+        "@nimiq/ledger-api": "github:nimiq/ledger-api#a7179c2d207c1deaeb2ab777ce6ad994e59f9c5f",
         "@nimiq/network-client": "^0.6.2",
         "@nimiq/oasis-api": "^1.1.1",
         "@nimiq/rpc": "^0.4.1",
diff --git a/src/CashlinkApp.vue b/src/CashlinkApp.vue
index 8f145f662..89bd7736e 100644
--- a/src/CashlinkApp.vue
+++ b/src/CashlinkApp.vue
@@ -21,7 +21,6 @@ import { Component, Vue } from 'vue-property-decorator';
 import { LoadingSpinner } from '@nimiq/vue-components';
 import CashlinkReceive from './views/CashlinkReceive.vue';
 import { CashlinkTheme } from '../client/PublicRequestTypes';
-import { loadNimiq } from './lib/Helpers';
 
 import '@nimiq/style/nimiq-style.min.css';
 import '@nimiq/vue-components/dist/NimiqVueComponents.css';
@@ -32,10 +31,7 @@ export default class CashlinkApp extends Vue {
     private isDarkTheme = false;
 
     public async created() {
-        await Promise.all([
-            this.$store.dispatch('initWallets'),
-            loadNimiq(),
-        ]);
+        await this.$store.dispatch('initWallets');
         this.loading = false;
     }
 
diff --git a/src/components/CheckoutCardNimiq.vue b/src/components/CheckoutCardNimiq.vue
index cb3374d72..b34cc5c5a 100644
--- a/src/components/CheckoutCardNimiq.vue
+++ b/src/components/CheckoutCardNimiq.vue
@@ -247,10 +247,10 @@ class CheckoutCardNimiq
             const balance = balances.get(accountOrContract.userFriendlyAddress);
             if (balance === undefined) continue;
 
-            if ('type' in accountOrContract && accountOrContract.type === Nimiq.Account.Type.VESTING) {
+            if ('type' in accountOrContract && accountOrContract.type === Nimiq.AccountType.Vesting) {
                 // Calculate available amount for vesting contract
                 accountOrContract.balance = (accountOrContract as VestingContractInfo)
-                    .calculateAvailableAmount(this.height, balance);
+                    .calculateAvailableAmount(balance);
             } else {
                 accountOrContract.balance = balance;
             }
@@ -392,10 +392,10 @@ class CheckoutCardNimiq
                     keyLabel: senderAccount.labelForKeyguard,
 
                     sender: (senderContract || signer).address.serialize(),
-                    senderType: senderContract ? senderContract.type : Nimiq.Account.Type.BASIC,
+                    senderType: senderContract ? senderContract.type : Nimiq.AccountType.Basic,
                     senderLabel: (senderContract || signer).label,
                     recipient: this.paymentOptions.protocolSpecific.recipient!.serialize(),
-                    recipientType: this.paymentOptions.protocolSpecific.recipientType,
+                    recipientType: this.paymentOptions.protocolSpecific.recipientType as any, // TODO: Remove when Keyguard Client is updated
                     // recipientLabel: '', // Checkout is using the shopOrigin instead
                     value: this.paymentOptions.amount,
                     fee: this.paymentOptions.fee,
diff --git a/src/components/Network.vue b/src/components/Network.vue
index a12bcad09..ca054534c 100644
--- a/src/components/Network.vue
+++ b/src/components/Network.vue
@@ -3,36 +3,36 @@
 <script lang="ts">
 import { Component, Vue } from 'vue-property-decorator';
 import { SignedTransaction } from '../../client/PublicRequestTypes';
-import { NetworkClient, DetailedPlainTransaction } from '@nimiq/network-client';
-import Config from 'config';
-import { loadNimiq, setHistoryStorage, getHistoryStorage } from '../lib/Helpers';
+import { setHistoryStorage, getHistoryStorage } from '../lib/Helpers';
 import { labelVestingContract } from '../lib/LabelingMachine';
 import { VestingContractInfo } from '../lib/ContractInfo';
+import { NetworkClient } from '../lib/NetworkClient';
+import { lunasToCoins } from '../lib/NimiqUtils';
 
 @Component
 class Network extends Vue {
-    private static _hasOrSyncsOnTopOfConsensus = false;
+    private boundListeners: Array<number> = [];
 
-    private boundListeners: Array<[NetworkClient.Events, (...args: any[]) => void]> = [];
-
-    public async createTx({
+    public createTx({
         sender,
-        senderType = Nimiq.Account.Type.BASIC,
+        senderType = Nimiq.AccountType.Basic,
+        senderData,
         recipient,
-        recipientType = Nimiq.Account.Type.BASIC,
+        recipientType = Nimiq.AccountType.Basic,
         value,
         fee = 0,
         validityStartHeight,
-        flags = Nimiq.Transaction.Flag.NONE,
+        flags = 0 /* Nimiq.Transaction.Flag.NONE */,
         data,
         signerPubKey,
         signature,
         proofPrefix = new Uint8Array(0),
     }: {
         sender: Nimiq.Address | Uint8Array,
-        senderType?: Nimiq.Account.Type | 3 /* Staking */,
+        senderType?: Nimiq.AccountType,
+        senderData?: Uint8Array,
         recipient: Nimiq.Address | Uint8Array,
-        recipientType?: Nimiq.Account.Type,
+        recipientType?: Nimiq.AccountType,
         value: number,
         fee?: number,
         validityStartHeight: number,
@@ -41,90 +41,74 @@ class Network extends Vue {
         signerPubKey: Nimiq.PublicKey | Uint8Array,
         signature?: Nimiq.Signature | Uint8Array,
         proofPrefix?: Uint8Array,
-    }): Promise<Nimiq.Transaction> {
+    }): Nimiq.Transaction {
         if (!(sender instanceof Nimiq.Address)) sender = new Nimiq.Address(sender);
         if (!(recipient instanceof Nimiq.Address)) recipient = new Nimiq.Address(recipient);
         if (!(signerPubKey instanceof Nimiq.PublicKey)) signerPubKey = new Nimiq.PublicKey(signerPubKey);
-        if (signature && !(signature instanceof Nimiq.Signature)) signature = new Nimiq.Signature(signature);
-
-        await loadNimiq();
+        if (signature && !(signature instanceof Nimiq.Signature)) signature = Nimiq.Signature.deserialize(signature);
 
         if (
             (data && data.length > 0)
-            || senderType !== Nimiq.Account.Type.BASIC
-            || recipientType !== Nimiq.Account.Type.BASIC
-            || flags !== Nimiq.Transaction.Flag.NONE
+            || senderType !== Nimiq.AccountType.Basic
+            || recipientType !== Nimiq.AccountType.Basic
+            || flags !== 0 /* Nimiq.Transaction.Flag.NONE */
         ) {
             let proof: Nimiq.SerialBuffer | undefined;
             if (signature) {
-                proof = new Nimiq.SerialBuffer(proofPrefix.length + Nimiq.SignatureProof.SINGLE_SIG_SIZE);
+                // 32 publicKey + 1 empty merkle path + 64 signature
+                proof = new Nimiq.SerialBuffer(proofPrefix.length + 32 + 1 + 64);
                 proof.write(proofPrefix);
                 proof.write(Nimiq.SignatureProof.singleSig(signerPubKey, signature).serialize());
             }
 
-            const tx = new Nimiq.ExtendedTransaction(
+            const tx = new Nimiq.Transaction(
                 sender,
                 // @ts-ignore Staking type not yet supported
                 senderType,
+                senderData,
                 recipient,
                 recipientType,
-                value || 1,
-                fee,
-                validityStartHeight,
-                Math.min(flags, Nimiq.Transaction.Flag.CONTRACT_CREATION),
                 data || new Uint8Array(0),
-                proof,
+                BigInt(value),
+                BigInt(fee),
+                flags,
+                validityStartHeight,
                 5,
             );
-
-            if (flags === 0b10) { // Signalling
-                // @ts-ignore Private property access
-                tx._value = 0;
-                // @ts-ignore Private property access
-                tx._flags = 0b10;
-            }
-
+            if (proof) tx.proof = proof;
             return tx;
         } else {
-            return new Nimiq.BasicTransaction(
-                signerPubKey,
+            const tx = Nimiq.TransactionBuilder.newBasic(
+                signerPubKey.toAddress(),
                 recipient,
-                value,
-                fee,
+                BigInt(value),
+                BigInt(fee),
                 validityStartHeight,
-                signature,
                 5,
             );
+            if (signature) tx.proof = Nimiq.SignatureProof.singleSig(signerPubKey, signature).serialize();
+            return tx;
         }
     }
 
-    public async makeSignTransactionResult(
-        tx: Omit<Nimiq.Transaction, 'senderType'> & { senderType: Nimiq.Account.Type | 3 },
-    ): Promise<SignedTransaction> {
-        await loadNimiq(); // needed for hash computation
-
-        const parsedProof = (tx.senderType === 3
-            ? (Nimiq.Account as any).TYPE_MAP.get(Nimiq.Account.Type.BASIC).proofToPlain(tx.proof.subarray(1))
-            : (Nimiq.Account as any).TYPE_MAP.get(tx.senderType).proofToPlain(tx.proof)) as ReturnType<
-                typeof Nimiq.BasicAccount.proofToPlain
-                | typeof Nimiq.HashedTimeLockedContract.proofToPlain
-                | typeof Nimiq.VestingContract.proofToPlain
-            >;
-        const signerPublicKeyHex = 'publicKey' in parsedProof
-            ? parsedProof.publicKey
-            : 'creatorPublicKey' in parsedProof
-                ? parsedProof.creatorPublicKey
+    public makeSignTransactionResult(tx: Nimiq.Transaction): SignedTransaction {
+        const plain = tx.toPlain();
+
+        const signerPublicKeyHex = 'publicKey' in plain.proof
+            ? plain.proof.publicKey
+            : 'creatorPublicKey' in plain.proof
+                ? plain.proof.creatorPublicKey
                 : (() => { throw new Error('Unsupported transaction proof'); })();
-        const signatureHex = 'signature' in parsedProof
-            ? parsedProof.signature
-            : 'creatorSignature' in parsedProof
-                ? parsedProof.creatorSignature
+        const signatureHex = 'signature' in plain.proof
+            ? plain.proof.signature
+            : 'creatorSignature' in plain.proof
+                ? plain.proof.creatorSignature
                 : (() => { throw new Error('Unsupported transaction proof'); })();
 
         const result: SignedTransaction = {
             transaction: tx.serialize(),
-            serializedTx: Nimiq.BufferUtils.toHex(tx.serialize()),
-            hash: tx.hash().toHex(),
+            serializedTx: tx.toHex(),
+            hash: plain.transactionHash,
 
             raw: {
                 signerPublicKey: Nimiq.BufferUtils.fromHex(signerPublicKeyHex),
@@ -136,8 +120,8 @@ class Network extends Vue {
                 recipient: tx.recipient.toUserFriendlyAddress(),
                 recipientType: tx.recipientType,
 
-                value: tx.value,
-                fee: tx.fee,
+                value: Number(tx.value),
+                fee: Number(tx.fee),
                 validityStartHeight: tx.validityStartHeight,
 
                 extraData: tx.data,
@@ -155,27 +139,24 @@ class Network extends Vue {
      * fires its 'transaction-relayed' event for that transaction.
      */
     public async sendToNetwork(tx: Nimiq.Transaction): Promise<SignedTransaction> {
-        await loadNimiq(); // needed for hash computation
-
         // Store the transaction in the history state to be able to resend the transaction when the user reloads the
         // window in case it failed to relay it to the network. Not using localstorage or sessionstorage as the
         // transaction should not be broadcast anymore when user closes page, accepting that it failed to send.
         let unrelayedTransactionMap = getHistoryStorage(Network.HISTORY_KEY_UNRELAYED_TRANSACTIONS) || {};
-        const base64Hash = tx.hash().toBase64();
+        const base64Hash = Nimiq.BufferUtils.toBase64(Nimiq.BufferUtils.fromHex(tx.hash()));
         unrelayedTransactionMap[base64Hash] = tx.serialize();
         setHistoryStorage(Network.HISTORY_KEY_UNRELAYED_TRANSACTIONS, unrelayedTransactionMap);
 
-        const signedTx = await this.makeSignTransactionResult(tx);
+        const signedTx = this.makeSignTransactionResult(tx);
         const client = await this.getNetworkClient();
 
         const txObjToSend = Object.assign({}, signedTx.raw, {
             senderPubKey: signedTx.raw.signerPublicKey,
-            value: Nimiq.Policy.satoshisToCoins(signedTx.raw.value),
-            fee: Nimiq.Policy.satoshisToCoins(signedTx.raw.fee),
+            value: lunasToCoins(signedTx.raw.value),
+            fee: lunasToCoins(signedTx.raw.fee),
         });
 
-        const plainTx = await client.relayTransaction(txObjToSend) as
-            ReturnType<Nimiq.Client.TransactionDetails['toPlain']>;
+        const plainTx = await client.relayTransaction(txObjToSend);
 
         if (plainTx.state === 'expired') {
             throw new Error(Network.Errors.TRANSACTION_EXPIRED);
@@ -194,11 +175,11 @@ class Network extends Vue {
 
     public getUnrelayedTransactions(filter?: {
         sender?: Nimiq.Address,
-        senderType?: Nimiq.Account.Type,
+        senderType?: Nimiq.AccountType,
         recipient?: Nimiq.Address,
-        recipientType?: Nimiq.Account.Type,
-        value?: number,
-        fee?: number,
+        recipientType?: Nimiq.AccountType,
+        value?: BigInt,
+        fee?: BigInt,
         validityStartHeight?: number,
         flags?: number,
         data?: Uint8Array,
@@ -207,9 +188,9 @@ class Network extends Vue {
         const serializedTransactions: Uint8Array[]
             = Object.values(getHistoryStorage(Network.HISTORY_KEY_UNRELAYED_TRANSACTIONS));
         const transactions = serializedTransactions.map((serializedTx: Uint8Array) =>
-            Nimiq.Transaction.unserialize(new Nimiq.SerialBuffer(serializedTx)));
+            Nimiq.Transaction.fromAny(serializedTx));
         if (!filter) return transactions;
-        return transactions.filter((tx: Nimiq.Transaction) =>
+        return transactions.filter((tx) =>
             (filter.sender === undefined || tx.sender.equals(filter.sender))
             && (filter.senderType === undefined || tx.senderType === filter.senderType)
             && (filter.recipient === undefined || tx.recipient.equals(filter.recipient))
@@ -224,11 +205,7 @@ class Network extends Vue {
 
     public async getBlockchainHeight(): Promise<number> {
         const client = await this.getNetworkClient();
-        if (Network._hasOrSyncsOnTopOfConsensus) return client.headInfo.height;
-        return new Promise((resolve) => this.$once(Network.Events.CONSENSUS_ESTABLISHED, () =>
-            // At the time of the consensus event, the new head is not populated yet. Therefore, instead of accessing
-            // client.headInfo we wait for the HEAD_CHANGE which is triggered immediately after CONSENSUS_ESTABLISHED
-            this.$once(Network.Events.HEAD_CHANGE, (head: { height: number }) => resolve(head.height))));
+        return client.getHeight();
     }
 
     public async getBalances(addresses: string[]): Promise<Map<string, number>> {
@@ -244,97 +221,42 @@ class Network extends Vue {
             labelVestingContract(),
             Nimiq.Address.fromString(contract.address),
             Nimiq.Address.fromString(contract.owner),
-            contract.start,
-            Nimiq.Policy.coinsToSatoshis(contract.stepAmount),
-            contract.stepBlocks,
-            Nimiq.Policy.coinsToSatoshis(contract.totalAmount),
+            contract.startTime,
+            contract.stepAmount,
+            contract.timeStep,
+            contract.totalAmount,
         ));
     }
 
     public async getNetworkClient(): Promise<NetworkClient> {
-        if (!NetworkClient.hasInstance()) {
-            NetworkClient.createInstance(Config.networkEndpoint);
-        }
         // Make sure the client is initialized
-        await NetworkClient.Instance.init();
-
-        if (this.boundListeners.length === 0) {
-            this._registerNetworkListener(NetworkClient.Events.API_READY,
-                () => this.$emit(Network.Events.API_READY));
-            this._registerNetworkListener(NetworkClient.Events.API_FAIL,
-                (e: Error) => this.$emit(Network.Events.API_FAIL, e));
-            this._registerNetworkListener(NetworkClient.Events.CONSENSUS_SYNCING,
-                () => this.$emit(Network.Events.CONSENSUS_SYNCING));
-            this._registerNetworkListener(NetworkClient.Events.CONSENSUS_ESTABLISHED,
-                () => this.$emit(Network.Events.CONSENSUS_ESTABLISHED));
-            this._registerNetworkListener(NetworkClient.Events.CONSENSUS_LOST,
-                () => this.$emit(Network.Events.CONSENSUS_LOST));
-            this._registerNetworkListener(NetworkClient.Events.PEERS_CHANGED,
-                (count: number) => this.$emit(Network.Events.PEERS_CHANGED, count));
-            this._registerNetworkListener(NetworkClient.Events.BALANCES_CHANGED,
-                (balances: Map<string, number>) => this.$emit(Network.Events.BALANCES_CHANGED, balances));
-            this._registerNetworkListener(NetworkClient.Events.TRANSACTION_PENDING,
-                (txInfo: Partial<DetailedPlainTransaction>) => this.$emit(Network.Events.TRANSACTION_PENDING, txInfo));
-            this._registerNetworkListener(NetworkClient.Events.TRANSACTION_EXPIRED,
-                (hash: string) => this.$emit(Network.Events.TRANSACTION_EXPIRED, hash));
-            this._registerNetworkListener(NetworkClient.Events.TRANSACTION_MINED,
-                (txInfo: DetailedPlainTransaction) => this.$emit(Network.Events.TRANSACTION_MINED, txInfo));
-            this._registerNetworkListener(NetworkClient.Events.TRANSACTION_RELAYED,
-                (txInfo: Partial<DetailedPlainTransaction>) => this.$emit(Network.Events.TRANSACTION_RELAYED, txInfo));
-            this._registerNetworkListener(NetworkClient.Events.HEAD_CHANGE,
-                (headInfo: {height: number, globalHashrate: number}) =>
-                    this.$emit(Network.Events.HEAD_CHANGE, headInfo));
-
-            this._fireInitialEvents();
+        try {
+            await NetworkClient.Instance.init();
+            this.$emit(Network.Events.API_READY);
+        } catch (error) {
+            this.$emit(Network.Events.API_FAIL);
+            throw error;
         }
 
-        return NetworkClient.Instance;
-    }
+        const client = await NetworkClient.Instance.innerClient;
 
-    private created() {
-        this.$on(Network.Events.CONSENSUS_ESTABLISHED, () => {
-            Network._hasOrSyncsOnTopOfConsensus = true;
-        });
-        this.$on(Network.Events.CONSENSUS_LOST, () => {
-            Network._hasOrSyncsOnTopOfConsensus = false;
-        });
-    }
-
-    private destroyed() {
-        if (!NetworkClient.hasInstance()) return;
-        for (const [event, listener] of this.boundListeners) {
-            NetworkClient.Instance.off(event, listener);
+        if (await client.isConsensusEstablished()) {
+            this.$emit(Network.Events.CONSENSUS_ESTABLISHED);
+        } else {
+            this.$emit(Network.Events.CONSENSUS_SYNCING);
         }
-    }
+        this.boundListeners.push(await client.addConsensusChangedListener((state) => {
+            if (state === 'syncing') this.$emit(Network.Events.CONSENSUS_SYNCING);
+            if (state === 'established') this.$emit(Network.Events.CONSENSUS_ESTABLISHED);
+        }));
 
-    private _registerNetworkListener(event: NetworkClient.Events, listener: (...args: any[]) => void) {
-        if (!NetworkClient.hasInstance()) console.warn('Using default instance with default endpoint.');
-        NetworkClient.Instance.on(event, listener);
-        this.boundListeners.push([event, listener]);
+        return NetworkClient.Instance;
     }
 
-    private _fireInitialEvents() {
-        if (!NetworkClient.hasInstance()) return;
-        const networkClient = NetworkClient.Instance;
-        if (networkClient.apiLoadingState === 'ready') this.$emit(Network.Events.API_READY);
-        else if (networkClient.apiLoadingState === 'failed') this.$emit(Network.Events.API_FAIL);
-
-        if (networkClient.consensusState === 'syncing') this.$emit(Network.Events.CONSENSUS_SYNCING);
-        else if (networkClient.consensusState === 'established') this.$emit(Network.Events.CONSENSUS_ESTABLISHED);
-        else if (networkClient.consensusState === 'lost') this.$emit(Network.Events.CONSENSUS_LOST);
-        Network._hasOrSyncsOnTopOfConsensus = Network._hasOrSyncsOnTopOfConsensus
-            || networkClient.consensusState === 'established';
-
-        if (networkClient.peerCount !== 0) this.$emit(Network.Events.PEERS_CHANGED, networkClient.peerCount);
-
-        if (networkClient.balances.size !== 0) this.$emit(Network.Events.BALANCES_CHANGED, networkClient.balances);
-
-        for (const tx of networkClient.pendingTransactions) this.$emit(Network.Events.TRANSACTION_PENDING, tx);
-        for (const txHash of networkClient.expiredTransactions) this.$emit(Network.Events.TRANSACTION_EXPIRED, txHash);
-        for (const tx of networkClient.minedTransactions) this.$emit(Network.Events.TRANSACTION_MINED, tx);
-        for (const tx of networkClient.relayedTransactions) this.$emit(Network.Events.TRANSACTION_RELAYED, tx);
-
-        if (networkClient.headInfo.height !== 0) this.$emit(Network.Events.HEAD_CHANGE, networkClient.headInfo);
+    private destroyed() {
+        for (const handle of this.boundListeners) {
+            NetworkClient.Instance.innerClient.then((client) => client && client.removeListener(handle));
+        }
     }
 }
 
@@ -344,14 +266,8 @@ namespace Network {
         API_FAIL = 'api-fail',
         CONSENSUS_SYNCING = 'consensus-syncing',
         CONSENSUS_ESTABLISHED = 'consensus-established',
-        CONSENSUS_LOST = 'consensus-lost',
-        PEERS_CHANGED = 'peer-count',
-        BALANCES_CHANGED = 'balances',
         TRANSACTION_PENDING = 'transaction-pending',
-        TRANSACTION_EXPIRED = 'transaction-expired',
-        TRANSACTION_MINED = 'transaction-mined',
         TRANSACTION_RELAYED = 'transaction-relayed',
-        HEAD_CHANGE = 'head-change',
     }
 
     export const enum Errors {
diff --git a/src/config/config.local.ts b/src/config/config.local.ts
index 2ca3adc63..4f13f8b87 100644
--- a/src/config/config.local.ts
+++ b/src/config/config.local.ts
@@ -5,7 +5,7 @@ import { POLYGON_NETWORK_TEST } from '../lib/polygon/PolygonConstants';
 
 export default {
     keyguardEndpoint: window.location.protocol + '//' + window.location.hostname + ':8000/src',
-    ledgerApiNimiqVersion: 'legacy' as LedgerApiNimiqVersion.LEGACY,
+    ledgerApiNimiqVersion: 'albatross' as LedgerApiNimiqVersion.ALBATROSS,
     network: NETWORK_TEST,
     networkEndpoint: 'https://network.nimiq-testnet.com',
     seedNodes: [
diff --git a/src/config/config.mainnet.ts b/src/config/config.mainnet.ts
index a10595e81..9c29c44cf 100644
--- a/src/config/config.mainnet.ts
+++ b/src/config/config.mainnet.ts
@@ -5,7 +5,7 @@ import { POLYGON_NETWORK_MAIN } from '../lib/polygon/PolygonConstants';
 
 export default {
     keyguardEndpoint: 'https://keyguard.nimiq.com',
-    ledgerApiNimiqVersion: 'legacy' as LedgerApiNimiqVersion.LEGACY,
+    ledgerApiNimiqVersion: 'albatross' as LedgerApiNimiqVersion.ALBATROSS,
     network: NETWORK_MAIN,
     networkEndpoint: 'https://network.nimiq.com',
     seedNodes: [],
diff --git a/src/config/config.testnet.ts b/src/config/config.testnet.ts
index 12dab035b..873436636 100644
--- a/src/config/config.testnet.ts
+++ b/src/config/config.testnet.ts
@@ -5,7 +5,7 @@ import { POLYGON_NETWORK_TEST } from '../lib/polygon/PolygonConstants';
 
 export default {
     keyguardEndpoint: process.env.VUE_APP_KEYGUARD_URL,
-    ledgerApiNimiqVersion: 'legacy' as LedgerApiNimiqVersion.LEGACY,
+    ledgerApiNimiqVersion: 'albatross' as LedgerApiNimiqVersion.ALBATROSS,
     network: NETWORK_TEST,
     networkEndpoint: 'https://network.nimiq-testnet.com',
     seedNodes: [
diff --git a/src/export.ts b/src/export.ts
index 4f727a264..80739269e 100644
--- a/src/export.ts
+++ b/src/export.ts
@@ -1,11 +1,8 @@
 import Cashlink from './lib/Cashlink';
 import { CashlinkStore } from './lib/CashlinkStore';
-import { loadNimiq } from './lib/Helpers';
 import { CashlinkState } from '../client/PublicRequestTypes';
 
 async function main() {
-    await loadNimiq();
-
     const store = CashlinkStore.Instance;
 
     const cashlinkEntries = await store.list();
diff --git a/src/i18n/en.po b/src/i18n/en.po
index 43a91b4b6..30e0a0929 100644
--- a/src/i18n/en.po
+++ b/src/i18n/en.po
@@ -27,11 +27,11 @@ msgstr ""
 msgid "30 seconds, no email, no download."
 msgstr ""
 
-#: src/views/CashlinkReceive.vue:206
+#: src/views/CashlinkReceive.vue:207
 msgid "404 - Cash not found"
 msgstr ""
 
-#: src/views/SetupSwapSuccess.vue:145
+#: src/views/SetupSwapSuccess.vue:143
 msgid "503 Service unavailable - please try again later"
 msgstr ""
 
@@ -47,7 +47,7 @@ msgstr ""
 msgid "Account Created"
 msgstr ""
 
-#: src/views/Migrate.vue:266
+#: src/views/Migrate.vue:267
 msgid "Accounts updated!"
 msgstr ""
 
@@ -198,14 +198,10 @@ msgstr ""
 msgid "Bitcoin activated"
 msgstr ""
 
-#: src/views/SetupSwapSuccess.vue:627
+#: src/views/SetupSwapSuccess.vue:636
 msgid "Bitcoin HTLC invalid: {error}"
 msgstr ""
 
-#: src/views/AddVestingContract.vue:36
-msgid "Blocks/Step:"
-msgstr ""
-
 #: src/lib/LabelingMachine.ts:31
 msgid "Blue Account"
 msgstr ""
@@ -241,7 +237,7 @@ msgstr ""
 msgid "Cancel payment"
 msgstr ""
 
-#: src/views/CashlinkReceive.vue:258
+#: src/views/CashlinkReceive.vue:257
 msgid "Cashlink claimed!"
 msgstr ""
 
@@ -253,19 +249,19 @@ msgstr ""
 msgid "Cashlink created."
 msgstr ""
 
-#: src/views/CashlinkReceive.vue:306
+#: src/views/CashlinkReceive.vue:305
 msgid "Cashlink empty :("
 msgstr ""
 
-#: src/views/CashlinkReceive.vue:299
+#: src/views/CashlinkReceive.vue:298
 msgid "Cashlink funding"
 msgstr ""
 
-#: src/views/CashlinkReceive.vue:303
+#: src/views/CashlinkReceive.vue:302
 msgid "Cashlink is empty"
 msgstr ""
 
-#: src/views/CashlinkReceive.vue:298
+#: src/views/CashlinkReceive.vue:297
 msgid "Cashlink not funded"
 msgstr ""
 
@@ -277,7 +273,7 @@ msgstr ""
 msgid "Check your Backup | Check your Backups"
 msgstr ""
 
-#: src/views/CashlinkReceive.vue:296
+#: src/views/CashlinkReceive.vue:295
 msgid "Checking status"
 msgstr ""
 
@@ -316,15 +312,15 @@ msgstr ""
 msgid "Choose which Nimiq address to use."
 msgstr ""
 
-#: src/views/CashlinkReceive.vue:297
+#: src/views/CashlinkReceive.vue:296
 msgid "Claim Cashlink"
 msgstr ""
 
-#: src/views/CashlinkReceive.vue:347
+#: src/views/CashlinkReceive.vue:346
 msgid "Claim your Cash"
 msgstr ""
 
-#: src/views/CashlinkReceive.vue:236
+#: src/views/CashlinkReceive.vue:234
 msgid "Claiming Cashlink"
 msgstr ""
 
@@ -344,7 +340,7 @@ msgstr ""
 msgid "Collecting payment details"
 msgstr ""
 
-#: src/views/SetupSwapLedger.vue:987
+#: src/views/SetupSwapLedger.vue:991
 msgid "Confirm {outgoingOrIncoming} transaction on Ledger"
 msgstr ""
 
@@ -378,15 +374,15 @@ msgstr ""
 msgid "Confirm using your Ledger"
 msgstr ""
 
-#: src/views/CashlinkReceive.vue:358
+#: src/views/CashlinkReceive.vue:357
 msgid "Congrats, somebody gifted you a Nimiq Cashlink."
 msgstr ""
 
-#: src/views/CashlinkReceive.vue:357
+#: src/views/CashlinkReceive.vue:356
 msgid "Congrats, you just opened a Nimiq Cashlink."
 msgstr ""
 
-#: src/views/CashlinkReceive.vue:353
+#: src/views/CashlinkReceive.vue:352
 msgid "Congrats, you received a Nimiq Gift Card."
 msgstr ""
 
@@ -407,24 +403,25 @@ msgstr ""
 msgid "Connect your Ledger hardware wallet."
 msgstr ""
 
-#: src/views/Migrate.vue:143
-#: src/views/Migrate.vue:285
+#: src/views/Migrate.vue:144
+#: src/views/Migrate.vue:286
 msgid "Connecting to Keyguard..."
 msgstr ""
 
 #: src/views/CashlinkManage.vue:133
-#: src/views/CheckoutTransmission.vue:42
+#: src/views/CheckoutTransmission.vue:40
 #: src/views/LoginSuccess.vue:44
 msgid "Connecting to network..."
 msgstr ""
 
-#: src/views/CashlinkReceive.vue:237
+#: src/views/CashlinkReceive.vue:235
 msgid "Connecting to Nimiq..."
 msgstr ""
 
-#: src/components/CheckoutCardNimiq.vue:285
+#: src/components/CheckoutCardNimiq.vue:284
+#: src/components/CheckoutCardNimiq.vue:289
 #: src/views/CashlinkManage.vue:186
-#: src/views/CheckoutTransmission.vue:120
+#: src/views/CheckoutTransmission.vue:116
 msgid "Contacting seed nodes..."
 msgstr ""
 
@@ -477,11 +474,11 @@ msgid "Creating your Account"
 msgstr ""
 
 #: src/views/CashlinkManage.vue:229
-#: src/views/SignTransactionLedger.vue:485
+#: src/views/SignTransactionLedger.vue:491
 msgid "Creating your Cashlink"
 msgstr ""
 
-#: src/views/Migrate.vue:230
+#: src/views/Migrate.vue:231
 msgid "Detecting vesting contracts..."
 msgstr ""
 
@@ -514,7 +511,7 @@ msgstr ""
 msgid "Enter your PIN"
 msgstr ""
 
-#: src/views/CashlinkCreate.vue:168
+#: src/views/CashlinkCreate.vue:167
 msgid "express"
 msgstr ""
 
@@ -540,7 +537,7 @@ msgstr ""
 msgid "Fetching Addresses Failed"
 msgstr ""
 
-#: src/views/SetupSwapSuccess.vue:616
+#: src/views/SetupSwapSuccess.vue:625
 msgid "Fetching Bitcoin HTLC..."
 msgstr ""
 
@@ -548,11 +545,11 @@ msgstr ""
 msgid "Fetching contract information..."
 msgstr ""
 
-#: src/views/SetupSwapSuccess.vue:624
+#: src/views/SetupSwapSuccess.vue:633
 msgid "Fetching swap data failed: {error}"
 msgstr ""
 
-#: src/views/SetupSwapSuccess.vue:612
+#: src/views/SetupSwapSuccess.vue:621
 msgid "Fetching swap data..."
 msgstr ""
 
@@ -570,7 +567,7 @@ msgstr ""
 msgid "Finish"
 msgstr ""
 
-#: src/views/CashlinkCreate.vue:158
+#: src/views/CashlinkCreate.vue:157
 msgid "free"
 msgstr ""
 
@@ -603,11 +600,11 @@ msgstr ""
 msgid "Green Address"
 msgstr ""
 
-#: src/views/CashlinkReceive.vue:346
+#: src/views/CashlinkReceive.vue:345
 msgid "Happy birthday!"
 msgstr ""
 
-#: src/views/CashlinkReceive.vue:344
+#: src/views/CashlinkReceive.vue:343
 msgid "Happy Easter!"
 msgstr ""
 
@@ -626,7 +623,7 @@ msgstr ""
 msgid "Imported {count} address so far... | Imported {count} addresses so far..."
 msgstr ""
 
-#: src/views/SetupSwapLedger.vue:990
+#: src/views/SetupSwapLedger.vue:994
 msgid "incoming"
 msgstr ""
 
@@ -724,7 +721,7 @@ msgid "New Address added to your Account."
 msgstr ""
 
 #: src/views/CashlinkCreate.vue:55
-#: src/views/SignTransactionLedger.vue:288
+#: src/views/SignTransactionLedger.vue:290
 msgid "New Cashlink"
 msgstr ""
 
@@ -752,7 +749,7 @@ msgstr ""
 msgid "None of your available addresses has sufficient balance."
 msgstr ""
 
-#: src/views/Migrate.vue:224
+#: src/views/Migrate.vue:225
 msgid "Nothing to update."
 msgstr ""
 
@@ -761,7 +758,7 @@ msgid "OASIS service fee"
 msgstr ""
 
 #: src/views/ErrorHandlerUnsupportedLedger.vue:4
-#: src/views/RefundSwapLedger.vue:346
+#: src/views/RefundSwapLedger.vue:343
 msgid "Ok"
 msgstr ""
 
@@ -790,7 +787,7 @@ msgstr ""
 msgid "Other wallets"
 msgstr ""
 
-#: src/views/SetupSwapLedger.vue:989
+#: src/views/SetupSwapLedger.vue:993
 msgid "outgoing"
 msgstr ""
 
@@ -814,7 +811,7 @@ msgstr ""
 msgid "Payment successful"
 msgstr ""
 
-#: src/views/CheckoutTransmission.vue:128
+#: src/views/CheckoutTransmission.vue:124
 msgid "Payment successful."
 msgstr ""
 
@@ -850,11 +847,11 @@ msgstr ""
 msgid "Prepare for update"
 msgstr ""
 
-#: src/views/SetupSwapSuccess.vue:605
+#: src/views/SetupSwapSuccess.vue:614
 msgid "Preparing Swap"
 msgstr ""
 
-#: src/views/CheckoutTransmission.vue:130
+#: src/views/CheckoutTransmission.vue:126
 msgid "Processing your payment"
 msgstr ""
 
@@ -878,11 +875,11 @@ msgstr ""
 msgid "Red Address"
 msgstr ""
 
-#: src/views/RefundSwapLedger.vue:316
+#: src/views/RefundSwapLedger.vue:313
 msgid "Refund Failed"
 msgstr ""
 
-#: src/views/RefundSwapLedger.vue:335
+#: src/views/RefundSwapLedger.vue:332
 msgid "Refunding this Swap is currently not supported on this device or browser. Please use the device and browser you originally created the Swap with. Otherwise please try again in the future."
 msgstr ""
 
@@ -903,7 +900,7 @@ msgstr ""
 msgid "Request failed: "
 msgstr ""
 
-#: src/components/CheckoutCardNimiq.vue:289
+#: src/components/CheckoutCardNimiq.vue:293
 msgid "Requesting balances..."
 msgstr ""
 
@@ -911,14 +908,14 @@ msgstr ""
 msgid "Restart Payment"
 msgstr ""
 
-#: src/views/Migrate.vue:219
+#: src/views/Migrate.vue:220
 msgid "Retrieving your old accounts..."
 msgstr ""
 
 #: src/views/ActivatePolygonSuccess.vue:139
 #: src/views/BitcoinSyncBaseView.vue:72
 #: src/views/LoginSuccess.vue:122
-#: src/views/SetupSwapSuccess.vue:634
+#: src/views/SetupSwapSuccess.vue:643
 #: src/views/SignupLedger.vue:145
 msgid "Retry"
 msgstr ""
@@ -932,12 +929,12 @@ msgstr ""
 msgid "Send your transaction"
 msgstr ""
 
-#: src/views/SignTransactionLedger.vue:486
+#: src/views/SignTransactionLedger.vue:492
 msgid "Sending Transaction"
 msgstr ""
 
 #: src/views/CashlinkManage.vue:190
-#: src/views/CheckoutTransmission.vue:122
+#: src/views/CheckoutTransmission.vue:118
 msgid "Sending transaction..."
 msgstr ""
 
@@ -957,7 +954,7 @@ msgstr ""
 msgid "Sign Message"
 msgstr ""
 
-#: src/views/SetupSwapSuccess.vue:614
+#: src/views/SetupSwapSuccess.vue:623
 msgid "Signing transactions..."
 msgstr ""
 
@@ -966,7 +963,7 @@ msgid "Single Accounts"
 msgstr ""
 
 #: src/views/CashlinkManage.vue:228
-#: src/views/CheckoutTransmission.vue:129
+#: src/views/CheckoutTransmission.vue:125
 msgid "Something went wrong"
 msgstr ""
 
@@ -982,20 +979,20 @@ msgstr ""
 msgid "Speed up your transaction"
 msgstr ""
 
-#: src/views/SignStaking.vue:47
-#: src/views/SignStaking.vue:65
+#: src/views/SignStaking.vue:46
+#: src/views/SignStaking.vue:64
 msgid "Staking Contract"
 msgstr ""
 
-#: src/views/CashlinkCreate.vue:163
+#: src/views/CashlinkCreate.vue:162
 msgid "standard"
 msgstr ""
 
 #: src/views/AddVestingContract.vue:32
-msgid "Start Block:"
+msgid "Start Time:"
 msgstr ""
 
-#: src/views/Migrate.vue:233
+#: src/views/Migrate.vue:234
 msgid "Storing your new accounts..."
 msgstr ""
 
@@ -1007,35 +1004,35 @@ msgstr ""
 msgid "Swap fee"
 msgstr ""
 
-#: src/views/SetupSwapLedger.vue:851
-#: src/views/SetupSwapSuccess.vue:601
+#: src/views/SetupSwapLedger.vue:855
+#: src/views/SetupSwapSuccess.vue:610
 msgid "Swap Setup Failed"
 msgstr ""
 
-#: src/views/RefundSwapLedger.vue:314
+#: src/views/RefundSwapLedger.vue:311
 msgid "Syncing"
 msgstr ""
 
-#: src/components/CheckoutCardNimiq.vue:287
+#: src/components/CheckoutCardNimiq.vue:291
 #: src/views/AddVestingContract.vue:11
 #: src/views/CashlinkManage.vue:188
-#: src/views/CheckoutTransmission.vue:121
+#: src/views/CheckoutTransmission.vue:117
 msgid "Syncing consensus..."
 msgstr ""
 
 #: src/views/ActivatePolygonSuccess.vue:113
 #: src/views/BitcoinSyncBaseView.vue:50
-#: src/views/SetupSwapLedger.vue:853
-#: src/views/SetupSwapSuccess.vue:603
-#: src/views/SignBtcTransactionLedger.vue:117
+#: src/views/SetupSwapLedger.vue:857
+#: src/views/SetupSwapSuccess.vue:612
+#: src/views/SignBtcTransactionLedger.vue:118
 msgid "Syncing Failed"
 msgstr ""
 
-#: src/views/RefundSwapLedger.vue:330
+#: src/views/RefundSwapLedger.vue:327
 msgid "Syncing with {currency} network failed: {error}"
 msgstr ""
 
-#: src/views/RefundSwapLedger.vue:324
+#: src/views/RefundSwapLedger.vue:321
 msgid "Syncing with {currency} network..."
 msgstr ""
 
@@ -1044,7 +1041,7 @@ msgid "Syncing with Bitcoin network failed: {error}"
 msgstr ""
 
 #: src/views/BitcoinSyncBaseView.vue:58
-#: src/views/SetupSwapLedger.vue:863
+#: src/views/SetupSwapLedger.vue:867
 msgid "Syncing with Bitcoin network..."
 msgstr ""
 
@@ -1078,7 +1075,7 @@ msgid "The display language changed. Do you want to reload the page to update al
 msgstr ""
 
 #: src/components/CheckoutCard.vue:171
-#: src/views/SignTransactionLedger.vue:492
+#: src/views/SignTransactionLedger.vue:498
 msgid "The offer expired."
 msgstr ""
 
@@ -1090,11 +1087,11 @@ msgstr ""
 msgid "There's much more. Read the full article"
 msgstr ""
 
-#: src/views/CashlinkReceive.vue:304
+#: src/views/CashlinkReceive.vue:303
 msgid "This Cashlink has already been claimed."
 msgstr ""
 
-#: src/views/CashlinkReceive.vue:207
+#: src/views/CashlinkReceive.vue:208
 msgid "This is not a valid Cashlink, sorry."
 msgstr ""
 
@@ -1122,6 +1119,10 @@ msgstr ""
 msgid "Time to grow"
 msgstr ""
 
+#: src/views/AddVestingContract.vue:36
+msgid "Time/Step:"
+msgstr ""
+
 #: src/views/ErrorHandlerUnsupportedLedger.vue:47
 msgid "To change the PIN of your Ledger please go to the settings on your device."
 msgstr ""
@@ -1131,21 +1132,21 @@ msgid "Total fees"
 msgstr ""
 
 #: src/views/CashlinkManage.vue:211
-#: src/views/CheckoutTransmission.vue:111
+#: src/views/CheckoutTransmission.vue:107
 msgid "Transaction could not be relayed"
 msgstr ""
 
 #: src/views/CashlinkManage.vue:209
-#: src/views/CheckoutTransmission.vue:109
+#: src/views/CheckoutTransmission.vue:105
 msgid "Transaction is expired"
 msgstr ""
 
-#: src/views/SignTransactionLedger.vue:490
+#: src/views/SignTransactionLedger.vue:496
 msgid "Transaction Sent"
 msgstr ""
 
-#: src/views/SignBtcTransactionLedger.vue:116
-#: src/views/SignTransactionLedger.vue:489
+#: src/views/SignBtcTransactionLedger.vue:117
+#: src/views/SignTransactionLedger.vue:495
 msgid "Transaction Signed"
 msgstr ""
 
@@ -1169,16 +1170,16 @@ msgstr ""
 msgid "Unsupported Request"
 msgstr ""
 
-#: src/components/CheckoutCardNimiq.vue:319
+#: src/components/CheckoutCardNimiq.vue:329
 msgid "Updating balances"
 msgstr ""
 
-#: src/views/Migrate.vue:262
+#: src/views/Migrate.vue:263
 msgid "Updating Keyguard..."
 msgstr ""
 
-#: src/views/Migrate.vue:142
-#: src/views/Migrate.vue:284
+#: src/views/Migrate.vue:143
+#: src/views/Migrate.vue:285
 msgid "Updating your Accounts"
 msgstr ""
 
@@ -1201,7 +1202,7 @@ msgstr ""
 msgid "Used addresses without balance might have been missed."
 msgstr ""
 
-#: src/views/SetupSwapSuccess.vue:370
+#: src/views/SetupSwapSuccess.vue:373
 msgid "Value mismatch (expected {expected} sats, found {found} sats)"
 msgstr ""
 
@@ -1210,7 +1211,7 @@ msgid "Verify Payment"
 msgstr ""
 
 #: src/lib/LabelingMachine.ts:50
-#: src/views/AddVestingContract.vue:138
+#: src/views/AddVestingContract.vue:136
 msgid "Vesting Contract"
 msgstr ""
 
@@ -1233,7 +1234,7 @@ msgstr ""
 msgid "What is Nimiq?"
 msgstr ""
 
-#: src/views/Migrate.vue:275
+#: src/views/Migrate.vue:276
 msgid "Whoops, something went wrong"
 msgstr ""
 
@@ -1250,7 +1251,7 @@ msgstr ""
 msgid "You are logged out."
 msgstr ""
 
-#: src/views/CashlinkReceive.vue:342
+#: src/views/CashlinkReceive.vue:341
 msgid "You are loved"
 msgstr ""
 
diff --git a/src/lib/AccountInfo.ts b/src/lib/AccountInfo.ts
index 22b475a3b..5af288b12 100644
--- a/src/lib/AccountInfo.ts
+++ b/src/lib/AccountInfo.ts
@@ -41,7 +41,7 @@ export class AccountInfo {
         return {
             path: this.path,
             label: this.label,
-            address: new Uint8Array(this.address.serialize()),
+            address: this.address.serialize(),
             balance: this.balance,
         };
     }
diff --git a/src/lib/BufferUtils.ts b/src/lib/BufferUtils.ts
deleted file mode 100644
index 4dc22aad5..000000000
--- a/src/lib/BufferUtils.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-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 (const code of bytes) {
-        // tslint:disable:no-bitwise
-        hex += HEX_ALPHABET[code >>> 4];
-        hex += HEX_ALPHABET[code & 0x0F];
-    }
-    return hex;
-}
diff --git a/src/lib/Cashlink.ts b/src/lib/Cashlink.ts
index 75f935907..ab5d7a250 100644
--- a/src/lib/Cashlink.ts
+++ b/src/lib/Cashlink.ts
@@ -1,7 +1,7 @@
 import { Utf8Tools } from '@nimiq/utils';
-import { DetailedPlainTransaction, NetworkClient } from '@nimiq/network-client';
-import { loadNimiq } from './Helpers';
+import { NetworkClient } from './NetworkClient';
 import { CashlinkState, CashlinkTheme } from '../../client/PublicRequestTypes';
+import { coinsToLunas, lunasToCoins } from './NimiqUtils';
 
 export const CashlinkExtraData = {
     FUNDING:  new Uint8Array([0, 130, 128, 146, 135]), // 'CASH'.split('').map(c => c.charCodeAt(0) + 63)
@@ -81,19 +81,17 @@ class Cashlink {
         this._networkClientResolver(client);
     }
 
-    public static async create(): Promise<Cashlink> {
-        await loadNimiq();
+    public static create(): Cashlink {
         const keyPair = Nimiq.KeyPair.derive(Nimiq.PrivateKey.generate());
         return new Cashlink(keyPair, keyPair.publicKey.toAddress());
     }
 
-    public static async parse(str: string): Promise<Cashlink | null> {
+    public static parse(str: string): Cashlink | null {
         if (!str) return null;
         try {
             str = str.replace(/~/g, '').replace(/=*$/, (match) => new Array(match.length).fill('.').join(''));
             const buf = Nimiq.BufferUtils.fromBase64Url(str);
-            await loadNimiq();
-            const keyPair = Nimiq.KeyPair.derive(Nimiq.PrivateKey.unserialize(buf));
+            const keyPair = Nimiq.KeyPair.derive(Nimiq.PrivateKey.deserialize(buf));
             const value = buf.readUint64();
             let message: string;
             if (buf.readPos === buf.byteLength) {
@@ -125,7 +123,7 @@ class Cashlink {
 
     public static fromObject(object: CashlinkEntry): Cashlink {
         return new Cashlink(
-            Nimiq.KeyPair.unserialize(new Nimiq.SerialBuffer(object.keyPair)),
+            Nimiq.KeyPair.deserialize(new Nimiq.SerialBuffer(object.keyPair)),
             Nimiq.Address.fromString(object.address),
             object.value,
             object.fee,
@@ -152,7 +150,7 @@ class Cashlink {
     private _value: number | null = null;
     private _fee: number | null = null;
     private _theme: CashlinkTheme = CashlinkTheme.UNSPECIFIED; // note that UNSPECIFIED equals to 0 and is thus falsy
-    private _knownTransactions: DetailedPlainTransaction[] = [];
+    private _knownTransactions: Nimiq.PlainTransactionDetails[] = [];
 
     constructor(
         public keyPair: Nimiq.KeyPair,
@@ -179,23 +177,20 @@ class Cashlink {
 
         this._immutable = !!(value || message || theme);
 
-        this._getNetwork().then((network: NetworkClient) => {
+        this._getNetwork().then(async (network: NetworkClient) => {
             const userFriendlyAddress = this.address.toUserFriendlyAddress();
 
-            // When not yet established, the balance will be updated by the nano-api as soon
-            // as we have consensus, because subscribing (below) triggers a balance check.
-            if (network.consensusState === 'established') {
-                network.getBalance(userFriendlyAddress).then(this._onBalancesChanged.bind(this));
+            if (await network.isConsensusEstablished()) {
+                network.getBalance([userFriendlyAddress]).then(this._onBalancesChanged.bind(this));
+                this.detectState();
+            } else {
+                network.awaitConsensus().then(() => {
+                    network.getBalance([userFriendlyAddress]).then(this._onBalancesChanged.bind(this));
+                    this.detectState();
+                });
             }
 
-            // Only listen for 'received' and 'mined' events, because 'relayed' events trigger a
-            // balance change in the nano-api, too, which triggers the state detection already.
-            network.on(NetworkClient.Events.TRANSACTION_PENDING, this._onTransactionReceivedOrMined.bind(this));
-            network.on(NetworkClient.Events.TRANSACTION_MINED, this._onTransactionReceivedOrMined.bind(this));
-            network.on(NetworkClient.Events.BALANCES_CHANGED, this._onBalancesChanged.bind(this));
-
-            // Triggers a BALANCES_CHANGED event if this is the first time this address is subscribed
-            network.subscribe(userFriendlyAddress);
+            (await network.innerClient).addTransactionListener(this._onTransactionReceivedOrMined.bind(this), [this.address]);
         });
 
         // Run initial state detection (awaits consensus in detectState())
@@ -206,48 +201,31 @@ class Cashlink {
         await this._awaitConsensus();
 
         const balance = await this._awaitBalance();
-        const pendingTransactions = [
-            ...(await this._getNetwork()).pendingTransactions,
-            ...(await this._getNetwork()).relayedTransactions,
-        ];
-
         const address = this.address.toUserFriendlyAddress();
 
-        const pendingFundingTx = pendingTransactions.find(
-            (tx) => tx.recipient === address);
-        const pendingClaimingTx = pendingTransactions.find(
-            (tx) => tx.sender === address);
-
-        // Only exit if the cashlink is CLAIMED and not currently funded or being funded.
-        if (this.state === CashlinkState.CLAIMED && !balance && !pendingFundingTx) return;
-
-        const knownTransactionReceipts = new Map(this._knownTransactions.map((tx) => [tx.hash, tx.blockHash!]));
+        // Only exit if the cashlink is CLAIMED and has no balance
+        if (this.state === CashlinkState.CLAIMED && !balance) return;
 
-        const transactionHistory = await (await this._getNetwork()).requestTransactionHistory(
+        const transactionHistory = await (await this._getNetwork()).getTransactionyByAddress(
             address,
-            knownTransactionReceipts,
+            this._knownTransactions,
         );
-        this._knownTransactions = this._knownTransactions.concat(transactionHistory.newTransactions);
+        this._knownTransactions = transactionHistory;
 
         let newState: CashlinkState = this.state;
 
-        const knownFundingTx = this._knownTransactions.find(
-            (tx) => tx.recipient === address);
-        const knownClaimingTx = this._knownTransactions.find(
-            (tx) => tx.sender === address);
+        const knownFundingTx = this._knownTransactions.find((tx) => tx.recipient === address);
+        const knownClaimingTx = this._knownTransactions.find((tx) => tx.sender === address);
 
         switch (this.state) {
             case CashlinkState.UNKNOWN:
-                if (!pendingFundingTx && !knownFundingTx) {
+                if (!knownFundingTx) {
                     newState = CashlinkState.UNCHARGED;
                     break;
                 }
             case CashlinkState.UNCHARGED:
-                if (pendingFundingTx) {
-                    newState = CashlinkState.CHARGING;
-                }
             case CashlinkState.CHARGING:
-                if (!balance && !pendingFundingTx) {
+                if (!balance) {
                     // Handle expired/replaced funding tx
                     newState = CashlinkState.UNCHARGED;
                     // Not break;ing here, because we need to see if the cashlink is already CLAIMED.
@@ -256,13 +234,10 @@ class Cashlink {
                     newState = CashlinkState.UNCLAIMED;
                 } else break; // If no known transactions are found, no further checks are necessary
             case CashlinkState.UNCLAIMED:
-                if (pendingClaimingTx) {
-                    newState = CashlinkState.CLAIMING;
-                }
             case CashlinkState.CLAIMING:
                 if (balance) {
                     // Handle recharged/reused cashlink
-                    if (!pendingClaimingTx) newState = CashlinkState.UNCLAIMED;
+                    newState = CashlinkState.UNCLAIMED;
                     break; // If a balance is detected on the cashlink, it cannot be in CLAIMED state.
                 }
                 if (knownClaimingTx) {
@@ -270,9 +245,7 @@ class Cashlink {
                 }
             case CashlinkState.CLAIMED:
                 // Detect cashlink re-use and chain rebranches
-                if (pendingFundingTx) newState = CashlinkState.CHARGING;
                 if (balance) newState = CashlinkState.UNCLAIMED;
-                if (pendingClaimingTx) newState = CashlinkState.CLAIMING;
         }
 
         if (newState !== this.state) this._updateState(newState);
@@ -280,7 +253,7 @@ class Cashlink {
 
     public toObject(includeOptional: boolean = true): CashlinkEntry {
         const result: CashlinkEntry = {
-            keyPair: new Uint8Array(this.keyPair.serialize()),
+            keyPair: this.keyPair.serialize(),
             address: this.address.toUserFriendlyAddress(),
             value: this.value,
             message: this.message,
@@ -304,7 +277,7 @@ class Cashlink {
             /*theme*/ (this._theme ? 1 : 0),
         );
 
-        this.keyPair.privateKey.serialize(buf);
+        buf.write(this.keyPair.privateKey.serialize());
         buf.writeUint64(this.value);
         if (this._messageBytes.byteLength || this._theme) {
             buf.writeUint8(this._messageBytes.byteLength);
@@ -344,24 +317,27 @@ class Cashlink {
 
     public async claim(
         recipientAddress: string,
-        recipientType: Nimiq.Account.Type = Nimiq.Account.Type.BASIC,
+        recipientType: Nimiq.AccountType = Nimiq.AccountType.Basic,
         fee: number = this.fee,
     ): Promise<void> {
         if (this.state >= CashlinkState.CLAIMING) {
             throw new Error('Cannot claim, Cashlink has already been claimed');
         }
 
-        await loadNimiq();
-
         // Only claim the amount specified in the cashlink (or the cashlink balance, if smaller)
         const balance = Math.min(this.value, await this._awaitBalance());
         if (!balance) {
             throw new Error('Cannot claim, there is no balance in this link');
         }
         const recipient = Nimiq.Address.fromString(recipientAddress);
-        const transaction = new Nimiq.ExtendedTransaction(this.address, Nimiq.Account.Type.BASIC,
-            recipient, recipientType, balance - fee, fee, await this._getBlockchainHeight(),
-            Nimiq.Transaction.Flag.NONE, CashlinkExtraData.CLAIMING);
+        const transaction = new Nimiq.Transaction(
+            this.address, Nimiq.AccountType.Basic, new Uint8Array(0),
+            recipient, recipientType, CashlinkExtraData.CLAIMING,
+            BigInt(balance - fee), BigInt(fee),
+            0 /* Nimiq.Transaction.Flag.NONE */,
+            await this._getBlockchainHeight(),
+            await (await this._getNetwork()).getNetworkId(),
+        );
 
         const keyPair = this.keyPair;
         const signature = Nimiq.Signature.create(keyPair.privateKey, keyPair.publicKey, transaction.serializeContent());
@@ -398,14 +374,7 @@ class Cashlink {
     }
 
     private async _awaitConsensus(): Promise<void> {
-        if ((await this._getNetwork()).consensusState === 'established') return;
-        return new Promise(async (resolve) => {
-            const handler = async () => {
-                (await this._getNetwork()).off(NetworkClient.Events.CONSENSUS_ESTABLISHED, handler);
-                resolve();
-            };
-            (await this._getNetwork()).on(NetworkClient.Events.CONSENSUS_ESTABLISHED, handler);
-        });
+        await (await this._getNetwork()).awaitConsensus();
     }
 
     private async _awaitBalance(): Promise<number> {
@@ -422,13 +391,13 @@ class Cashlink {
     private async _sendTransaction(transaction: Nimiq.Transaction): Promise<void> {
         await this._awaitConsensus();
         try {
-            const proof = Nimiq.SignatureProof.unserialize(new Nimiq.SerialBuffer(transaction.proof));
+            const proof = Nimiq.SignatureProof.deserialize(new Nimiq.SerialBuffer(transaction.proof));
             await (await this._getNetwork()).relayTransaction({
                 sender: transaction.sender.toUserFriendlyAddress(),
                 senderPubKey: proof.publicKey.serialize(),
                 recipient: transaction.recipient.toUserFriendlyAddress(),
-                value: Nimiq.Policy.lunasToCoins(transaction.value),
-                fee: Nimiq.Policy.lunasToCoins(transaction.fee),
+                value: lunasToCoins(Number(transaction.value)),
+                fee: lunasToCoins(Number(transaction.fee)),
                 validityStartHeight: transaction.validityStartHeight,
                 signature: proof.signature.serialize(),
                 extraData: transaction.data,
@@ -441,12 +410,18 @@ class Cashlink {
 
     private async _getBlockchainHeight(): Promise<number> {
         await this._awaitConsensus();
-        return (await this._getNetwork()).headInfo.height;
+        return (await (await this._getNetwork()).innerClient).getHeadHeight();
     }
 
-    private async _onTransactionReceivedOrMined(transaction: DetailedPlainTransaction): Promise<void> {
-        if (transaction.recipient === this.address.toUserFriendlyAddress()
-            || transaction.sender === this.address.toUserFriendlyAddress()) {
+    private async _onTransactionReceivedOrMined(transaction: Nimiq.PlainTransactionDetails): Promise<void> {
+        if (
+            transaction.recipient === this.address.toUserFriendlyAddress()
+            || transaction.sender === this.address.toUserFriendlyAddress()
+        ) {
+            this._knownTransactions.push(transaction);
+
+            await (await this._getNetwork()).getBalance([this.address.toUserFriendlyAddress()]).then(this._onBalancesChanged.bind(this));
+
             // Always run state detection when a transaction comes in
             // or an incoming or outgoing transaction was mined, as those
             // events likely signal a state change of the cashlink.
@@ -456,17 +431,9 @@ class Cashlink {
 
     private _onBalancesChanged(balances: Map<string, number>) {
         const address = this.address.toUserFriendlyAddress();
-
         if (!balances.has(address)) return;
-
-        this.balance = Nimiq.Policy.coinsToLunas(balances.get(address)!);
+        this.balance = coinsToLunas(balances.get(address)!);
         this.fire(Cashlink.Events.BALANCE_CHANGE, this.balance);
-        // Always run state detection when the balance changes,
-        // to catch state changes even when the transaction events
-        // have not been recognized (can happen when an incoming
-        // transaction gets mined before it's pending state is
-        // broadcasted to this client).
-        this.detectState();
     }
 
     private _updateState(state: CashlinkState) {
diff --git a/src/lib/ContractInfo.ts b/src/lib/ContractInfo.ts
index a2ffa5145..040afda07 100644
--- a/src/lib/ContractInfo.ts
+++ b/src/lib/ContractInfo.ts
@@ -5,9 +5,9 @@ import { labelAddress } from './LabelingMachine';
 export class ContractInfoHelper {
     public static fromObject(o: ContractInfoEntry): VestingContractInfo | HashedTimeLockedContractInfo {
         switch (o.type) {
-            case Nimiq.Account.Type.VESTING:
+            case Nimiq.AccountType.Vesting:
                 return VestingContractInfo.fromObject(o);
-            case Nimiq.Account.Type.HTLC:
+            case Nimiq.AccountType.HTLC:
                 return HashedTimeLockedContractInfo.fromObject(o);
             // @ts-ignore Property 'type' does not exist on type 'never'.
             default: throw new Error('Unknown contract type: ' + o.type);
@@ -17,9 +17,9 @@ export class ContractInfoHelper {
     // Used in iframe
     public static objectToContractType(o: ContractInfoEntry): VestingContract | HashedTimeLockedContract {
         switch (o.type) {
-            case 1 /* Nimiq.Account.Type.VESTING */:
+            case Nimiq.AccountType.Vesting:
                 return VestingContractInfo.objectToContractType(o);
-            case 2 /* Nimiq.Account.Type.HTLC */:
+            case Nimiq.AccountType.HTLC:
                 return HashedTimeLockedContractInfo.objectToContractType(o);
             // @ts-ignore Property 'type' does not exist on type 'never'.
             default: throw new Error('Unknown contract type: ' + o.type);
@@ -33,9 +33,9 @@ export class VestingContractInfo {
             o.label,
             new Nimiq.Address(o.address),
             new Nimiq.Address(o.owner),
-            o.start,
+            o.startTime,
             o.stepAmount,
-            o.stepBlocks,
+            o.timeStep,
             o.totalAmount,
             o.balance,
         );
@@ -44,27 +44,27 @@ export class VestingContractInfo {
     // Used in iframe
     public static objectToContractType(o: VestingContractInfoEntry): VestingContract {
         return {
-            type: 1 /* Nimiq.Account.Type.VESTING */,
+            type: Nimiq.AccountType.Vesting,
             label: o.label,
             address: AddressUtils.toUserFriendlyAddress(o.address),
             owner: AddressUtils.toUserFriendlyAddress(o.owner),
-            start: o.start,
+            startTime: o.startTime,
             stepAmount: o.stepAmount,
-            stepBlocks: o.stepBlocks,
+            timeStep: o.timeStep,
             totalAmount: o.totalAmount,
         };
     }
 
-    public type = Nimiq.Account.Type.VESTING;
+    public type: Nimiq.AccountType.Vesting = Nimiq.AccountType.Vesting;
     public walletId?: string;
 
     public constructor(
         public label: string,
         public address: Nimiq.Address,
         public owner: Nimiq.Address,
-        public start: number,
+        public startTime: number,
         public stepAmount: number,
-        public stepBlocks: number,
+        public timeStep: number,
         public totalAmount: number,
         public balance?: number,
     ) {}
@@ -81,11 +81,11 @@ export class VestingContractInfo {
         return {
             type: this.type,
             label: this.label,
-            address: new Uint8Array(this.address.serialize()),
-            owner: new Uint8Array(this.owner.serialize()),
-            start: this.start,
+            address: this.address.serialize(),
+            owner: this.owner.serialize(),
+            startTime: this.startTime,
             stepAmount: this.stepAmount,
-            stepBlocks: this.stepBlocks,
+            timeStep: this.timeStep,
             totalAmount: this.totalAmount,
             balance: this.balance,
         };
@@ -97,9 +97,9 @@ export class VestingContractInfo {
             label: this.label,
             address: this.userFriendlyAddress,
             owner: this.owner.toUserFriendlyAddress(),
-            start: this.start,
+            startTime: this.startTime,
             stepAmount: this.stepAmount,
-            stepBlocks: this.stepBlocks,
+            timeStep: this.timeStep,
             totalAmount: this.totalAmount,
         };
     }
@@ -136,10 +136,10 @@ export class VestingContractInfo {
      * and currentBalance. The withdrawn amount is simply subtracted from the released amount:
      *      <previous result> - (this.totalAmount - currentBalance)
      */
-    public calculateAvailableAmount(height: number, currentBalance = this.totalAmount) {
+    public calculateAvailableAmount(currentBalance = this.totalAmount) {
         return Math.min(
             this.totalAmount,
-            Math.max(0, Math.floor((height - this.start) / this.stepBlocks)) * this.stepAmount,
+            Math.max(0, Math.floor((Date.now() - this.startTime) / this.timeStep)) * this.stepAmount,
         ) - (this.totalAmount - currentBalance);
     }
 }
@@ -151,7 +151,7 @@ export class HashedTimeLockedContractInfo {
             new Nimiq.Address(o.address),
             new Nimiq.Address(o.sender),
             new Nimiq.Address(o.recipient),
-            new Nimiq.Hash(o.hashRoot),
+            o.hashRoot,
             o.hashCount,
             o.timeout,
             o.totalAmount,
@@ -162,7 +162,7 @@ export class HashedTimeLockedContractInfo {
     // Used in iframe
     public static objectToContractType(o: HashedTimeLockedContractInfoEntry): HashedTimeLockedContract {
         return {
-            type: 2 /* Nimiq.Account.Type.HTLC */,
+            type: Nimiq.AccountType.HTLC,
             label: o.label,
             address: AddressUtils.toUserFriendlyAddress(o.address),
             sender: AddressUtils.toUserFriendlyAddress(o.sender),
@@ -177,7 +177,7 @@ export class HashedTimeLockedContractInfo {
         };
     }
 
-    public type = Nimiq.Account.Type.HTLC;
+    public type: Nimiq.AccountType.HTLC = Nimiq.AccountType.HTLC;
     public walletId?: string;
 
     public constructor(
@@ -185,7 +185,7 @@ export class HashedTimeLockedContractInfo {
         public address: Nimiq.Address,
         public sender: Nimiq.Address,
         public recipient: Nimiq.Address,
-        public hashRoot: Nimiq.Hash,
+        public hashRoot: Uint8Array,
         public hashCount: number,
         public timeout: number,
         public totalAmount: number,
@@ -204,10 +204,10 @@ export class HashedTimeLockedContractInfo {
         return {
             type: this.type,
             label: this.label,
-            address: new Uint8Array(this.address.serialize()),
-            sender: new Uint8Array(this.sender.serialize()),
-            recipient: new Uint8Array(this.recipient.serialize()),
-            hashRoot: new Uint8Array(this.hashRoot.serialize()),
+            address: this.address.serialize(),
+            sender: this.sender.serialize(),
+            recipient: this.recipient.serialize(),
+            hashRoot: this.hashRoot,
             hashCount: this.hashCount,
             timeout: this.timeout,
             totalAmount: this.totalAmount,
@@ -217,12 +217,12 @@ export class HashedTimeLockedContractInfo {
 
     public toContractType(): HashedTimeLockedContract {
         return {
-            type: Nimiq.Account.Type.HTLC,
+            type: Nimiq.AccountType.HTLC,
             label: this.label,
             address: this.userFriendlyAddress,
             sender: this.sender.toUserFriendlyAddress(),
             recipient: this.recipient.toUserFriendlyAddress(),
-            hashRoot: this.hashRoot.toHex(),
+            hashRoot: Nimiq.BufferUtils.toHex(this.hashRoot),
             hashCount: this.hashCount,
             timeout: this.timeout,
             totalAmount: this.totalAmount,
@@ -236,19 +236,19 @@ export type ContractInfo = VestingContractInfo | HashedTimeLockedContractInfo;
  * Database Types
  */
 export interface VestingContractInfoEntry {
-    type: Nimiq.Account.Type.VESTING;
+    type: Nimiq.AccountType.Vesting;
     label: string;
     address: Uint8Array;
     owner: Uint8Array;
-    start: number;
+    startTime: number;
     stepAmount: number;
-    stepBlocks: number;
+    timeStep: number;
     totalAmount: number;
     balance?: number;
 }
 
 export interface HashedTimeLockedContractInfoEntry {
-    type: Nimiq.Account.Type.HTLC;
+    type: Nimiq.AccountType.HTLC;
     label: string;
     address: Uint8Array;
     sender: Uint8Array;
diff --git a/src/lib/CookieDecoder.ts b/src/lib/CookieDecoder.ts
index 41ce92fd8..05d852fde 100644
--- a/src/lib/CookieDecoder.ts
+++ b/src/lib/CookieDecoder.ts
@@ -212,26 +212,26 @@ export class CookieDecoder {
         const addressBytes = this.readBytes(bytes, 20 /* Nimiq.Address.SERIALIZED_SIZE */);
 
         switch (type) {
-            case 1 /* Nimiq.Account.Type.VESTING */:
+            case Nimiq.AccountType.Vesting:
                 const label = labelBytes.length > 0
                     ? Utf8Tools.utf8ByteArrayToString(new Uint8Array(labelBytes))
                     : labelVestingContract();
                 const ownerBytes = this.readBytes(bytes, 20 /* Nimiq.Address.SERIALIZED_SIZE */);
-                const start = this.fromBase256(this.readBytes(bytes, 4)); // Uint32
+                const startTime = this.fromBase256(this.readBytes(bytes, 8)); // Uint64
+                const timeStep = this.fromBase256(this.readBytes(bytes, 8)); // Uint64
                 const stepAmount = this.fromBase256(this.readBytes(bytes, 8)); // Uint64
-                const stepBlocks = this.fromBase256(this.readBytes(bytes, 4)); // Uint32
                 const totalAmount = this.fromBase256(this.readBytes(bytes, 8)); // Uint64
                 return {
                     type,
                     label,
                     address: new Uint8Array(addressBytes),
                     owner: new Uint8Array(ownerBytes),
-                    start,
+                    startTime,
                     stepAmount,
-                    stepBlocks,
+                    timeStep,
                     totalAmount,
                 } as VestingContractInfoEntry;
-            case 2 /* Nimiq.Account.Type.HTLC */:
+            case Nimiq.AccountType.HTLC:
                 throw new Error('HTLC decoding is not yet implemented');
             default:
                 throw new Error('Unknown contract type: ' + type);
diff --git a/src/lib/CookieJar.ts b/src/lib/CookieJar.ts
index 4beb0b28c..2c61e0271 100644
--- a/src/lib/CookieJar.ts
+++ b/src/lib/CookieJar.ts
@@ -161,10 +161,10 @@ class CookieJar {
         return label;
     }
 
-    private static checkContractDefaultLabel(type: Nimiq.Account.Type, label: string): string {
+    private static checkContractDefaultLabel(type: Nimiq.AccountType, label: string): string {
         switch (type) {
-            case Nimiq.Account.Type.VESTING: return label === labelVestingContract() ? '' : label;
-            case Nimiq.Account.Type.HTLC: return label === labelHashedTimeLockedContract() ? '' : label;
+            case Nimiq.AccountType.Vesting: return label === labelVestingContract() ? '' : label;
+            case Nimiq.AccountType.HTLC: return label === labelHashedTimeLockedContract() ? '' : label;
             default: return label;
         }
     }
@@ -280,15 +280,15 @@ class CookieJar {
             bytes.push.apply(bytes, Array.from(contract.address));
 
             switch (contract.type) {
-                case Nimiq.Account.Type.VESTING:
+                case Nimiq.AccountType.Vesting:
                     const data = contract as VestingContractInfoEntry;
                     bytes.push.apply(bytes, Array.from(data.owner));
-                    bytes.push.apply(bytes, this.toBase256(data.start, 4)); // Uint32
+                    bytes.push.apply(bytes, this.toBase256(data.startTime, 8)); // Uint64
+                    bytes.push.apply(bytes, this.toBase256(data.timeStep, 8)); // Uint64
                     bytes.push.apply(bytes, this.toBase256(data.stepAmount, 8)); // Uint64
-                    bytes.push.apply(bytes, this.toBase256(data.stepBlocks, 4)); // Uint32
                     bytes.push.apply(bytes, this.toBase256(data.totalAmount, 8)); // Uint64
                     break;
-                case Nimiq.Account.Type.HTLC:
+                case Nimiq.AccountType.HTLC:
                     throw new Error('HTLC encoding is not yet implemented');
                 default:
                     // @ts-ignore Property 'type' does not exist on type 'never'.
diff --git a/src/lib/Helpers.ts b/src/lib/Helpers.ts
index b90fedff5..e57eecd76 100644
--- a/src/lib/Helpers.ts
+++ b/src/lib/Helpers.ts
@@ -1,9 +1,4 @@
-import Config from 'config';
 import {
-    NETWORK_TEST,
-    NETWORK_DEV,
-    NETWORK_MAIN,
-    ERROR_INVALID_NETWORK,
     MOBILE_MAX_WIDTH,
 } from './Constants';
 
@@ -20,31 +15,6 @@ export function getHistoryStorage(key: string): any | undefined {
     return history.state ? history.state[key] : undefined;
 }
 
-export const loadNimiq = async () => {
-    await Nimiq.WasmHelper.doImport();
-    let genesisConfigInitialized = true;
-    try {
-        Nimiq.GenesisConfig.NETWORK_ID; // tslint:disable-line:no-unused-expression
-    } catch (e) {
-        genesisConfigInitialized = false;
-    }
-    if (!genesisConfigInitialized) {
-        switch (Config.network) {
-            case NETWORK_TEST:
-                Nimiq.GenesisConfig.test();
-                break;
-            case NETWORK_MAIN:
-                Nimiq.GenesisConfig.main();
-                break;
-            case NETWORK_DEV:
-                Nimiq.GenesisConfig.dev();
-                break;
-            default:
-                throw new Error(ERROR_INVALID_NETWORK);
-        }
-    }
-};
-
 export function includesOrigin(list: string[], origin: string) {
     return list.includes(origin) || list.includes('*');
 }
diff --git a/src/lib/LedgerSwapProxy.ts b/src/lib/LedgerSwapProxy.ts
index 1bf6f1b05..75397ea33 100644
--- a/src/lib/LedgerSwapProxy.ts
+++ b/src/lib/LedgerSwapProxy.ts
@@ -1,7 +1,6 @@
-import LedgerApi, { Coin, TransactionInfoNimiq, getBip32Path, parseBip32Path } from '@nimiq/ledger-api';
-import { NetworkClient } from '@nimiq/network-client';
+import LedgerApi, { Coin, TransactionInfoNimiq, getBip32Path, parseBip32Path, NetworkIdNimiq, AccountTypeNimiq } from '@nimiq/ledger-api';
 import Config from 'config';
-import { loadNimiq } from './Helpers';
+import { NetworkClient } from './NetworkClient';
 
 export const LedgerSwapProxyMarker = {
     // HTLC Proxy Funding, abbreviated as 'HPFD', mapped to values outside of basic ascii range
@@ -123,7 +122,6 @@ export default class LedgerSwapProxy {
         });
         const [entropySourcePublicKey] = await Promise.all([
             LedgerApi.Nimiq.getPublicKey(entropySourcePublicKeyPath, ledgerKeyId, Config.ledgerApiNimiqVersion),
-            loadNimiq(),
         ]);
 
         if (!localStorage[LEDGER_SWAP_PROXY_SALT_STORAGE_KEY]) {
@@ -157,7 +155,6 @@ export default class LedgerSwapProxy {
         });
         const [entropySourcePublicKey] = await Promise.all([
             LedgerApi.Nimiq.getPublicKey(entropySourcePublicKeyPath, ledgerKeyId, Config.ledgerApiNimiqVersion),
-            loadNimiq(),
         ]);
 
         return Nimiq.KeyPair.derive(new Nimiq.PrivateKey(entropySourcePublicKey.serialize()));
@@ -170,28 +167,26 @@ export default class LedgerSwapProxy {
         // See MultiSigWallet in core-js. Note that we don't have to aggregate the public keys as it's a 1 of 2 multi
         // sig, where a single signature suffices.
         const publicKeys = [localSignerPublicKey, ledgerSignerPublicKey].sort((a, b) => a.compare(b));
-        const merkleRoot = Nimiq.MerkleTree.computeRoot(publicKeys);
-        return Nimiq.Address.fromHash(merkleRoot);
+        const merkleRoot = Nimiq.MerkleTree.computeRoot(publicKeys.map(key => key.serialize()));
+        return Nimiq.Address.fromAny(merkleRoot);
     }
 
     private static async _fetchFundingTransaction(htlcOrProxyAddress: Nimiq.Address)
-        : Promise<ReturnType<Nimiq.Client.TransactionDetails['toPlain']>> {
-        if (!NetworkClient.hasInstance()) {
-            NetworkClient.createInstance(Config.networkEndpoint);
-        }
+        : Promise<Nimiq.PlainTransactionDetails> {
         const networkClient = NetworkClient.Instance;
         await networkClient.init(); // Make sure the client is initialized
+        const client = await networkClient.innerClient;
 
         // Get the oldest transaction as funding transaction. Note that non-legacy swap proxies are swap specific and
         // not reused, therefore the fetched transaction history should be small unless it's a legacy swap proxy.
         const userFriendlyAddress = htlcOrProxyAddress.toUserFriendlyAddress();
-        const transactionHistory = await networkClient.getTransactionsByAddress(userFriendlyAddress);
+        const transactionHistory = await client.getTransactionsByAddress(userFriendlyAddress);
         if (!transactionHistory.length) throw new Error(`Failed to get transaction history for ${userFriendlyAddress}`);
         return transactionHistory[transactionHistory.length - 1];
     }
 
     private static _getOriginalLocalSignerPublicKey(proxyFundingDataHex: string): Nimiq.PublicKey | null {
-        const expectedDataHexLength = (LedgerSwapProxyMarker.FUND.length + Nimiq.PublicKey.SIZE) * 2; //  * 2 for hex
+        const expectedDataHexLength = (LedgerSwapProxyMarker.FUND.length + 32 /* Nimiq.PublicKey.SIZE */) * 2; // * 2 for hex
         if (proxyFundingDataHex.length !== expectedDataHexLength
             || !proxyFundingDataHex.startsWith(Nimiq.BufferUtils.toHex(LedgerSwapProxyMarker.FUND))) return null;
         return new Nimiq.PublicKey(Nimiq.BufferUtils.fromHex(
@@ -224,13 +219,13 @@ export default class LedgerSwapProxy {
 
     public getFundingInfo(): Pick<
         TransactionInfoNimiq<typeof Config.ledgerApiNimiqVersion>,
-        'recipient' | 'recipientType' | 'validityStartHeight' | 'extraData'
+        'recipient' | 'recipientType' | 'validityStartHeight' | 'recipientData'
     > {
         return {
             recipient: this.address,
-            recipientType: Nimiq.Account.Type.BASIC,
+            recipientType: 0 /* BASIC */,
             validityStartHeight: this._swapValidityStartHeight,
-            extraData: this._ledgerSignerPublicKey
+            recipientData: this._ledgerSignerPublicKey
                 ? new Uint8Array([...LedgerSwapProxyMarker.FUND, ...this._localSignerPublicKey.serialize()])
                 : LedgerSwapProxyMarker.FUND, // legacy proxy
         };
@@ -238,7 +233,7 @@ export default class LedgerSwapProxy {
 
     public getHtlcCreationInfo(htlcData: Uint8Array): Pick<
         TransactionInfoNimiq<typeof Config.ledgerApiNimiqVersion>,
-        'sender' | 'senderType' | 'recipient' | 'recipientType' | 'validityStartHeight' | 'flags' | 'extraData'
+        'sender' | 'senderType' | 'recipient' | 'recipientType' | 'validityStartHeight' | 'flags' | 'recipientData'
     > {
         const decodedHtlcScript = Nimiq.HashedTimeLockedContract.dataToPlain(htlcData);
         if (!('sender' in decodedHtlcScript) || !Nimiq.Address.fromAny(decodedHtlcScript.sender).equals(this.address)) {
@@ -246,63 +241,61 @@ export default class LedgerSwapProxy {
         }
         return {
             sender: this.address,
-            senderType: Nimiq.Account.Type.BASIC,
+            senderType: Nimiq.AccountType.Basic as unknown as AccountTypeNimiq,
             recipient: Nimiq.Address.CONTRACT_CREATION,
-            recipientType: Nimiq.Account.Type.HTLC,
+            recipientType: Nimiq.AccountType.HTLC as unknown as AccountTypeNimiq,
             validityStartHeight: this._swapValidityStartHeight,
-            flags: Nimiq.Transaction.Flag.CONTRACT_CREATION,
-            extraData: htlcData,
+            flags: 1 /* CONTRACT_CREATION */,
+            recipientData: htlcData,
         };
     }
 
     public getRefundInfo(refundSender: Nimiq.Address): Pick<
         TransactionInfoNimiq<typeof Config.ledgerApiNimiqVersion>,
-        'sender' | 'senderType' | 'extraData'
+        'sender' | 'senderType' | 'recipientData'
     > {
         if (refundSender.equals(this.address)) {
             // refunding from proxy
             return {
                 sender: refundSender,
-                senderType: Nimiq.Account.Type.BASIC,
-                extraData: LedgerSwapProxyMarker.REDEEM,
+                senderType: 0 /* Basic */,
+                recipientData: LedgerSwapProxyMarker.REDEEM,
             };
         } else {
             // refunding from htlc
             return {
                 sender: refundSender,
-                senderType: Nimiq.Account.Type.HTLC,
+                senderType: 2 /* HTLC */,
             };
         }
     }
 
     public async signTransaction({
         sender,
-        senderType = Nimiq.Account.Type.BASIC,
+        senderType = 0 /* Basic */,
         recipient,
-        recipientType = Nimiq.Account.Type.BASIC,
+        recipientType = 0 /* Basic */,
         value,
-        fee = 0,
+        fee = BigInt(0),
         validityStartHeight,
-        flags = Nimiq.Transaction.Flag.NONE,
-        extraData,
+        flags = 0 /* NONE */,
+        recipientData,
         network,
     }: TransactionInfoNimiq<typeof Config.ledgerApiNimiqVersion>): Promise<Nimiq.Transaction> {
-        await loadNimiq();
-
         // Always create an ExtendedTransaction because all transactions that will typically be signed by the proxy will
         // be ExtendedTransactions because they include extraData or have sender- or recipientType HTLC.
-        const transaction = new Nimiq.ExtendedTransaction(
+        const transaction = new Nimiq.Transaction(
             sender,
             senderType,
+            new Uint8Array(0),
             recipient,
             recipientType,
+            recipientData || new Uint8Array(0),
             value,
             fee,
-            validityStartHeight,
             flags,
-            extraData || new Uint8Array(0),
-            undefined,
-            network ? Nimiq.GenesisConfig.CONFIGS[network].NETWORK_ID : undefined,
+            validityStartHeight,
+            (network || Config.network) === 'test' ? 5 : 24,
         );
 
         if (this._localSignerPrivateKey) {
@@ -321,18 +314,21 @@ export default class LedgerSwapProxy {
                     this._ledgerKeyId,
                     Config.ledgerApiNimiqVersion,
                 );
-            if (transaction.senderType !== Nimiq.Account.Type.BASIC
-                || transaction.recipientType !== Nimiq.Account.Type.BASIC) {
+            if (transaction.senderType !== Nimiq.AccountType.Basic
+                || transaction.recipientType !== Nimiq.AccountType.Basic) {
                 throw new Error('Contract transactions can currently not be signed by the Ledger.');
             }
-            const { signature } = Nimiq.SignatureProof.unserialize(new Nimiq.SerialBuffer(
+            const { signature } = Nimiq.SignatureProof.deserialize(
                 (await LedgerApi.Nimiq.signTransaction(
-                    transaction,
+                    transaction as Nimiq.Transaction & {
+                        senderType: AccountTypeNimiq,
+                        recipientType: AccountTypeNimiq,
+                    },
                     this._ledgerKeyPath,
                     this._ledgerKeyId,
                     Config.ledgerApiNimiqVersion,
                 )).proof,
-            ));
+            );
             transaction.proof = this.createSignatureProof(this._ledgerSignerPublicKey!, signature).serialize();
         }
 
@@ -340,7 +336,7 @@ export default class LedgerSwapProxy {
     }
 
     public createSignatureProof(signer: Nimiq.PublicKey, signature: Nimiq.Signature): Nimiq.SignatureProof {
-        if (!signer.equals(this._localSignerPublicKey) && !signer.equals(this._ledgerSignerPublicKey)) {
+        if (!signer.equals(this._localSignerPublicKey) && (!this._ledgerSignerPublicKey || !signer.equals(this._ledgerSignerPublicKey))) {
             throw new Error('Invalid proxy signer.');
         }
         if (!this._ledgerSignerPublicKey) {
diff --git a/src/lib/NetworkClient.ts b/src/lib/NetworkClient.ts
index 3371acb0f..4ef03a60d 100644
--- a/src/lib/NetworkClient.ts
+++ b/src/lib/NetworkClient.ts
@@ -1,18 +1,11 @@
-import type * as Nimiq from '@nimiq/albatross-wasm';
 import Config from 'config';
-
-declare global {
-    interface Window {
-        loadAlbatross: () => Promise<typeof Nimiq>;
-    }
-}
+import { NETWORK_TEST, NETWORK_MAIN, NETWORK_DEV, ERROR_INVALID_NETWORK } from './Constants';
 
 export class NetworkClient {
     private static _instance?: NetworkClient;
 
     public static get Instance() {
-        if (!this._instance) this._instance = new NetworkClient();
-        return this._instance;
+        return this._instance || (this._instance = new NetworkClient());
     }
 
     private _clientPromise?: Promise<Nimiq.Client>;
@@ -20,16 +13,13 @@ export class NetworkClient {
     // constructor() {}
 
     public async init() {
-        const initPromise = this._clientPromise || (this._clientPromise = new Promise(async (resolve) => {
-            const { Client, ClientConfiguration } = await window.loadAlbatross();
-            const clientConfig = new ClientConfiguration();
+        await this._clientPromise || (this._clientPromise = new Promise(async (resolve) => {
+            const clientConfig = new Nimiq.ClientConfiguration();
             clientConfig.network(this.networkToAlbatross(Config.network));
             clientConfig.seedNodes(Config.seedNodes);
             clientConfig.logLevel('debug');
-            resolve(Client.create(clientConfig.build()));
+            resolve(Nimiq.Client.create(clientConfig.build()));
         }));
-
-        await initPromise;
     }
 
     public async requestTransactionReceipts(address: string, limit?: number) {
@@ -37,10 +27,29 @@ export class NetworkClient {
         return client.getTransactionReceiptsByAddress(address, limit);
     }
 
+    public async getTransactionyByAddress(
+        address: string | Nimiq.Address,
+        // sinceBlockHeight?: number,
+        knownTransactionDetails?: Nimiq.PlainTransactionDetails[],
+        // startAt?: string,
+        limit?: number,
+        // minPeers?: number,
+    ) {
+        const client = await this.client;
+        return client.getTransactionsByAddress(
+            address,
+            undefined /* sinceBlockHeight */,
+            knownTransactionDetails,
+            undefined /* startAt */,
+            limit,
+            undefined /* minPeers */,
+        );
+    }
+
     public async getBalance(addresses: string[]) {
         const client = await this.client;
         const accounts = await client.getAccounts(addresses);
-        return new Map(accounts.map((account, i) => [addresses[i], account.balance]));
+        return new Map(accounts.map((account, i) => [addresses[i], account.balance / 1e5]));
     }
 
     public async getStake(addresses: string[]) {
@@ -54,10 +63,56 @@ export class NetworkClient {
         ]));
     }
 
+    public async getHeight() {
+        const client = await this.client;
+        return client.getHeadHeight();
+    }
+
+    public async getNetworkId() {
+        const client = await this.client;
+        return client.getNetworkId();
+    }
+
+    public async awaitConsensus() {
+        await this.client;
+    }
+
+    public async isConsensusEstablished() {
+        return (await this.client).isConsensusEstablished();
+    }
+
     public async getGenesisVestingContracts() {
         return [] as Array<Nimiq.PlainVestingContract & { address: string }>; // TODO
     }
 
+    public async relayTransaction(obj: {
+        sender: string;
+        senderPubKey: Uint8Array;
+        recipient: string;
+        value: number;
+        fee: number;
+        validityStartHeight: number;
+        signature: Uint8Array;
+        extraData?: string | Uint8Array;
+    }) {
+        const client = await this.client;
+
+        const tx = Nimiq.TransactionBuilder.newBasicWithData(
+            Nimiq.Address.fromString(obj.sender),
+            Nimiq.Address.fromString(obj.recipient),
+            typeof obj.extraData === 'string'
+                ? Nimiq.BufferUtils.fromAny(obj.extraData)
+                : (obj.extraData || new Uint8Array(0)),
+            BigInt(obj.value),
+            BigInt(obj.fee),
+            obj.validityStartHeight,
+            await client.getNetworkId(),
+        );
+        tx.proof = Nimiq.SignatureProof.singleSig(new Nimiq.PublicKey(obj.senderPubKey), Nimiq.Signature.deserialize(obj.signature)).serialize();
+
+        return client.sendTransaction(tx);
+    }
+
     public get innerClient() {
         return this._clientPromise!;
     }
@@ -72,10 +127,10 @@ export class NetworkClient {
 
     private networkToAlbatross(network: string) {
         switch (network) {
-            case 'main': return 'albatross';
-            case 'test': return 'testalbatross';
-            case 'dev': return 'devalbatross';
-            default: throw new Error(`Unknown network: ${network}`);
+            case NETWORK_MAIN: return 'mainalbatross';
+            case NETWORK_TEST: return 'testalbatross';
+            case NETWORK_DEV: return 'devalbatross';
+            default: throw new Error(ERROR_INVALID_NETWORK);
         }
     }
 }
diff --git a/src/lib/NimiqUtils.ts b/src/lib/NimiqUtils.ts
new file mode 100644
index 000000000..e8341a1ac
--- /dev/null
+++ b/src/lib/NimiqUtils.ts
@@ -0,0 +1,7 @@
+export function lunasToCoins(lunas: number): number {
+    return lunas / 1e5;
+}
+
+export function coinsToLunas(coins: number): number {
+    return Math.round(coins * 1e5);
+}
diff --git a/src/lib/PermissionStore.ts b/src/lib/PermissionStore.ts
index 577520c44..c55724a2c 100644
--- a/src/lib/PermissionStore.ts
+++ b/src/lib/PermissionStore.ts
@@ -66,7 +66,7 @@ export class PermissionStore {
         const result: PermissionEntry = await PermissionStore._requestAsPromise(request);
         return result ? {
             ...result,
-            addresses: result.addresses.map((address) => Nimiq.Address.unserialize(new Nimiq.SerialBuffer(address))),
+            addresses: result.addresses.map((address) => new Nimiq.Address(address)),
         } : result;
     }
 
@@ -108,7 +108,7 @@ export class PermissionStore {
         const result: PermissionEntry[] = await PermissionStore._readAllFromCursor(request);
         return result ? result.map((entry) => ({
             ...entry,
-            addresses: entry.addresses.map((address) => Nimiq.Address.unserialize(new Nimiq.SerialBuffer(address))),
+            addresses: entry.addresses.map((address) => new Nimiq.Address(address)),
         })) : result;
     }
 
diff --git a/src/lib/RequestParser.ts b/src/lib/RequestParser.ts
index 411ca2d88..cef812608 100644
--- a/src/lib/RequestParser.ts
+++ b/src/lib/RequestParser.ts
@@ -71,21 +71,21 @@ export class RequestParser {
                     appName: signTransactionRequest.appName,
                     sender: Nimiq.Address.fromString(signTransactionRequest.sender),
                     recipient: Nimiq.Address.fromString(signTransactionRequest.recipient),
-                    recipientType: signTransactionRequest.recipientType || Nimiq.Account.Type.BASIC,
+                    recipientType: signTransactionRequest.recipientType || Nimiq.AccountType.Basic,
                     recipientLabel: signTransactionRequest.recipientLabel,
                     value: signTransactionRequest.value,
                     fee: signTransactionRequest.fee || 0,
                     data: typeof signTransactionRequest.extraData === 'string'
                         ? Utf8Tools.stringToUtf8ByteArray(signTransactionRequest.extraData)
                         : signTransactionRequest.extraData || new Uint8Array(0),
-                    flags: signTransactionRequest.flags || Nimiq.Transaction.Flag.NONE,
+                    flags: signTransactionRequest.flags || 0 /* Nimiq.Transaction.Flag.NONE */,
                     validityStartHeight: signTransactionRequest.validityStartHeight,
                 } as ParsedSignTransactionRequest;
             case RequestType.SIGN_STAKING:
                 const signStakingRequest = request as SignStakingRequest;
 
-                // const Albatross = await window.loadAlbatross();
-                // const transaction = Albatross.Transaction.fromAny(
+                // TODO Parse transactions
+                // const transaction = Nimiq.Transaction.fromAny(
                 //     Nimiq.BufferUtils.toHex(signStakingRequest.transaction),
                 // );
 
@@ -163,11 +163,11 @@ export class RequestParser {
                             protocolSpecific: {
                                 extraData: checkoutRequest.extraData,
                                 recipient: checkoutRequest.recipient,
-                                recipientType: checkoutRequest.recipientType || Nimiq.Account.Type.BASIC,
+                                recipientType: checkoutRequest.recipientType || Nimiq.AccountType.Basic,
                                 sender: checkoutRequest.sender,
                                 forceSender: !!checkoutRequest.forceSender,
                                 fee: checkoutRequest.fee || 0,
-                                flags: checkoutRequest.flags || Nimiq.Transaction.Flag.NONE,
+                                flags: checkoutRequest.flags || 0 /* Nimiq.Transaction.Flag.NONE */,
                                 validityDuration: checkoutRequest.validityDuration,
                             },
                         })],
@@ -750,8 +750,8 @@ export class RequestParser {
             case RequestType.SIGN_STAKING:
                 const signStakingRequest = request as ParsedSignStakingRequest;
 
-                // const Albatross = await window.loadAlbatross();
-                // const transaction = Albatross.Transaction.fromPlain(signStakingRequest.transaction);
+                // TODO: Parse transactions
+                // const transaction = Nimiq.Transaction.fromPlain(signStakingRequest.transaction);
 
                 return {
                     appName: signStakingRequest.appName,
diff --git a/src/lib/RequestTypes.ts b/src/lib/RequestTypes.ts
index bc110b4ce..3f4435a62 100644
--- a/src/lib/RequestTypes.ts
+++ b/src/lib/RequestTypes.ts
@@ -40,12 +40,12 @@ export interface ParsedSignTransactionRequest extends ParsedBasicRequest {
         address: Nimiq.Address,
         label?: string,
         walletLabel?: string,
-        type?: Nimiq.Account.Type,
+        type?: Nimiq.AccountType,
         signerKeyId: string,
         signerKeyPath: string,
     };
     recipient: Nimiq.Address;
-    recipientType: Nimiq.Account.Type;
+    recipientType: Nimiq.AccountType;
     recipientLabel?: string;
     value: number;
     fee: number;
@@ -57,7 +57,7 @@ export interface ParsedSignTransactionRequest extends ParsedBasicRequest {
 export interface ParsedSignStakingRequest extends ParsedBasicRequest {
     senderLabel?: string;
     recipientLabel?: string;
-    // transaction: AlbatrossPlainTransaction;
+    // transactions: AlbatrossPlainTransaction[];
     transactions: Uint8Array[];
 }
 
diff --git a/src/lib/Uid.ts b/src/lib/Uid.ts
index eae9bc30c..6db4a7be0 100644
--- a/src/lib/Uid.ts
+++ b/src/lib/Uid.ts
@@ -1,5 +1,3 @@
-import { loadNimiq } from './Helpers';
-
 /**
  * The UID is used for the purpose of tracking Fastspot swap limits per user. It is generated from
  * two deterministic values. The keyId of an account and its first NIM address, which are always the same.
@@ -20,7 +18,6 @@ async function sha256(buffer: Uint8Array): Promise<Uint8Array> {
         return new Uint8Array(await window.crypto.subtle.digest('SHA-256', buffer));
     } catch (error) {
         if (window.top === window) { // Not an iframe or popup
-            await loadNimiq();
             return Nimiq.Hash.computeSha256(buffer);
         } else {
             throw error;
diff --git a/src/lib/WalletInfo.ts b/src/lib/WalletInfo.ts
index 2d1c6b4d9..7b39f4e9a 100644
--- a/src/lib/WalletInfo.ts
+++ b/src/lib/WalletInfo.ts
@@ -110,8 +110,8 @@ export class WalletInfo {
     public findContractsByOwner(address: Nimiq.Address): ContractInfo[] {
         return this.contracts.filter((contract) => {
             switch (contract.type) {
-                case Nimiq.Account.Type.VESTING: return contract.owner.equals(address);
-                case Nimiq.Account.Type.HTLC:
+                case Nimiq.AccountType.Vesting: return contract.owner.equals(address);
+                case Nimiq.AccountType.HTLC:
                     return contract.sender.equals(address)
                         || contract.recipient.equals(address);
                 default: return false;
@@ -125,7 +125,7 @@ export class WalletInfo {
         // address belongs to a contract
         const contract = this.findContractByAddress(address);
         if (!contract) return null;
-        if (contract.type !== Nimiq.Account.Type.VESTING) {
+        if (contract.type !== Nimiq.AccountType.Vesting) {
             throw new Error('Currently only Vesting contracts are supported');
         }
         return this.accounts.get(contract.owner.toUserFriendlyAddress()) || null;
diff --git a/src/lib/WalletInfoCollector.ts b/src/lib/WalletInfoCollector.ts
index 47c9de60d..de43baad5 100644
--- a/src/lib/WalletInfoCollector.ts
+++ b/src/lib/WalletInfoCollector.ts
@@ -29,6 +29,7 @@ import {
     NATIVE_SEGWIT,
 } from './bitcoin/BitcoinConstants';
 import { deriveAddressesFromXPub, getBtcNetwork, publicKeyToPayment } from './bitcoin/BitcoinUtils';
+import { coinsToLunas } from './NimiqUtils';
 
 export type BasicAccountInfo = {
     address: string,
@@ -544,9 +545,9 @@ export default class WalletInfoCollector {
                 Nimiq.Address.fromString(contract.address),
                 Nimiq.Address.fromString(contract.owner),
                 contract.startTime,
-                Nimiq.Policy.coinsToSatoshis(contract.stepAmount),
+                coinsToLunas(contract.stepAmount),
                 contract.timeStep,
-                Nimiq.Policy.coinsToSatoshis(contract.totalAmount),
+                coinsToLunas(contract.totalAmount),
             ));
 
         const potentialVestingOwnerAddress = Nimiq.Address.fromString(potentialOwner.address);
diff --git a/src/lib/WalletStore.ts b/src/lib/WalletStore.ts
index 9fcc758cc..d0a45d2fe 100644
--- a/src/lib/WalletStore.ts
+++ b/src/lib/WalletStore.ts
@@ -47,7 +47,6 @@ export class WalletStore extends Store<any, WalletInfoEntry> {
         const saltedKeyIdBytes = new Uint8Array(keyIdBytes.length + salt.length);
         saltedKeyIdBytes.set(keyIdBytes, 0);
         saltedKeyIdBytes.set(salt, keyIdBytes.length);
-        await Nimiq.WasmHelper.doImport();
         const keyIdHash = Nimiq.Hash.computeBlake2b(saltedKeyIdBytes);
 
         for (let i = 0; i <= (keyIdHash.length - WalletStore.WALLET_ID_LENGTH); i++) {
diff --git a/src/lib/bitcoin/BitcoinLedgerUtils.ts b/src/lib/bitcoin/BitcoinLedgerUtils.ts
index ac1986a94..1812263fc 100644
--- a/src/lib/bitcoin/BitcoinLedgerUtils.ts
+++ b/src/lib/bitcoin/BitcoinLedgerUtils.ts
@@ -5,9 +5,9 @@ import { loadBitcoinJS } from './BitcoinJSLoader';
 
 // Import only types to avoid bundling
 import type { Transaction as BitcoinJsTransaction } from 'bitcoinjs-lib';
-import type { BitcoinTransactionInfo } from '../../views/SignBtcTransaction.vue';
+import type { BitcoinTransactionInfo } from './BitcoinUtils';
 import type { TransactionInfoBitcoin as LedgerBitcoinTransactionInfo } from '@nimiq/ledger-api';
-import { BitcoinTransactionInputType } from '@nimiq/keyguard-client';
+import type { BitcoinTransactionInputType } from '@nimiq/keyguard-client';
 
 /**
  * Prepare a bitcoin transaction for signing via the Ledger api by enriching it with complete input transactions and
diff --git a/src/lib/bitcoin/BitcoinUtils.ts b/src/lib/bitcoin/BitcoinUtils.ts
index 43037d59a..be1b00149 100644
--- a/src/lib/bitcoin/BitcoinUtils.ts
+++ b/src/lib/bitcoin/BitcoinUtils.ts
@@ -12,6 +12,15 @@ import {
     BTC_ACCOUNT_MAX_ALLOWED_ADDRESS_GAP,
 } from './BitcoinConstants';
 import { BtcAddressInfo } from './BtcAddressInfo';
+import type {
+    BitcoinTransactionChangeOutput,
+    BitcoinTransactionInfo as KeyguardBitcoinTransactionInfo,
+} from '@nimiq/keyguard-client';
+
+// BitcoinTransactionInfo with complete changeOutput
+export type BitcoinTransactionInfo = Omit<KeyguardBitcoinTransactionInfo, 'changeOutput'> & {
+    changeOutput?: Required<BitcoinTransactionChangeOutput>,
+};
 
 export function getBtcNetwork(addressType = Config.bitcoinAddressType) {
     let network: BitcoinJS.Network;
diff --git a/src/lib/paymentOptions/NimiqPaymentOptions.ts b/src/lib/paymentOptions/NimiqPaymentOptions.ts
index 04cd748cb..cdee09971 100644
--- a/src/lib/paymentOptions/NimiqPaymentOptions.ts
+++ b/src/lib/paymentOptions/NimiqPaymentOptions.ts
@@ -47,9 +47,9 @@ export class ParsedNimiqDirectPaymentOptions extends ParsedPaymentOptions<Curren
             }
         }
 
-        let recipientType: Nimiq.Account.Type | undefined;
+        let recipientType: Nimiq.AccountType | undefined;
         if (options.protocolSpecific.recipientType !== undefined) {
-            if (!Object.values(Nimiq.Account.Type).includes(options.protocolSpecific.recipientType)) {
+            if (!Object.values(Nimiq.AccountType).includes(options.protocolSpecific.recipientType)) {
                 throw new Error('If provided, recipientType must be a valid Nimiq account type');
             }
             recipientType = options.protocolSpecific.recipientType;
@@ -78,8 +78,8 @@ export class ParsedNimiqDirectPaymentOptions extends ParsedPaymentOptions<Curren
         }
 
         const requiresExtendedTransaction = extraData && extraData.byteLength > 0
-            || (recipientType !== undefined && recipientType !== Nimiq.Account.Type.BASIC)
-            || (flags !== undefined && flags !== Nimiq.Transaction.Flag.NONE);
+            || (recipientType !== undefined && recipientType !== Nimiq.AccountType.Basic)
+            || (flags !== undefined && flags !== 0 /* Nimiq.Transaction.Flag.NONE */);
         // Note that the transaction size can be bigger than this, for example if the sender type the user wants
         // to use requires an extended transaction or if an extended transaction includes a multi signature proof.
         // The size is therefore just an estimate. In the majority of cases the estimate will be accurate though
@@ -113,8 +113,8 @@ export class ParsedNimiqDirectPaymentOptions extends ParsedPaymentOptions<Curren
         // forceSender we are more lenient.
         if (this.parserFlags.isPointOfSale && (
             options.protocolSpecific.forceSender
-            || (recipientType !== undefined && recipientType !== Nimiq.Account.Type.BASIC)
-            || (flags !== undefined && flags !== Nimiq.Transaction.Flag.NONE)
+            || (recipientType !== undefined && recipientType !== Nimiq.AccountType.Basic)
+            || (flags !== undefined && flags !== 0 /* Nimiq.Transaction.Flag.NONE */)
             || (extraData && !Utf8Tools.isValidUtf8(extraData)) // only allow string data
         )) {
             throw new Error('isPointOfSale was set but requested sender, recipientType, flags or extraData can not '
@@ -127,7 +127,7 @@ export class ParsedNimiqDirectPaymentOptions extends ParsedPaymentOptions<Curren
             fee,
             feePerByte,
             extraData,
-            flags: flags || Nimiq.Transaction.Flag.NONE,
+            flags: flags || 0 /* Nimiq.Transaction.Flag.NONE */,
             recipient,
             recipientType,
             validityDuration: !options.protocolSpecific.validityDuration
diff --git a/src/main.ts b/src/main.ts
index 4fe7a6b35..a59b1ff45 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -31,6 +31,11 @@ Vue.config.productionTip = false;
 // see https://cli.vuejs.org/guide/mode-and-env.html#using-env-variables-in-client-side-code
 setVueComponentsAssetPath(`${process.env.BASE_URL}js/`, `${process.env.BASE_URL}img/`);
 
+// Load the main Nimiq WASM module and make it available globally.
+// This must happen before creating the RpcApi instance, because it can try to recover state in its
+// constructor, which in turn uses the RequestParser, which needs the Nimiq module.
+window.Nimiq = await window.loadAlbatross();
+
 const rpcApi = new RpcApi(store, staticStore, router);
 Vue.prototype.$rpc = rpcApi; // rpcApi is started in App.vue->created()
 
@@ -80,3 +85,10 @@ declare module 'vue/types/vue' {
         $rpc: RpcApi;
     }
 }
+
+declare global {
+    interface Window {
+        loadAlbatross: () => Promise<typeof Nimiq>;
+        Nimiq: typeof Nimiq;
+    }
+}
diff --git a/src/views/AddVestingContract.vue b/src/views/AddVestingContract.vue
index e857320cc..a0b8b69e2 100644
--- a/src/views/AddVestingContract.vue
+++ b/src/views/AddVestingContract.vue
@@ -29,12 +29,12 @@
                             <Amount :amount="contract.balance" :minDecimals="0"/>
                         </div>
                         <div class="row">
-                            <strong>{{ $t('Start Block:') }}</strong>
-                            <span>{{ contract.start }}</span>
+                            <strong>{{ $t('Start Time:') }}</strong>
+                            <span>{{ new Date(contract.startTime).toLocaleString() }}</span>
                         </div>
                         <div class="row">
-                            <strong>{{ $t('Blocks/Step:') }}</strong>
-                            <span>{{ contract.stepBlocks }}</span>
+                            <strong>{{ $t('Time/Step:') }}</strong>
+                            <span>{{ contract.timeStep / 1000 }} seconds</span>
                         </div>
                         <div class="row">
                             <strong>{{ $t('Amount/Step:') }}</strong>
@@ -58,8 +58,6 @@
         </SmallPage>
 
         <GlobalClose :hidden="contractStored"/>
-
-        <Network ref="$network"/>
     </div>
 </template>
 
@@ -75,14 +73,13 @@ import {
     CircleSpinner,
     Amount,
 } from '@nimiq/vue-components';
-import { NetworkClient } from '@nimiq/network-client';
 import StatusScreen from '../components/StatusScreen.vue';
 import GlobalClose from '../components/GlobalClose.vue';
-import Network from '../components/Network.vue';
 import { WalletInfo } from '../lib/WalletInfo';
 import { WalletStore } from '../lib/WalletStore';
 import { VestingContractInfo } from '../lib/ContractInfo';
 import { RequestType } from '../../client/PublicRequestTypes';
+import { NetworkClient } from '../lib/NetworkClient';
 
 @Component({components: {
         SmallPage,
@@ -94,7 +91,6 @@ import { RequestType } from '../../client/PublicRequestTypes';
         PageFooter,
         StatusScreen,
         GlobalClose,
-        Network,
     }})
 export default class AddVestingContract extends Vue {
     @Getter private findWalletByAddress!: (address: string, includeContracts: boolean) => WalletInfo | undefined;
@@ -107,8 +103,9 @@ export default class AddVestingContract extends Vue {
     private contractStored: boolean = false;
 
     private async mounted() {
-        const client = await (this.$refs.$network as Network).getNetworkClient();
-        client.on(NetworkClient.Events.CONSENSUS, (state) => {
+        await NetworkClient.Instance.init();
+        const client = await NetworkClient.Instance.innerClient;
+        client.addConsensusChangedListener((state) => {
             this.hasConsensus = state === 'established';
         });
     }
@@ -116,15 +113,16 @@ export default class AddVestingContract extends Vue {
     private async checkContract(address: string) {
         this.checkingContract = true;
 
-        const client = await (this.$refs.$network as Network).getNetworkClient();
-        const account = (await client.getAccounts(address))[0] as any as {
+        const client = await NetworkClient.Instance.innerClient;
+        await client.waitForConsensusEstablished();
+        const account = (await client.getAccounts([address]))[0] as any as {
             type: string,
             balance: number,
             owner: string,
-            vestingStart: number,
-            vestingStepAmount: number,
-            vestingStepBlocks: number,
-            vestingTotalAmount: number,
+            startTime: number;
+            timeStep: number;
+            stepAmount: number;
+            totalAmount: number;
         };
 
         if (account.type !== 'vesting') {
@@ -138,10 +136,10 @@ export default class AddVestingContract extends Vue {
             this.$t('Vesting Contract') as string,
             Nimiq.Address.fromUserFriendlyAddress(address),
             Nimiq.Address.fromUserFriendlyAddress(account.owner),
-            account.vestingStart,
-            account.vestingStepAmount,
-            account.vestingStepBlocks,
-            account.vestingTotalAmount,
+            account.startTime,
+            account.stepAmount,
+            account.timeStep,
+            account.totalAmount,
             account.balance,
         );
 
diff --git a/src/views/CashlinkCreate.vue b/src/views/CashlinkCreate.vue
index 8506d5742..686de3e96 100644
--- a/src/views/CashlinkCreate.vue
+++ b/src/views/CashlinkCreate.vue
@@ -94,18 +94,16 @@ import staticStore, { Static } from '../lib/StaticStore';
 import StatusScreen from '../components/StatusScreen.vue';
 import GlobalClose from '../components/GlobalClose.vue';
 import { State as RpcState } from '@nimiq/rpc';
-import { loadNimiq } from '../lib/Helpers';
 import { AccountInfo } from '../lib/AccountInfo';
 import { ParsedCreateCashlinkRequest } from '../lib/RequestTypes';
 import { RequestType } from '../../client/PublicRequestTypes';
-import { NetworkClient } from '@nimiq/network-client';
+import { NetworkClient } from '../lib/NetworkClient';
 import { WalletStore } from '../lib/WalletStore';
 import { WalletInfo } from '../lib/WalletInfo';
 import { WalletType, FIAT_API_PROVIDER } from '../lib/Constants';
 import { ContractInfo, VestingContractInfo } from '../lib/ContractInfo';
 import { i18n } from '../i18n/i18n-setup';
 import KeyguardClient from '@nimiq/keyguard-client';
-import Config from 'config';
 import {
     Account,
     AccountDetails,
@@ -125,6 +123,7 @@ import {
     Tooltip,
 } from '@nimiq/vue-components';
 import { CryptoCurrency, getExchangeRates } from '@nimiq/utils';
+import { coinsToLunas } from '../lib/NimiqUtils';
 
 @Component({components: {
     Account,
@@ -193,7 +192,6 @@ class CashlinkCreate extends Vue {
         userFriendlyAddress: string,
     }) => any;
 
-    private nimiqLoadedPromise?: Promise<void>;
     private balanceUpdatedPromise?: Promise<void>;
     private loading: boolean = false;
 
@@ -247,13 +245,8 @@ class CashlinkCreate extends Vue {
             this.message = this.request.message;
         }
 
-        if (!NetworkClient.hasInstance()) {
-            NetworkClient.createInstance(Config.networkEndpoint);
-        }
-
         this.loading = !staticStore.cashlink && (!this.request.senderAddress || !this.request.senderBalance);
 
-        this.nimiqLoadedPromise = loadNimiq();
         this.balanceUpdatedPromise = this.updateBalances();
         if (this.loading) {
             this.balanceUpdatedPromise.then(() => this.loading = false);
@@ -363,15 +356,12 @@ class CashlinkCreate extends Vue {
             const balance = balances.get(accountOrContract.userFriendlyAddress);
             if (balance === undefined) continue;
 
-            if ('type' in accountOrContract && accountOrContract.type === Nimiq.Account.Type.VESTING) {
+            if ('type' in accountOrContract && accountOrContract.type === Nimiq.AccountType.Vesting) {
                 // Calculate available amount for vesting contract
                 accountOrContract.balance =
-                    (accountOrContract as VestingContractInfo).calculateAvailableAmount(
-                        NetworkClient.Instance.headInfo.height,
-                        Nimiq.Policy.coinsToSatoshis(balance),
-                    );
+                    (accountOrContract as VestingContractInfo).calculateAvailableAmount(coinsToLunas(balance));
             } else {
-                accountOrContract.balance = Nimiq.Policy.coinsToSatoshis(balance);
+                accountOrContract.balance = coinsToLunas(balance);
             }
         }
         // Store updated wallets
@@ -405,7 +395,7 @@ class CashlinkCreate extends Vue {
     private async sendTransaction() {
         const loadingTimeout = window.setTimeout(() => this.loading = true, 10);
 
-        await Promise.all([this.balanceUpdatedPromise, this.nimiqLoadedPromise]);
+        await this.balanceUpdatedPromise;
 
         window.clearTimeout(loadingTimeout);
 
@@ -414,7 +404,7 @@ class CashlinkCreate extends Vue {
             return;
         }
 
-        const cashlink = await Cashlink.create();
+        const cashlink = Cashlink.create();
         staticStore.cashlink = cashlink;
         cashlink.networkClient = NetworkClient.Instance;
         cashlink.value = this.liveAmountAndFee.amount;
@@ -433,7 +423,7 @@ class CashlinkCreate extends Vue {
             case WalletType.LEGACY:
             case WalletType.BIP39:
                 const fundingDetails = cashlink.getFundingDetails();
-                const validityStartHeight = NetworkClient.Instance.headInfo.height + 1;
+                const validityStartHeight = await NetworkClient.Instance.getHeight() + 1;
 
                 const request: KeyguardClient.SignTransactionRequest = Object.assign({}, fundingDetails, {
                     shopOrigin: this.rpcState.origin,
@@ -442,12 +432,10 @@ class CashlinkCreate extends Vue {
                     keyPath: senderAccount.findSignerForAddress(this.accountOrContractInfo!.address)!.path,
                     keyLabel: senderAccount.labelForKeyguard,
                     sender: this.accountOrContractInfo!.address.serialize(),
-                    senderType: (this.accountOrContractInfo as ContractInfo).type
-                        ? (this.accountOrContractInfo as ContractInfo).type
-                        : Nimiq.Account.Type.BASIC,
+                    senderType: (this.accountOrContractInfo as ContractInfo).type || Nimiq.AccountType.Basic,
                     senderLabel: this.accountOrContractInfo!.label,
                     recipient: fundingDetails.recipient.serialize(),
-                    recipientType: Nimiq.Account.Type.BASIC,
+                    recipientType: Nimiq.AccountType.Basic as any, // TODO: Update with new Keyguard Client
                     fee: this.fee,
                     validityStartHeight,
                 });
diff --git a/src/views/CashlinkManage.vue b/src/views/CashlinkManage.vue
index 57b4a9fef..e5841a8d0 100644
--- a/src/views/CashlinkManage.vue
+++ b/src/views/CashlinkManage.vue
@@ -165,7 +165,7 @@ export default class CashlinkManage extends Vue {
             // might be that the sending failed and the user reloaded the page, in which case we try sending again.
             transactionToSend = network.getUnrelayedTransactions({
                 recipient: storedCashlink.address,
-                value: storedCashlink.value,
+                value: BigInt(storedCashlink.value),
             })[0];
             this.isTxSent = !transactionToSend;
             this.retrievedCashlink = storedCashlink;
@@ -195,7 +195,7 @@ export default class CashlinkManage extends Vue {
             // Store cashlink in database first to be safe when browser crashes during sending
             await CashlinkStore.Instance.put(this.retrievedCashlink);
 
-            transactionToSend = transactionToSend || await network.createTx({
+            transactionToSend = transactionToSend || network.createTx({
                 ...this.keyguardRequest,
                 signerPubKey: this.keyguardResult.publicKey,
                 signature: this.keyguardResult.signature,
diff --git a/src/views/CashlinkReceive.vue b/src/views/CashlinkReceive.vue
index 8e5140759..2b3d82207 100644
--- a/src/views/CashlinkReceive.vue
+++ b/src/views/CashlinkReceive.vue
@@ -135,11 +135,12 @@ import Cashlink from '../lib/Cashlink';
 import { CashlinkState, BasicRequest, CashlinkTheme } from '../../client/PublicRequestTypes';
 import { AccountInfo } from '../lib/AccountInfo';
 import { Getter, Mutation } from 'vuex-class';
-import { NetworkClient, DetailedPlainTransaction } from '@nimiq/network-client';
 import Config from 'config';
 import { WalletInfo } from '../lib/WalletInfo';
 import { CashlinkStore } from '../lib/CashlinkStore';
 import HubApi from '../../client/HubApi';
+import { NetworkClient } from '../lib/NetworkClient';
+import { PlainTransactionDetails } from '@nimiq/albatross-wasm';
 
 @Component({components: {
     SmallPage,
@@ -198,7 +199,7 @@ class CashlinkReceive extends Vue {
 
     public async mounted() {
         // Load Cashlink from URL
-        this.cashlink = await Cashlink.parse(window.location.hash.substring(1));
+        this.cashlink = Cashlink.parse(window.location.hash.substring(1));
 
         // Fail if no Cashlink was found
         if (!this.cashlink) {
@@ -217,9 +218,6 @@ class CashlinkReceive extends Vue {
         if (!this.hasWallets) return;
 
         // Start network to check Cashlink status
-        if (!NetworkClient.hasInstance()) {
-            NetworkClient.createInstance(Config.networkEndpoint);
-        }
         await NetworkClient.Instance.init();
 
         // Assign network to Cashlink
@@ -241,10 +239,11 @@ class CashlinkReceive extends Vue {
         this.cashlink!.claim(this.activeAccount!.userFriendlyAddress);
 
         // Set up transaction-relayed listener, so we know when the tx has been sent
-        await new Promise((resolve, reject) => {
-            NetworkClient.Instance.on(NetworkClient.Events.TRANSACTION_RELAYED, (tx: DetailedPlainTransaction) => {
+        await new Promise<void>(async (resolve, reject) => {
+            const client = await NetworkClient.Instance.innerClient;
+            client.addTransactionListener((tx) => {
                 if (tx.sender === this.cashlink!.address.toUserFriendlyAddress()) resolve();
-            });
+            }, [this.cashlink!.address]);
         });
 
         try {
diff --git a/src/views/CheckoutTransmission.vue b/src/views/CheckoutTransmission.vue
index fc65af83e..d196795ae 100644
--- a/src/views/CheckoutTransmission.vue
+++ b/src/views/CheckoutTransmission.vue
@@ -20,12 +20,10 @@
 import { Component, Vue } from 'vue-property-decorator';
 import { State } from 'vuex-class';
 import { SmallPage } from '@nimiq/vue-components';
-import type * as Nimiq from '@nimiq/albatross-wasm';
 import StatusScreen from '../components/StatusScreen.vue';
 import KeyguardClient from '@nimiq/keyguard-client';
 import { i18n } from '../i18n/i18n-setup';
 import { ERROR_CANCELED } from '../lib/Constants';
-import { bytesToHex, hexToBytes } from '../lib/BufferUtils';
 import { SignedTransaction } from '../../client/PublicRequestTypes';
 import { NetworkClient } from '../lib/NetworkClient';
 
@@ -49,10 +47,8 @@ export default class CheckoutTransmission extends Vue {
     }
 
     private async mounted() {
-        const { Transaction } = await window.loadAlbatross();
-
-        const hex = bytesToHex(this.keyguardResult.serializedTx);
-        const tx = Transaction.fromAny(hex);
+        const hex = Nimiq.BufferUtils.toHex(this.keyguardResult.serializedTx);
+        const tx = Nimiq.Transaction.fromAny(hex);
 
         try {
             await NetworkClient.Instance.init();
@@ -87,14 +83,14 @@ export default class CheckoutTransmission extends Vue {
                     recipientType: tx.recipientType,
                     proof: tx.proof,
                     signerPublicKey: 'publicKey' in plain.proof
-                        ? hexToBytes(plain.proof.publicKey)
+                        ? Nimiq.BufferUtils.fromHex(plain.proof.publicKey)
                         : 'creatorPublicKey' in plain.proof
-                            ? hexToBytes(plain.proof.creatorPublicKey)
+                            ? Nimiq.BufferUtils.fromHex(plain.proof.creatorPublicKey)
                             : new Uint8Array(0),
                     signature: 'signature' in plain.proof
-                        ? hexToBytes(plain.proof.signature)
+                        ? Nimiq.BufferUtils.fromHex(plain.proof.signature)
                         : 'creatorSignature' in plain.proof
-                            ? hexToBytes(plain.proof.creatorSignature)
+                            ? Nimiq.BufferUtils.fromHex(plain.proof.creatorSignature)
                             : new Uint8Array(0),
                     extraData: tx.data,
                     networkId: tx.networkId,
diff --git a/src/views/Migrate.vue b/src/views/Migrate.vue
index 7f79a068b..708c5d431 100644
--- a/src/views/Migrate.vue
+++ b/src/views/Migrate.vue
@@ -116,6 +116,7 @@ import staticStore, { Static } from '@/lib/StaticStore';
 import { SimpleRequest, Account, RequestType } from '../../client/PublicRequestTypes';
 import { State } from 'vuex-class';
 import { i18n } from '../i18n/i18n-setup';
+import { coinsToLunas } from '../lib/NimiqUtils';
 
 type SerializedAccount = {
     path: string;
@@ -187,7 +188,7 @@ export default class Migrate extends Vue {
         // Update legacyAccounts array
         this.legacyAccounts.forEach((account) => {
             const balance = balances.get(account.userFriendlyAddress);
-            account.balance = balance !== undefined ? Nimiq.Policy.coinsToSatoshis(balance) : balance;
+            account.balance = balance !== undefined ? coinsToLunas(balance) : balance;
         });
         this.storeAccountsCache();
     }
diff --git a/src/views/RefundSwap.vue b/src/views/RefundSwap.vue
index b1db757aa..05eef92a7 100644
--- a/src/views/RefundSwap.vue
+++ b/src/views/RefundSwap.vue
@@ -58,7 +58,7 @@ export default class RefundSwap extends BitcoinSyncBaseView {
 
                 keyPath: signer.path,
                 sender: sender.serialize(), // HTLC address
-                senderType: Nimiq.Account.Type.HTLC,
+                senderType: Nimiq.AccountType.HTLC,
                 senderLabel: 'Swap HTLC',
                 // My address, must be refund address of HTLC. Send to signer as recipient might be a contract.
                 recipient: signer.address.serialize(),
diff --git a/src/views/RefundSwapLedger.vue b/src/views/RefundSwapLedger.vue
index 9408c1066..657c84427 100644
--- a/src/views/RefundSwapLedger.vue
+++ b/src/views/RefundSwapLedger.vue
@@ -30,7 +30,6 @@ import StatusScreen from '../components/StatusScreen.vue';
 import GlobalClose from '../components/GlobalClose.vue';
 import LedgerUi from '../components/LedgerUi.vue';
 import Network from '../components/Network.vue';
-import { loadNimiq } from '../lib/Helpers';
 import { SwapAsset } from '@nimiq/fastspot-api';
 import Config from 'config';
 import {
@@ -80,12 +79,8 @@ export default class RefundSwapLedger extends RefundSwap {
     protected async created() {
         if (this.request.kind === RequestType.REFUND_SWAP) {
             if ((this.request as ParsedRefundSwapRequest).refund.type === SwapAsset.NIM) {
-                Promise.all([
-                    // start syncing with the network for later retrieving transaction histories in LedgerSwapProxy
-                    (new Network()).getNetworkClient(),
-                    // preload nimiq cryptography used in LedgerSwapProxy, makeSignTransactionResult
-                    loadNimiq(),
-                ]).catch(() => void 0);
+                // start syncing with the network for later retrieving transaction histories in LedgerSwapProxy
+                (new Network()).getNetworkClient().catch(() => void 0);
             }
 
             // first entry point into the flow is handled by the parent class which then calls _signTransaction
@@ -125,8 +120,8 @@ export default class RefundSwapLedger extends RefundSwap {
                 if (swapProxy.canSignLocally) {
                     refundTransaction = await swapProxy.signTransaction({
                         recipient, // Can directly send to recipient, the proxy just needs to sign.
-                        value,
-                        fee,
+                        value: BigInt(value),
+                        fee: BigInt(fee),
                         validityStartHeight,
                         // extraData: data, // data is the swap proxy marker which we don't want for redeeming from htlc
                         network: Config.network as LedgerApiNetwork,
@@ -139,8 +134,8 @@ export default class RefundSwapLedger extends RefundSwap {
                     const {
                         publicKey: ledgerSignerPublicKey,
                         signature,
-                    } = Nimiq.SignatureProof.unserialize(new Nimiq.SerialBuffer(refundTransaction.proof));
-                    refundTransaction.proof = swapProxy.createSignatureProof(ledgerSignerPublicKey, signature)
+                    } = Nimiq.SignatureProof.deserialize(new Nimiq.SerialBuffer(refundTransaction.proof));
+                    refundTransaction.proof = (await swapProxy.createSignatureProof(ledgerSignerPublicKey as Nimiq.PublicKey, signature))
                         .serialize();
                 } else {
                     // Refunding from the HTLC is currently not supported by the Ledger app
@@ -148,20 +143,22 @@ export default class RefundSwapLedger extends RefundSwap {
                     return;
                 }
             } catch (e) {
-                this.$rpc.reject(e.message.toLowerCase().indexOf('cancelled') !== -1 ? new Error(ERROR_CANCELED) : e);
+                this.$rpc.reject(e.message.toLowerCase().indexOf('cancelled') !== -1 ? new Error(ERROR_CANCELED) : e as Error);
                 return;
             }
 
-            if (refundTransaction.senderType === Nimiq.Account.Type.HTLC) {
+            if (refundTransaction.senderType === Nimiq.AccountType.HTLC) {
                 // create htlc timeout resolve transaction proof
                 const proof = new Nimiq.SerialBuffer(1 + refundTransaction.proof.length);
-                proof.writeUint8(Nimiq.HashedTimeLockedContract.ProofType.TIMEOUT_RESOLVE);
+                proof.writeUint8(3 /* Nimiq.HashedTimeLockedContract.ProofType.TIMEOUT_RESOLVE */);
                 proof.write(refundTransaction.proof);
                 refundTransaction.proof = proof;
             }
 
             // Validate that the transaction is valid
-            if (!refundTransaction.verify()) {
+            try {
+                refundTransaction.verify();
+            } catch (e) {
                 this.$rpc.reject(new Error('NIM transaction is invalid'));
                 return;
             }
@@ -237,7 +234,7 @@ export default class RefundSwapLedger extends RefundSwap {
             parsedSignTransactionRequest.sender = {
                 address: senderAddress,
                 label: 'Swap HTLC',
-                // type: Nimiq.Account.Type.HTLC, // Ledgers currently can not sign actual htlc transactions
+                // type: Nimiq.AccountType.HTLC, // Ledgers currently can not sign actual htlc transactions
                 signerKeyId: keyId,
                 signerKeyPath: keyPath,
             };
diff --git a/src/views/RefundSwapSuccess.vue b/src/views/RefundSwapSuccess.vue
index 9244a03c8..72c9c94bc 100644
--- a/src/views/RefundSwapSuccess.vue
+++ b/src/views/RefundSwapSuccess.vue
@@ -25,16 +25,18 @@ export default class SignBtcTransactionSuccess extends Vue {
             const tx = await (this.$refs.network as Network).createTx(Object.assign({
                 signerPubKey: this.keyguardResult.publicKey,
             }, this.keyguardResult, this.request.refund, {
-                senderType: Nimiq.Account.Type.HTLC,
+                senderType: Nimiq.AccountType.HTLC,
             }));
 
             const proof = new Nimiq.SerialBuffer(1 + tx.proof.length);
-            proof.writeUint8(Nimiq.HashedTimeLockedContract.ProofType.TIMEOUT_RESOLVE);
+            proof.writeUint8(3 /* Nimiq.HashedTimeLockedContract.ProofType.TIMEOUT_RESOLVE */);
             proof.write(new Nimiq.SerialBuffer(tx.proof)); // Current tx.proof is a regular SignatureProof
             tx.proof = proof;
 
             // Validate that the transaction is valid
-            if (!tx.verify()) {
+            try {
+                tx.verify();
+            } catch (e) {
                 this.$rpc.reject(new Error('NIM transaction is invalid'));
                 return;
             }
diff --git a/src/views/SetupSwap.vue b/src/views/SetupSwap.vue
index ba698a402..81af533c8 100644
--- a/src/views/SetupSwap.vue
+++ b/src/views/SetupSwap.vue
@@ -33,7 +33,7 @@ export default class SetupSwap extends BitcoinSyncBaseView {
         try {
             const swapSetupInfo = await this._collectSwapSetupInfo();
             if (this._isDestroyed || !swapSetupInfo) return; // destroyed or failed and is displaying an error
-            this._setupSwap(swapSetupInfo);
+            await this._setupSwap(swapSetupInfo);
         } catch (e) {
             this.error = e.message || e;
             if (this.state === this.State.SYNCING_FAILED // keep the error message displayed and offer to retry
@@ -108,7 +108,7 @@ export default class SetupSwap extends BitcoinSyncBaseView {
                 type: SwapAsset.NIM,
                 keyPath: signer.path,
                 sender: (senderContract || signer).address.serialize(),
-                senderType: senderContract ? senderContract.type : Nimiq.Account.Type.BASIC,
+                senderType: senderContract ? senderContract.type : Nimiq.AccountType.Basic,
                 senderLabel: (senderContract || signer).label,
                 value: this.request.fund.value,
                 fee: this.request.fund.fee,
diff --git a/src/views/SetupSwapLedger.vue b/src/views/SetupSwapLedger.vue
index 4eaa2f83a..f1edee1e3 100644
--- a/src/views/SetupSwapLedger.vue
+++ b/src/views/SetupSwapLedger.vue
@@ -359,6 +359,7 @@ import LedgerApi, {
     Network as LedgerApiNetwork,
     getBip32Path,
     Coin,
+    AccountTypeNimiq,
 } from '@nimiq/ledger-api';
 import {
     getBackgroundColorName as getIdenticonBackgroundColorName,
@@ -372,12 +373,12 @@ import { SignedBtcTransaction } from '../../client/PublicRequestTypes';
 import { WalletInfo } from '../lib/WalletInfo';
 import { ERROR_CANCELED } from '../lib/Constants';
 import { BTC_NETWORK_TEST } from '../lib/bitcoin/BitcoinConstants';
-import { loadNimiq } from '../lib/Helpers';
 import { loadBitcoinJS } from '../lib/bitcoin/BitcoinJSLoader';
 import { getElectrumClient } from '../lib/bitcoin/ElectrumClient';
 import { satoshisToCoins } from '../lib/bitcoin/BitcoinUtils';
 import { prepareBitcoinTransactionForLedgerSigning } from '../lib/bitcoin/BitcoinLedgerUtils';
 import LedgerSwapProxy from '../lib/LedgerSwapProxy';
+import { lunasToCoins } from '../lib/NimiqUtils';
 
 type BalanceBarEntry = {
     currency: SwapAsset,
@@ -449,8 +450,7 @@ export default class SetupSwapLedger extends Mixins(SetupSwap, SetupSwapSuccess)
         const { fund, redeem, nimiqAddresses, walletId } = this.request;
 
         Promise.all([
-            // preload nimiq cryptography used in ledger api, LedgerSwapProxy and sendToNetwork
-            fund.type === SwapAsset.NIM || redeem.type === SwapAsset.NIM ? loadNimiq() : null,
+            // no need to preload the Nimiq library, it's available by default
             // if we need to fund the proxy address, pre-initialize the nimiq network
             fund.type === SwapAsset.NIM ? this.nimiqNetwork.getNetworkClient() : null,
             // preload BitcoinJS and the electrum client used in prepareBitcoinTransactionForLedgerSigning
@@ -556,7 +556,7 @@ export default class SetupSwapLedger extends Mixins(SetupSwap, SetupSwapSuccess)
             const proxyAddress = nimiqSwapProxy.address.serialize();
             if (swapSetupInfo.fund.type === SwapAsset.NIM) {
                 swapSetupInfo.fund.sender = proxyAddress;
-                swapSetupInfo.fund.senderType = Nimiq.Account.Type.BASIC;
+                swapSetupInfo.fund.senderType = Nimiq.AccountType.Basic;
             } else if (swapSetupInfo.redeem.type === SwapAsset.NIM) {
                 swapSetupInfo.redeem.recipient = proxyAddress;
             }
@@ -631,15 +631,15 @@ export default class SetupSwapLedger extends Mixins(SetupSwap, SetupSwapSuccess)
             && this.nimiqLedgerAddressInfo
             && nimiqSwapProxy) {
             nimiqSwapTransactionInfo = {
-                value: swapSetupInfo.fund.value,
-                fee: swapSetupInfo.fund.fee,
+                value: BigInt(swapSetupInfo.fund.value),
+                fee: BigInt(swapSetupInfo.fund.fee),
                 network: Config.network as LedgerApiNetwork,
                 ...nimiqSwapProxy.getHtlcCreationInfo(htlcInfo.fund.htlcData),
             };
             // funding tx from Ledger to proxy address
             nimiqProxyTransactionInfo = {
                 sender: this.nimiqLedgerAddressInfo.address,
-                value: swapSetupInfo.fund.value,
+                value: BigInt(swapSetupInfo.fund.value),
                 network: Config.network as LedgerApiNetwork,
                 ...nimiqSwapProxy.getFundingInfo(),
             };
@@ -651,10 +651,10 @@ export default class SetupSwapLedger extends Mixins(SetupSwap, SetupSwapSuccess)
             // The htlc redeem tx currently has to be signed by the proxy but doesn't have to forward funds through it.
             nimiqSwapTransactionInfo = {
                 sender: Nimiq.Address.fromString(htlcInfo.redeem.htlcAddress),
-                senderType: Nimiq.Account.Type.HTLC,
+                senderType: Nimiq.AccountType.HTLC as unknown as AccountTypeNimiq.HTLC,
                 recipient: this.nimiqLedgerAddressInfo.address,
-                value: swapSetupInfo.redeem.value,
-                fee: swapSetupInfo.redeem.fee,
+                value: BigInt(swapSetupInfo.redeem.value),
+                fee: BigInt(swapSetupInfo.redeem.fee),
                 validityStartHeight: swapSetupInfo.redeem.validityStartHeight,
                 network: Config.network as LedgerApiNetwork,
             };
@@ -731,7 +731,11 @@ export default class SetupSwapLedger extends Mixins(SetupSwap, SetupSwapSuccess)
             if (swapSetupInfo.fund.type === SwapAsset.NIM && nimiqProxyTransactionInfo && this.nimiqLedgerAddressInfo) {
                 // send funding tx from Ledger to proxy address
                 this.currentlySignedTransaction = nimiqProxyTransactionInfo;
-                signedNimiqProxyTransaction = this.nimiqNetwork.getUnrelayedTransactions(nimiqProxyTransactionInfo)[0];
+                signedNimiqProxyTransaction = this.nimiqNetwork.getUnrelayedTransactions({
+                    ...nimiqProxyTransactionInfo,
+                    senderType: nimiqProxyTransactionInfo.senderType as Nimiq.AccountType | undefined,
+                    recipientType: nimiqProxyTransactionInfo.recipientType as Nimiq.AccountType | undefined,
+                })[0];
                 if (!signedNimiqProxyTransaction) {
                     signedNimiqProxyTransaction = await LedgerApi.Nimiq.signTransaction(
                         nimiqProxyTransactionInfo,
@@ -1077,7 +1081,7 @@ export default class SetupSwapLedger extends Mixins(SetupSwap, SetupSwapSuccess)
 
     private _toCoins(amount: number, currency: SwapAsset) {
         switch (currency) {
-            case SwapAsset.NIM: return Nimiq.Policy.lunasToCoins(amount);
+            case SwapAsset.NIM: return lunasToCoins(amount);
             case SwapAsset.BTC: return satoshisToCoins(amount);
             case SwapAsset.EUR: return amount / 100;
             default: throw new Error(`Invalid currency ${currency}`);
diff --git a/src/views/SetupSwapSuccess.vue b/src/views/SetupSwapSuccess.vue
index a75b0b1ac..d0c6eed9b 100644
--- a/src/views/SetupSwapSuccess.vue
+++ b/src/views/SetupSwapSuccess.vue
@@ -24,7 +24,6 @@ import { SetupSwapResult, SignedBtcTransaction, SignedPolygonTransaction } from
 import { Static } from '../lib/StaticStore';
 import { ParsedSetupSwapRequest } from '../lib/RequestTypes';
 import Config from 'config';
-import { loadNimiq } from '../lib/Helpers';
 import { loadBitcoinJS } from '../lib/bitcoin/BitcoinJSLoader';
 import { getElectrumClient } from '../lib/bitcoin/ElectrumClient';
 import { decodeBtcScript } from '../lib/bitcoin/BitcoinHtlcUtils';
@@ -58,8 +57,7 @@ export default class SetupSwapSuccess extends BitcoinSyncBaseView {
 
     protected async mounted() {
         Promise.all([
-            // if nimiq is involved, preload nimiq cryptography used in createTx, makeSignTransactionResult
-            this.request.fund.type === SwapAsset.NIM || this.request.redeem.type === SwapAsset.NIM ? loadNimiq() : null,
+            // no need to preload the Nimiq library, it's available by default
             // if BTC is involved preload BitcoinJS
             this.request.fund.type === SwapAsset.BTC || this.request.redeem.type === SwapAsset.BTC
                 ? loadBitcoinJS() : null,
@@ -161,7 +159,7 @@ export default class SetupSwapSuccess extends BitcoinSyncBaseView {
         // Validate contract details
         // TODO: Validate timeouts if possible (e.g. not possible for NIM)
         let hashRoot: string | undefined;
-        let nimiqHtlcHashAlgorithm: Nimiq.Hash.Algorithm | undefined;
+        let nimiqHtlcHashAlgorithm: 'blake2b' | 'sha256' | 'sha512' | undefined;
 
         if (confirmedSwap.from.asset === SwapAsset.NIM || confirmedSwap.to.asset === SwapAsset.NIM) {
             const { data: nimHtlcData } = confirmedSwap.contracts[SwapAsset.NIM]!.htlc as NimHtlcDetails;
@@ -178,10 +176,15 @@ export default class SetupSwapSuccess extends BitcoinSyncBaseView {
                 hashCount,
             } = decodedNimHtlc;
             hashRoot = decodedNimHtlc.hashRoot;
-            nimiqHtlcHashAlgorithm = (Nimiq.Hash.Algorithm as any).fromAny(decodedNimHtlc.hashAlgorithm);
-            const hashSize = Nimiq.Hash.SIZE.get(nimiqHtlcHashAlgorithm!);
-
-            if (nimiqHtlcHashAlgorithm === Nimiq.Hash.Algorithm.ARGON2D) {
+            nimiqHtlcHashAlgorithm = decodedNimHtlc.hashAlgorithm as 'blake2b' | 'sha256' | 'sha512';
+            const hashSize = {
+                blake2b: 32,
+                sha256: 32,
+                sha512: 64,
+            }[nimiqHtlcHashAlgorithm];
+
+            // @ts-ignore 'argon2d' is no longer defined
+            if (nimiqHtlcHashAlgorithm === 'argon2d') {
                 // argon2d is blacklisted for HTLCs
                 this.$rpc.reject(new Error('Disallowed HTLC hash algorithm argon2d'));
                 return;
@@ -479,8 +482,12 @@ export default class SetupSwapSuccess extends BitcoinSyncBaseView {
                 const dummyHashRoot = '66687aadf862bd776c8fc18b8e9f8e20089714856ee233b3902a591d0d5f2925'; // sha256
 
                 const proof = new Nimiq.SerialBuffer(3 + 2 * 32 + nimiqTransaction.proof.length);
-                proof.writeUint8(Nimiq.HashedTimeLockedContract.ProofType.REGULAR_TRANSFER);
-                proof.writeUint8(nimiqHtlcHashAlgorithm);
+                proof.writeUint8(1 /* Nimiq.HashedTimeLockedContract.ProofType.REGULAR_TRANSFER */);
+                proof.writeUint8({
+                    blake2b: 0,
+                    sha256: 1,
+                    sha512: 2,
+                }[nimiqHtlcHashAlgorithm]);
                 proof.writeUint8(1); // hashCount must be 1 for our swaps
                 proof.write(Nimiq.BufferUtils.fromHex(dummyHashRoot));
                 proof.write(Nimiq.BufferUtils.fromHex(dummyPreImage));
@@ -489,7 +496,9 @@ export default class SetupSwapSuccess extends BitcoinSyncBaseView {
             }
 
             // Validate that transaction is valid
-            if (!nimiqTransaction.verify()) {
+            try {
+                nimiqTransaction.verify()
+            } catch (e) {
                 this.$rpc.reject(new Error('NIM transaction is invalid'));
                 return;
             }
@@ -498,9 +507,9 @@ export default class SetupSwapSuccess extends BitcoinSyncBaseView {
         // Construct Hub response
 
         const result: SetupSwapResult = {
-            nim: nimiqTransaction ? await this.nimiqNetwork.makeSignTransactionResult(nimiqTransaction) : undefined,
+            nim: nimiqTransaction ? this.nimiqNetwork.makeSignTransactionResult(nimiqTransaction) : undefined,
             nimProxy: nimiqProxyTransaction
-                ? await this.nimiqNetwork.makeSignTransactionResult(nimiqProxyTransaction)
+                ? this.nimiqNetwork.makeSignTransactionResult(nimiqProxyTransaction)
                 : undefined,
             btc: bitcoinTransaction,
             usdc: polygonTransaction,
@@ -559,9 +568,9 @@ export default class SetupSwapSuccess extends BitcoinSyncBaseView {
             nimiqTransaction = await this.nimiqNetwork.createTx({
                 ...this.request.fund,
                 recipient: Nimiq.Address.CONTRACT_CREATION,
-                recipientType: Nimiq.Account.Type.HTLC,
+                recipientType: Nimiq.AccountType.HTLC,
                 data: htlcInfo.fund.htlcData,
-                flags: Nimiq.Transaction.Flag.CONTRACT_CREATION,
+                flags: 1 /* Nimiq.Transaction.Flag.CONTRACT_CREATION */,
                 signerPubKey: nimiqSignatureResult.publicKey,
                 signature: nimiqSignatureResult.signature,
             });
@@ -570,7 +579,7 @@ export default class SetupSwapSuccess extends BitcoinSyncBaseView {
             nimiqTransaction = await this.nimiqNetwork.createTx({
                 ...this.request.redeem,
                 sender: Nimiq.Address.fromUserFriendlyAddress(htlcInfo.redeem.htlcAddress),
-                senderType: Nimiq.Account.Type.HTLC,
+                senderType: Nimiq.AccountType.HTLC,
                 signerPubKey: nimiqSignatureResult.publicKey,
                 signature: nimiqSignatureResult.signature,
             });
diff --git a/src/views/SignBtcTransaction.vue b/src/views/SignBtcTransaction.vue
index 371b5e6ad..c860a94c0 100644
--- a/src/views/SignBtcTransaction.vue
+++ b/src/views/SignBtcTransaction.vue
@@ -16,13 +16,8 @@ import type {
     SignBtcTransactionRequest as KeyguardSignBtcTransactionRequest,
     BitcoinTransactionInput,
     BitcoinTransactionChangeOutput,
-    BitcoinTransactionInfo as KeyguardBitcoinTransactionInfo,
 } from '@nimiq/keyguard-client';
-
-// BitcoinTransactionInfo with complete changeOutput
-export type BitcoinTransactionInfo = Omit<KeyguardBitcoinTransactionInfo, 'changeOutput'> & {
-    changeOutput?: Required<BitcoinTransactionChangeOutput>,
-};
+import type { BitcoinTransactionInfo } from '../lib/bitcoin/BitcoinUtils';
 
 @Component({components: {StatusScreen, SmallPage, GlobalClose}}) // including components used in parent class
 export default class SignBtcTransaction extends BitcoinSyncBaseView {
diff --git a/src/views/SignBtcTransactionLedger.vue b/src/views/SignBtcTransactionLedger.vue
index cf88dbe3e..0384d95b9 100644
--- a/src/views/SignBtcTransactionLedger.vue
+++ b/src/views/SignBtcTransactionLedger.vue
@@ -55,7 +55,7 @@
 <script lang="ts">
 import { Component } from 'vue-property-decorator';
 import { SmallPage, PageHeader, Amount } from '@nimiq/vue-components';
-import SignBtcTransaction, { BitcoinTransactionInfo } from './SignBtcTransaction.vue';
+import SignBtcTransaction from './SignBtcTransaction.vue';
 import StatusScreen from '../components/StatusScreen.vue';
 import GlobalClose from '../components/GlobalClose.vue';
 import LedgerUi from '../components/LedgerUi.vue';
@@ -70,6 +70,7 @@ import { ERROR_CANCELED } from '../lib/Constants';
 import { WalletInfo } from '../lib/WalletInfo';
 import { loadBitcoinJS } from '../lib/bitcoin/BitcoinJSLoader';
 import { prepareBitcoinTransactionForLedgerSigning } from '../lib/bitcoin/BitcoinLedgerUtils';
+import { BitcoinTransactionInfo } from '../lib/bitcoin/BitcoinUtils';
 
 @Component({components: {StatusScreen, SmallPage, PageHeader, Amount, GlobalClose, LedgerUi, LabelAvatar}})
 export default class SignBtcTransactionLedger extends SignBtcTransaction {
diff --git a/src/views/SignStaking.vue b/src/views/SignStaking.vue
index 5194461b2..9c2fe13f9 100644
--- a/src/views/SignStaking.vue
+++ b/src/views/SignStaking.vue
@@ -22,8 +22,7 @@ export default class SignStaking extends Vue {
         let keyLabel: string | undefined;
         let recipientLabel = this.request.recipientLabel;
 
-        const { Transaction } = await window.loadAlbatross();
-        const transaction = Transaction.fromAny(Nimiq.BufferUtils.toHex(
+        const transaction = Nimiq.Transaction.fromAny(Nimiq.BufferUtils.toHex(
             this.request.transactions[this.request.transactions.length - 1],
         )).toPlain();
 
diff --git a/src/views/SignStakingSuccess.vue b/src/views/SignStakingSuccess.vue
index 1e3be1ae6..f523deb3d 100644
--- a/src/views/SignStakingSuccess.vue
+++ b/src/views/SignStakingSuccess.vue
@@ -3,18 +3,15 @@ import { Component, Vue } from 'vue-property-decorator';
 import { SignedTransaction } from '../../client/PublicRequestTypes';
 import { State } from 'vuex-class';
 import KeyguardClient from '@nimiq/keyguard-client';
-import { bytesToHex, hexToBytes } from '../lib/BufferUtils';
 
 @Component({})
 export default class SignStakingSuccess extends Vue {
     @State private keyguardResult!: KeyguardClient.SignStakingResult[];
 
-    private async mounted() {
-        const { Transaction } = await window.loadAlbatross();
-
+    private mounted() {
         const result: SignedTransaction[] = this.keyguardResult.map((signedTransaction) => {
-            const hex = bytesToHex(signedTransaction.transaction);
-            const tx = Transaction.fromAny(hex);
+            const hex = Nimiq.BufferUtils.toHex(signedTransaction.transaction);
+            const tx = Nimiq.Transaction.fromAny(hex);
             const plain = tx.toPlain();
 
             return {
@@ -27,10 +24,10 @@ export default class SignStakingSuccess extends Vue {
                     recipientType: tx.recipientType,
                     proof: tx.proof,
                     signerPublicKey: 'publicKey' in plain.proof
-                        ? hexToBytes(plain.proof.publicKey)
+                        ? Nimiq.BufferUtils.fromHex(plain.proof.publicKey)
                         : new Uint8Array(0),
                     signature: 'signature' in plain.proof
-                        ? hexToBytes(plain.proof.signature)
+                        ? Nimiq.BufferUtils.fromHex(plain.proof.signature)
                         : new Uint8Array(0),
                     extraData: tx.data,
                     networkId: tx.networkId,
diff --git a/src/views/SignTransaction.vue b/src/views/SignTransaction.vue
index 012605965..c6d6761ab 100644
--- a/src/views/SignTransaction.vue
+++ b/src/views/SignTransaction.vue
@@ -13,12 +13,12 @@ export default class SignTransaction extends Vue {
     @Static private request!: ParsedSignTransactionRequest;
     @Getter private findWalletByAddress!: (address: string, includeContracts: boolean) => WalletInfo | undefined;
 
-    public async created() {
+    public created() {
         // Forward user through Hub to Keyguard
 
         let senderAddress: Nimiq.Address;
         let senderLabel: string | undefined;
-        let senderType: Nimiq.Account.Type | undefined;
+        let senderType: Nimiq.AccountType | undefined;
         let keyId: string;
         let keyPath: string;
         let keyLabel: string | undefined;
@@ -31,7 +31,7 @@ export default class SignTransaction extends Vue {
 
             senderAddress = this.request.sender;
             senderLabel = (senderContract || signer).label;
-            senderType = senderContract ? senderContract.type : Nimiq.Account.Type.BASIC;
+            senderType = senderContract ? senderContract.type : Nimiq.AccountType.Basic;
             keyId = senderAccount.keyId;
             keyPath = signer.path;
             keyLabel = senderAccount.labelForKeyguard;
@@ -56,9 +56,9 @@ export default class SignTransaction extends Vue {
 
             sender: senderAddress.serialize(),
             senderLabel,
-            senderType: senderType || Nimiq.Account.Type.BASIC,
+            senderType: senderType || Nimiq.AccountType.Basic,
             recipient: this.request.recipient.serialize(),
-            recipientType: this.request.recipientType,
+            recipientType: this.request.recipientType as any, // TODO: Remove when Keyguard Client updated to Albatross types in API
             recipientLabel: this.request.recipientLabel,
             value: this.request.value,
             fee: this.request.fee,
diff --git a/src/views/SignTransactionLedger.vue b/src/views/SignTransactionLedger.vue
index 2bf5c0eb1..1c4aa6eee 100644
--- a/src/views/SignTransactionLedger.vue
+++ b/src/views/SignTransactionLedger.vue
@@ -126,7 +126,7 @@ import {
     StopwatchIcon,
 } from '@nimiq/vue-components';
 import Network from '../components/Network.vue';
-import LedgerApi, { RequestTypeNimiq as LedgerApiRequestType, Network as LedgerApiNetwork } from '@nimiq/ledger-api';
+import LedgerApi, { RequestTypeNimiq as LedgerApiRequestType, Network as LedgerApiNetwork, AccountTypeNimiq } from '@nimiq/ledger-api';
 import StatusScreen from '../components/StatusScreen.vue';
 import GlobalClose from '../components/GlobalClose.vue';
 import LedgerUi from '../components/LedgerUi.vue';
@@ -149,6 +149,7 @@ import Config from 'config';
 import Cashlink from '../lib/Cashlink';
 import { CashlinkStore } from '../lib/CashlinkStore';
 import CheckoutServerApi from '../lib/CheckoutServerApi';
+import { NetworkClient } from '../lib/NetworkClient';
 
 interface AccountDetailsData {
     address: string;
@@ -197,6 +198,7 @@ export default class SignTransactionLedger extends Vue {
 
     private async mounted() {
         const network = this.$refs.network as Network;
+        await NetworkClient.Instance.init();
 
         // collect payment information
         let sender: ParsedSignTransactionRequest['sender'];
@@ -260,7 +262,7 @@ export default class SignTransactionLedger extends Vue {
             };
 
             // Usually instant as synced in checkout. Only on reload we have to resync.
-            validityStartHeightPromise = network.getBlockchainHeight().then((blockchainHeight) =>
+            validityStartHeightPromise = NetworkClient.Instance.getHeight().then((blockchainHeight) =>
                 blockchainHeight + 1 // The next block is the earliest for which tx are accepted by standard miners
                 - TX_VALIDITY_WINDOW
                 + checkoutPaymentOptions.protocolSpecific.validityDuration,
@@ -281,7 +283,7 @@ export default class SignTransactionLedger extends Vue {
             ({ recipient, value, fee } = this.cashlink!.getFundingDetails());
             validityStartHeightPromise = network.getBlockchainHeight().then((blockchainHeight) => blockchainHeight + 1);
             data = CASHLINK_FUNDING_DATA;
-            flags = Nimiq.Transaction.Flag.NONE;
+            flags = 0 /* Nimiq.Transaction.Flag.NONE */;
 
             this.recipientDetails = {
                 address: this.cashlink.address.toUserFriendlyAddress(),
@@ -303,7 +305,7 @@ export default class SignTransactionLedger extends Vue {
         }
 
         let senderAddress: Nimiq.Address;
-        let senderType: Nimiq.Account.Type | undefined;
+        let senderType: Nimiq.AccountType | undefined;
         let signerKeyId: string;
         let signerKeyPath: string;
 
@@ -315,7 +317,7 @@ export default class SignTransactionLedger extends Vue {
             const signer = senderAccount.findSignerForAddress(sender)!;
 
             senderAddress = sender;
-            senderType = senderContract ? senderContract.type : Nimiq.Account.Type.BASIC;
+            senderType = senderContract ? senderContract.type : Nimiq.AccountType.Basic;
             signerKeyId = senderAccount.keyId;
             signerKeyPath = signer.path;
 
@@ -347,8 +349,8 @@ export default class SignTransactionLedger extends Vue {
             sender: senderAddress,
             senderType,
             recipient,
-            value,
-            fee: fee || 0,
+            value: BigInt(value),
+            fee: BigInt(fee || 0),
             network: Config.network as LedgerApiNetwork,
             extraData: data,
             flags,
@@ -367,7 +369,11 @@ export default class SignTransactionLedger extends Vue {
 
             try {
                 signedTransaction = await LedgerApi.Nimiq.signTransaction(
-                    { ...transactionInfo, validityStartHeight },
+                    {
+                        ...transactionInfo,
+                        validityStartHeight,
+                        senderType: transactionInfo.senderType as AccountTypeNimiq | undefined,
+                    },
                     signerKeyPath,
                     signerKeyId,
                     Config.ledgerApiNimiqVersion,
@@ -457,7 +463,7 @@ export default class SignTransactionLedger extends Vue {
         }
 
         // tslint:disable-next-line no-bitwise
-        if ((flags & Nimiq.Transaction.Flag.CONTRACT_CREATION) > 0) {
+        if ((flags & 1 /* Nimiq.Transaction.Flag.CONTRACT_CREATION*/) > 0) {
             // TODO: Decode contract creation transactions
             // return ...
         }
diff --git a/src/views/SignTransactionSuccess.vue b/src/views/SignTransactionSuccess.vue
index 69e0ecf4b..8b52e0c2e 100644
--- a/src/views/SignTransactionSuccess.vue
+++ b/src/views/SignTransactionSuccess.vue
@@ -3,17 +3,14 @@ import { Component, Vue } from 'vue-property-decorator';
 import { SignedTransaction } from '../../client/PublicRequestTypes';
 import { State } from 'vuex-class';
 import KeyguardClient from '@nimiq/keyguard-client';
-import { bytesToHex, hexToBytes } from '../lib/BufferUtils';
 
 @Component({})
 export default class SignTransactionSuccess extends Vue {
     @State private keyguardResult!: KeyguardClient.SignTransactionResult;
 
-    private async mounted() {
-        const { Transaction } = await window.loadAlbatross();
-
-        const hex = bytesToHex(this.keyguardResult.serializedTx);
-        const tx = Transaction.fromAny(hex);
+    private mounted() {
+        const hex = Nimiq.BufferUtils.toHex(this.keyguardResult.serializedTx);
+        const tx = Nimiq.Transaction.fromAny(hex);
         const plain = tx.toPlain();
 
         const result: SignedTransaction = {
@@ -26,14 +23,14 @@ export default class SignTransactionSuccess extends Vue {
                 recipientType: tx.recipientType,
                 proof: tx.proof,
                 signerPublicKey: 'publicKey' in plain.proof
-                    ? hexToBytes(plain.proof.publicKey)
+                    ? Nimiq.BufferUtils.fromHex(plain.proof.publicKey)
                     : 'creatorPublicKey' in plain.proof
-                        ? hexToBytes(plain.proof.creatorPublicKey)
+                        ? Nimiq.BufferUtils.fromHex(plain.proof.creatorPublicKey)
                         : new Uint8Array(0),
                 signature: 'signature' in plain.proof
-                    ? hexToBytes(plain.proof.signature)
+                    ? Nimiq.BufferUtils.fromHex(plain.proof.signature)
                     : 'creatorSignature' in plain.proof
-                        ? hexToBytes(plain.proof.creatorSignature)
+                        ? Nimiq.BufferUtils.fromHex(plain.proof.creatorSignature)
                         : new Uint8Array(0),
                 extraData: tx.data,
                 networkId: tx.networkId,
diff --git a/tests/unit/CookieJar.spec.ts b/tests/unit/CookieJar.spec.ts
index d485f5a92..7ed34b4bb 100644
--- a/tests/unit/CookieJar.spec.ts
+++ b/tests/unit/CookieJar.spec.ts
@@ -15,12 +15,12 @@ const DUMMY_ADDRESS_HRV = 'NQ76 E5NX K4S8 9RS9 65FC DQ8C H5ML SCYG 81XJ'; // Ves
 const DUMMY_ADDRESS1: Nimiq.Address = Nimiq.Address.fromUserFriendlyAddress(DUMMY_ADDRESS_HR1);
 const DUMMY_ADDRESS2: Nimiq.Address = Nimiq.Address.fromUserFriendlyAddress(DUMMY_ADDRESS_HR2);
 const DUMMY_ADDRESSV: Nimiq.Address = Nimiq.Address.fromUserFriendlyAddress(DUMMY_ADDRESS_HRV);
-const DUMMY_ADDRESS_S1 = new Uint8Array(DUMMY_ADDRESS1.serialize());
-const DUMMY_ADDRESS_S2 = new Uint8Array(DUMMY_ADDRESS2.serialize());
-const DUMMY_ADDRESS_SV = new Uint8Array(DUMMY_ADDRESSV.serialize());
+const DUMMY_ADDRESS_S1 = DUMMY_ADDRESS1.serialize();
+const DUMMY_ADDRESS_S2 = DUMMY_ADDRESS2.serialize();
+const DUMMY_ADDRESS_SV = DUMMY_ADDRESSV.serialize();
 const BURN_ADDRESS_HR  = 'NQ07 0000 0000 0000 0000 0000 0000 0000 0000';
 const BURN_ADDRESS  = Nimiq.Address.fromUserFriendlyAddress(BURN_ADDRESS_HR);
-const BURN_ADDRESS_S = new Uint8Array(BURN_ADDRESS.serialize());
+const BURN_ADDRESS_S = BURN_ADDRESS.serialize();
 
 const DUMMY_WALLET_OBJECTS: WalletInfoEntry[] = [
     {
@@ -79,13 +79,13 @@ const DUMMY_WALLET_OBJECTS: WalletInfoEntry[] = [
             ],
         ]),
         contracts: [{
-            type: Nimiq.Account.Type.VESTING,
+            type: Nimiq.AccountType.Vesting,
             label: 'Vesting Contract',
             address: DUMMY_ADDRESS_SV,
             owner: BURN_ADDRESS_S,
-            start: 0,
+            startTime: 0,
             stepAmount: 419229878121,
-            stepBlocks: 2880,
+            timeStep: 2880 * 60e3,
             totalAmount: 2515379268724,
         }],
         type: WalletType.LEDGER,
@@ -188,13 +188,13 @@ const DUMMY_WALLET_OBJECTS: WalletInfoEntry[] = [
             ],
         ]),
         contracts: [{
-            type: Nimiq.Account.Type.VESTING,
+            type: Nimiq.AccountType.Vesting,
             label: 'Custom Label',
             address: DUMMY_ADDRESS_SV,
             owner: DUMMY_ADDRESS_S2,
-            start: 400000,
+            startTime: 400000 * 60e3,
             stepAmount: 419229878121,
-            stepBlocks: 28800,
+            timeStep: 28800 * 60e3,
             totalAmount: 2515379268724,
         }],
         type: WalletType.LEGACY,
@@ -257,13 +257,13 @@ const OUT_DUMMY_WALLET_OBJECTS: WalletInfoEntry[] = [
             ],
         ]),
         contracts: [{
-            type: Nimiq.Account.Type.VESTING,
+            type: Nimiq.AccountType.Vesting,
             label: 'Vesting Contract',
             address: DUMMY_ADDRESS_SV,
             owner: BURN_ADDRESS_S,
-            start: 0,
+            startTime: 0,
             stepAmount: 419229878121,
-            stepBlocks: 2880,
+            timeStep: 2880 * 60e3,
             totalAmount: 2515379268724,
         }],
         type: WalletType.LEDGER,
@@ -366,13 +366,13 @@ const OUT_DUMMY_WALLET_OBJECTS: WalletInfoEntry[] = [
             ],
         ]),
         contracts: [{
-            type: Nimiq.Account.Type.VESTING,
+            type: Nimiq.AccountType.Vesting,
             label: 'Custom Label',
             address: DUMMY_ADDRESS_SV,
             owner: DUMMY_ADDRESS_S2,
-            start: 400000,
+            startTime: 400000 * 60e3,
             stepAmount: 419229878121,
-            stepBlocks: 28800,
+            timeStep: 28800 * 60e3,
             totalAmount: 2515379268724,
         }],
         type: WalletType.LEGACY,
diff --git a/tests/unit/WalletStore.spec.ts b/tests/unit/WalletStore.spec.ts
index 26d441f59..8735beafe 100644
--- a/tests/unit/WalletStore.spec.ts
+++ b/tests/unit/WalletStore.spec.ts
@@ -36,9 +36,9 @@ const DUMMY: WalletInfo[] = [ // IDs must be alphabetically ordered, as the Wall
             Nimiq.Address.fromUserFriendlyAddress('NQ07 0000 0000 0000 0000 0000 0000 0000 0000'),
             Nimiq.Address.fromUserFriendlyAddress('NQ07 0000 0000 0000 0000 0000 0000 0000 0000'),
             Nimiq.Address.fromUserFriendlyAddress('NQ07 0000 0000 0000 0000 0000 0000 0000 0000'),
-            new Nimiq.Hash(Nimiq.BufferUtils
+            Nimiq.BufferUtils
                 .fromHex('0000000000000000000000000000000000000000000000000000000000000000')
-                .subarray(0, 32)),
+                .subarray(0, 32),
             1, 120, 3000e5,
         )], WalletType.LEDGER),
 ];
diff --git a/types/Nimiq.d.ts b/types/Nimiq.d.ts
index 15a232db5..41ac84ae0 100644
--- a/types/Nimiq.d.ts
+++ b/types/Nimiq.d.ts
@@ -1,2 +1,8 @@
-// tslint:disable-next-line no-reference
-/// <reference path="../node_modules/@nimiq/core-web/namespace.d.ts" />
+import type * as _Nimiq from '@nimiq/albatross-wasm';
+
+export as namespace Nimiq;
+export = _Nimiq;
+
+declare global {
+    const Nimiq: typeof _Nimiq;
+}
diff --git a/yarn.lock b/yarn.lock
index 11b8df658..3a67e5043 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1884,10 +1884,9 @@
   version "1.0.0"
   resolved "https://gitpkg.vercel.app/nimiq/keyguard?scripts.postinstall=cd%20client%20%26%26%20.%2Fbuild-gitpkg.sh&239c43cc712da603ce744eeede76f3b9d56d16b2#8650f137330f7da2bb1a4ecd798b10ace7f9f3a3"
 
-"@nimiq/ledger-api@^3.0.0":
+"@nimiq/ledger-api@github:nimiq/ledger-api#a7179c2d207c1deaeb2ab777ce6ad994e59f9c5f":
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/@nimiq/ledger-api/-/ledger-api-3.0.0.tgz#3ea78e8acc8045ac1e62b81ac708b2d5d5e9194c"
-  integrity sha512-iU3DQWg5GlAQ/1nt4R2S0Udwwa+XOQPkbGKp72PZS+woRc4VEziB0DQtI5HeZsJvzJtB/UcDCYJhNa3p1I6HVA==
+  resolved "https://codeload.github.com/nimiq/ledger-api/tar.gz/a7179c2d207c1deaeb2ab777ce6ad994e59f9c5f"
   dependencies:
     "@ledgerhq/hw-app-btc" "^10.0.9"
     "@ledgerhq/hw-transport" "^6.29.0"