+
+
diff --git a/src/main/pbc-ledger-client/PbcLedgerClient.ts b/src/main/pbc-ledger-client/PbcLedgerClient.ts
new file mode 100644
index 0000000..b6753b8
--- /dev/null
+++ b/src/main/pbc-ledger-client/PbcLedgerClient.ts
@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) 2022 - 2023 Partisia Blockchain Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+import BIPPath from "bip32-path";
+import type Transport from "@ledgerhq/hw-transport";
+import BN from "bn.js";
+import { Signature } from "../client/CryptoUtils";
+
+/**
+ * Serializes a BIP-32 path to a buffer.
+ */
+export function bip32Buffer(path: string): Buffer {
+ // Bip format to numbers
+
+ const pathElements: number[] = BIPPath.fromString(path).toPathArray();
+ const buffer = Buffer.alloc(1 + pathElements.length * 4);
+ buffer[0] = pathElements.length;
+ pathElements.forEach((pathElement, pathIdx) => {
+ buffer.writeUInt32BE(pathElement, 1 + 4 * pathIdx);
+ });
+ return buffer;
+}
+
+/**
+ * Serializes a number as an unsigned 32-bit integer as a buffer.
+ */
+function uint32BeBuffer(v: number): Buffer {
+ const buffer = Buffer.alloc(4);
+ buffer.writeUInt32BE(v, 0);
+ return buffer;
+}
+
+/**
+ * The maximum length of each APDU packets to send to the Ledger device.
+ *
+ * @see https://en.wikipedia.org/wiki/Smart_card_application_protocol_data_unit
+ */
+const MAX_APDU_DATA_LENGTH = 255;
+
+/**
+ * Instruction class for the PBC App.
+ *
+ * @see https://en.wikipedia.org/wiki/Smart_card_application_protocol_data_unit
+ */
+const CLA = 0xe0;
+
+/**
+ * Instructions for the PBC App.
+ *
+ * @see https://en.wikipedia.org/wiki/Smart_card_application_protocol_data_unit
+ */
+enum INS {
+ GET_VERSION = 0x03,
+ GET_APP_NAME = 0x04,
+ SIGN_TRANSACTION = 0x06,
+ GET_ADDRESS = 0x07,
+}
+
+/**
+ * First parameters for the PBC App.
+ *
+ * @see https://en.wikipedia.org/wiki/Smart_card_application_protocol_data_unit
+ */
+enum P1 {
+ P1_FIRST_CHUNK = 0x00,
+ P1_NOT_FIRST_CHUNK = 0x01,
+}
+
+const P1_CONFIRM_ADDRESS_ON_SCREEN = 0x01;
+
+/**
+ * Second parameters for the PBC App.
+ *
+ * @see https://en.wikipedia.org/wiki/Smart_card_application_protocol_data_unit
+ */
+enum P2 {
+ P2_LAST_CHUNK = 0x00,
+ P2_NOT_LAST_CHUNK = 0x80,
+}
+
+/**
+ * Splits the given buffer into chunks of at most chunkSize.
+ */
+function chunkifyBuffer(buffer: Buffer, chunkSize: number): Buffer[] {
+ const chunks: Buffer[] = [];
+ for (let i = 0; i < buffer.length; i += chunkSize) {
+ chunks.push(buffer.slice(i, Math.min(buffer.length, i + chunkSize)));
+ }
+ return chunks;
+}
+
+/**
+ * Wrapper class capable of interacting with the Ledger hardware wallet through
+ * APDU calls.
+ */
+export class PbcLedgerClient {
+ private readonly ledgerTransport: Transport;
+
+ constructor(ledgerTransport: Transport) {
+ this.ledgerTransport = ledgerTransport;
+ }
+
+ /**
+ * Asks the Ledger hardware wallet about the address that it will sign for.
+ */
+ public getAddress(keyPath: string, confirmOnScreen = false): Promise {
+ return this.ledgerTransport
+ .send(
+ CLA,
+ INS.GET_ADDRESS,
+ confirmOnScreen ? P1_CONFIRM_ADDRESS_ON_SCREEN : P1.P1_FIRST_CHUNK,
+ P2.P2_LAST_CHUNK,
+ bip32Buffer(keyPath)
+ )
+ .then((result) => result.slice(0, 21).toString("hex"));
+ }
+
+ /**
+ * Attempts to sign a transaction by communicating with a Ledger hardware
+ * wallet.
+ *
+ * Returns a signature as a promised buffer.
+ */
+ public async signTransaction(
+ keyPath: string,
+ serializedTransaction: Buffer,
+ chainId: string
+ ): Promise {
+ const chainIdBuffer = Buffer.from(chainId, "utf8");
+
+ // Setup data to send
+ const initialChunkData = Buffer.concat([
+ bip32Buffer(keyPath),
+ uint32BeBuffer(chainIdBuffer.length),
+ chainIdBuffer,
+ ]);
+
+ const subsequentChunkData = chunkifyBuffer(serializedTransaction, MAX_APDU_DATA_LENGTH);
+
+ // Setup promise flow
+ let result = await this.ledgerTransport.send(
+ CLA,
+ INS.SIGN_TRANSACTION,
+ P1.P1_FIRST_CHUNK,
+ P2.P2_NOT_LAST_CHUNK,
+ initialChunkData
+ );
+
+ // Iterate blocks
+ for (let chunkIdx = 0; chunkIdx < subsequentChunkData.length; chunkIdx++) {
+ const chunk = subsequentChunkData[chunkIdx];
+ const isLastChunk = chunkIdx == subsequentChunkData.length - 1;
+ result = await this.ledgerTransport.send(
+ CLA,
+ INS.SIGN_TRANSACTION,
+ P1.P1_NOT_FIRST_CHUNK,
+ isLastChunk ? P2.P2_LAST_CHUNK : P2.P2_NOT_LAST_CHUNK,
+ chunk
+ );
+ }
+
+ // Deserialize signature from the transfer format
+ return {
+ recoveryParam: result[0],
+ r: new BN(result.slice(1, 32 + 1)),
+ s: new BN(result.slice(32 + 1, 32 + 32 + 1)),
+ };
+ }
+}
diff --git a/src/main/pbc-ledger-client/bip32-path.d.ts b/src/main/pbc-ledger-client/bip32-path.d.ts
new file mode 100644
index 0000000..aa985a9
--- /dev/null
+++ b/src/main/pbc-ledger-client/bip32-path.d.ts
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2022 - 2023 Partisia Blockchain Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+declare module "bip32-path";
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+class BIPPath {}
diff --git a/src/main/shared/ConnectedWallet.ts b/src/main/shared/ConnectedWallet.ts
new file mode 100644
index 0000000..6b009ef
--- /dev/null
+++ b/src/main/shared/ConnectedWallet.ts
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2022 - 2023 Partisia Blockchain Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+import { ShardPutTransactionResponse } from "../client/ShardedClient";
+import { Rpc, TransactionPayload } from "../client/TransactionData";
+import { ShardedClient } from "../client/ShardedClient";
+
+/**
+ * Unified interface for connected MPC wallets.
+ *
+ * These wallets are capable of reporting their address and can sign and send
+ * a transaction.
+ */
+export interface ConnectedWallet {
+ /**
+ * The address that transactions will be sent from.
+ */
+ readonly address: string;
+ /**
+ * Method to sign and send a transaction to the blockchain.
+ */
+ readonly signAndSendTransaction: (
+ client: ShardedClient,
+ payload: TransactionPayload,
+ cost?: string | number
+ ) => Promise;
+}
diff --git a/src/main/shared/LedgerIntegration.ts b/src/main/shared/LedgerIntegration.ts
new file mode 100644
index 0000000..1074d6e
--- /dev/null
+++ b/src/main/shared/LedgerIntegration.ts
@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2022 - 2023 Partisia Blockchain Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+import { ConnectedWallet } from "./ConnectedWallet";
+import { ShardedClient } from "../client/ShardedClient";
+import { ShardPutTransactionResponse } from "../client/ShardedClient";
+import { TransactionApi } from "../client/TransactionApi";
+import { PbcLedgerClient } from "../pbc-ledger-client/PbcLedgerClient";
+import { listen } from "@ledgerhq/logs";
+import { CryptoUtils } from "../client/CryptoUtils";
+import { Rpc, TransactionPayload } from "../client/TransactionData";
+import { serializeTransaction } from "../client/TransactionSerialization";
+import { NETWORK_ID } from "../constant";
+
+import TransportWebUSB from "@ledgerhq/hw-transport-webusb";
+//import TransportWebHID from "@ledgerhq/hw-transport-webhid";
+
+const DEFAULT_KEYPATH = "44'/3757'/0'/0/0";
+
+const HACKY_DOWNLOAD_SIGNED_TRANSACTION: boolean = true;
+
+/**
+ * Internal utility for signing a transaction using a Ledger hardware device,
+ * and then sending the transaction.
+ *
+ * @param client Blockchain client.
+ * @param payload Payload to sign and send.
+ * @param cost Cost to use to send.
+ * @param ledgerClient Client for using the PBC App on the Ledger Hardware
+ * Device.
+ * @param senderAddress Address of the sender
+ */
+async function signAndSendTransaction(
+ client: ShardedClient,
+ payload: TransactionPayload,
+ cost: string | number,
+ ledgerClient: PbcLedgerClient,
+ senderAddress: string
+): Promise {
+
+ // To send a transaction we need some up-to-date account information, i.e. the
+ // current account nonce.
+ const accountData = await client.getAccountData(senderAddress);
+
+ if (accountData == null) {
+ throw new Error("Account data was null");
+ }
+
+ // Account data was fetched, build and serialize the transaction
+ // data.
+ const serializedTx = serializeTransaction(
+ {
+ cost: String(cost),
+ nonce: accountData.nonce,
+ validTo: String(new Date().getTime() + TransactionApi.TRANSACTION_TTL),
+ },
+ payload
+ );
+
+ // Use ledger device to sign transaction
+ const signature = await ledgerClient.signTransaction(DEFAULT_KEYPATH, serializedTx, NETWORK_ID);
+
+ const signatureBuffer = CryptoUtils.signatureToBuffer(signature);
+
+ // Serialize transaction for sending
+ const transactionPayload = Buffer.concat([signatureBuffer, serializedTx]);
+
+ if (HACKY_DOWNLOAD_SIGNED_TRANSACTION) {
+ const blob = new Blob([transactionPayload], {type:"application/octet-stream"});
+ const url = window.URL.createObjectURL(blob);
+ window.open(url);
+
+ return { putSuccessful: false };
+ }
+
+ // Send the transaction to the blockchain
+ const txPointer = await client.putTransaction(transactionPayload);
+
+ // Create result
+ if (txPointer != null) {
+ return {
+ putSuccessful: true,
+ shard: txPointer.destinationShardId,
+ transactionHash: txPointer.identifier,
+ };
+ } else {
+ return { putSuccessful: false };
+ }
+}
+
+/**
+ * Initializes a ConnectedWallet by connecting to a Ledger Hardware Wallet.
+ *
+ * Both the initial connection and sending of a transaction will require the
+ * user to interact with their Ledger device.
+ *
+ * Does not take any arguments as everything is automatically determined from the
+ * environment.
+ */
+export const connectLedger = async (): Promise => {
+ const ledgerTransport = await TransportWebUSB.create();
+ //const ledgerTransport = await TransportWebHID.create();
+
+ //listen to the events which are sent by the Ledger packages in order to debug the app
+ // eslint-disable-next-line no-console
+ listen((log) => console.log(log));
+
+ const ledgerClient = new PbcLedgerClient(ledgerTransport);
+ const senderAddress = await ledgerClient.getAddress(DEFAULT_KEYPATH);
+
+ return {
+ address: senderAddress,
+ signAndSendTransaction: (client: ShardedClient, payload: TransactionPayload, cost = 0) =>
+ signAndSendTransaction(client, payload, cost, ledgerClient, senderAddress),
+ };
+};
+
+/**
+ * Shows the address on the Ledger.
+ *
+ * Does not take any arguments as everything is automatically determined from the
+ * environment.
+ */
+export const validateLedgerConnection = async (): Promise => {
+ const ledgerTransport = await TransportWebUSB.create();
+ //const ledgerTransport = await TransportWebHID.create();
+
+ const ledgerClient = new PbcLedgerClient(ledgerTransport);
+ await ledgerClient.getAddress(DEFAULT_KEYPATH, true);
+};
diff --git a/src/main/shared/MetaMaskIntegration.ts b/src/main/shared/MetaMaskIntegration.ts
new file mode 100644
index 0000000..331b496
--- /dev/null
+++ b/src/main/shared/MetaMaskIntegration.ts
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2022 - 2023 Partisia Blockchain Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+import { ConnectedWallet } from "./ConnectedWallet";
+import { serializeTransaction } from "../client/TransactionSerialization";
+import { TransactionApi } from "../client/TransactionApi";
+import { ShardedClient } from "../client/ShardedClient";
+import { NETWORK_ID } from "../constant";
+
+interface MetamaskRequestArguments {
+ /** The RPC method to request. */
+ method: string;
+ /** The params of the RPC method, if any. */
+ params?: unknown[] | Record;
+}
+
+interface MetaMask {
+ request(args: MetamaskRequestArguments): Promise;
+}
+
+/**
+ * Initializes a ConnectedWallet by connecting to MetaMask snap.
+ *
+ * Does not take any arguments as everything is automatically determined from the
+ * environment. An error is thrown if the MetaMask extension is not installed.
+ */
+export const connectMetaMask = async (): Promise => {
+ const snapId = "npm:@partisiablockchain/snap";
+
+ if ("ethereum" in window) {
+ const metamask = window.ethereum as MetaMask;
+
+ // Request snap to be installed and connected
+ await metamask.request({
+ method: "wallet_requestSnaps",
+ params: {
+ [snapId]: {},
+ },
+ });
+
+ // Get the address of the user from the snap
+ const userAddress: string = await metamask.request({
+ method: "wallet_invokeSnap",
+ params: { snapId, request: { method: "get_address" } },
+ });
+
+ return {
+ address: userAddress,
+ signAndSendTransaction: async (client: ShardedClient, payload, cost = 0) => {
+ // To send a transaction we need some up-to-date account information, i.e. the
+ // current account nonce.
+ const accountData = await client.getAccountData(userAddress);
+ if (accountData == null) {
+ throw new Error("Account data was null");
+ }
+ // Account data was fetched, build and serialize the transaction
+ // data.
+ const serializedTx = serializeTransaction(
+ {
+ cost: String(cost),
+ nonce: accountData.nonce,
+ validTo: String(new Date().getTime() + TransactionApi.TRANSACTION_TTL),
+ },
+ payload
+ );
+
+ // Request signature from MetaMask
+ const signature: string = await metamask.request({
+ method: "wallet_invokeSnap",
+ params: {
+ snapId: "npm:@partisiablockchain/snap",
+ request: {
+ method: "sign_transaction",
+ params: {
+ payload: serializedTx.toString("hex"),
+ chainId: NETWORK_ID,
+ },
+ },
+ },
+ });
+
+ // Serialize transaction for sending
+ const transactionPayload = Buffer.concat([Buffer.from(signature, "hex"), serializedTx]);
+
+ // Send the transaction to the blockchain
+ return client.putTransaction(transactionPayload).then((txPointer) => {
+ if (txPointer != null) {
+ return {
+ putSuccessful: true,
+ shard: txPointer.destinationShardId,
+ transactionHash: txPointer.identifier,
+ };
+ } else {
+ return { putSuccessful: false };
+ }
+ });
+ },
+ };
+ } else {
+ throw new Error("Unable to find MetaMask extension");
+ }
+};
diff --git a/src/main/shared/MpcWalletIntegration.ts b/src/main/shared/MpcWalletIntegration.ts
new file mode 100644
index 0000000..9715a52
--- /dev/null
+++ b/src/main/shared/MpcWalletIntegration.ts
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2022 - 2023 Partisia Blockchain Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+import { ConnectedWallet } from "./ConnectedWallet";
+import { serializeTransaction } from "../client/TransactionSerialization";
+import { TransactionApi } from "../client/TransactionApi";
+import { ShardedClient } from "../client/ShardedClient";
+import PartisiaSdk from "partisia-blockchain-applications-sdk";
+import { NETWORK_ID } from "../constant";
+
+/**
+ * Initializes a new ConnectedWallet by connecting to Partisia Blockchain
+ * Applications MPC wallet.
+ *
+ * Does not take any arguments as everything is automatically determined from the
+ * environment. An error is thrown if the MPC Wallet extension is not installed.
+ */
+export const connectMpcWallet = async (): Promise => {
+ const partisiaSdk = new PartisiaSdk();
+ return partisiaSdk
+ .connect({
+ // eslint-disable-next-line
+ permissions: ["sign" as any],
+ dappName: "Wallet integration demo",
+ chainId: NETWORK_ID,
+ })
+ .then(() => {
+ const connection = partisiaSdk.connection;
+ if (connection != null) {
+ // User connection was successful. Use the connection to build up a connected wallet
+ // in state.
+ const userAccount: ConnectedWallet = {
+ address: connection.account.address,
+ signAndSendTransaction: (client: ShardedClient, payload, cost = 0) => {
+ // To send a transaction we need some up-to-date account information, i.e. the
+ // current account nonce.
+ return client.getAccountData(connection.account.address).then((accountData) => {
+ if (accountData == null) {
+ throw new Error("Account data was null");
+ }
+ // Account data was fetched, build and serialize the transaction
+ // data.
+ const serializedTx = serializeTransaction(
+ {
+ cost: String(cost),
+ nonce: accountData.nonce,
+ validTo: String(new Date().getTime() + TransactionApi.TRANSACTION_TTL),
+ },
+ payload
+ );
+ // Ask the MPC wallet to sign and send the transaction.
+ return partisiaSdk
+ .signMessage({
+ payload: serializedTx.toString("hex"),
+ payloadType: "hex",
+ dontBroadcast: false,
+ })
+ .then((value) => {
+ return {
+ putSuccessful: true,
+ shard: client.shardForAddress(connection.account.address),
+ transactionHash: value.trxHash,
+ };
+ })
+ .catch(() => ({
+ putSuccessful: false,
+ }));
+ });
+ },
+ };
+ return userAccount;
+ } else {
+ throw new Error("Unable to establish connection to MPC wallet");
+ }
+ })
+ .catch((error) => {
+ // Something went wrong with the connection.
+ if (error instanceof Error) {
+ if (error.message === "Extension not Found") {
+ throw new Error("Partisia Wallet Extension not found.");
+ } else if (error.message === "user closed confirm window") {
+ throw new Error("Sign in using MPC wallet was cancelled");
+ } else if (error.message === "user rejected") {
+ throw new Error("Sign in using MPC wallet was rejected");
+ } else {
+ throw error;
+ }
+ } else {
+ throw new Error(error);
+ }
+ });
+};
diff --git a/src/main/shared/PrivateKeyIntegration.ts b/src/main/shared/PrivateKeyIntegration.ts
new file mode 100644
index 0000000..0c19c7a
--- /dev/null
+++ b/src/main/shared/PrivateKeyIntegration.ts
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2022 - 2023 Partisia Blockchain Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+import { ConnectedWallet } from "./ConnectedWallet";
+import { serializeTransaction } from "../client/TransactionSerialization";
+import { TransactionApi } from "../client/TransactionApi";
+import { ShardedClient } from "../client/ShardedClient";
+import { Rpc, TransactionPayload } from "../client/TransactionData";
+import { BigEndianByteOutput } from "@secata-public/bitmanipulation-ts";
+import { CryptoUtils } from "../client/CryptoUtils";
+import { ec } from "elliptic";
+import { NETWORK_ID } from "../constant";
+
+/**
+ * Initializes a ConnectedWallet by inputting the private key directly.
+ */
+export const connectPrivateKey = async (
+ sender: string,
+ keyPair: ec.KeyPair
+): Promise => {
+ return {
+ address: sender,
+ signAndSendTransaction: (client: ShardedClient, payload: TransactionPayload, cost = 0) => {
+ // To send a transaction we need some up-to-date account information, i.e. the
+ // current account nonce.
+ return client.getAccountData(sender).then((accountData) => {
+ if (accountData == null) {
+ throw new Error("Account data was null");
+ }
+ // Account data was fetched, build and serialize the transaction
+ // data.
+ const serializedTx = serializeTransaction(
+ {
+ cost: String(cost),
+ nonce: accountData.nonce,
+ validTo: String(new Date().getTime() + TransactionApi.TRANSACTION_TTL),
+ },
+ payload
+ );
+ const hash = CryptoUtils.hashBuffers([
+ serializedTx,
+ BigEndianByteOutput.serialize((out) => out.writeString(NETWORK_ID)),
+ ]);
+ const signature = keyPair.sign(hash);
+ const signatureBuffer = CryptoUtils.signatureToBuffer(signature);
+
+ // Serialize transaction for sending
+ const transactionPayload = Buffer.concat([signatureBuffer, serializedTx]);
+
+ // Send the transaction to the blockchain
+ return client.putTransaction(transactionPayload).then((txPointer) => {
+ if (txPointer != null) {
+ return {
+ putSuccessful: true,
+ shard: txPointer.destinationShardId,
+ transactionHash: txPointer.identifier,
+ };
+ } else {
+ return { putSuccessful: false };
+ }
+ });
+ });
+ },
+ };
+};
diff --git a/src/main/shared/TokenContract.ts b/src/main/shared/TokenContract.ts
new file mode 100644
index 0000000..66e2b21
--- /dev/null
+++ b/src/main/shared/TokenContract.ts
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2022 - 2023 Partisia Blockchain Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+import BN from "bn.js";
+import { BlockchainAddress } from "@partisiablockchain/abi-client";
+import { PutTransactionWasSuccessful } from "../client/TransactionData";
+
+export interface TokenContractBasicState {
+ name: string;
+ decimals: number;
+ symbol: string;
+ owner: BlockchainAddress;
+ totalSupply: BN;
+}
+
+export interface TokenBalancesResult {
+ balances: Map;
+ next_cursor: string | undefined;
+}
+
+/**
+ * Unified API for token contracts.
+ *
+ * This minimal implementation only allows for transferring tokens to a single address.
+ *
+ * The implementation uses the TransactionApi to send transactions, and ABI for the contract to be
+ * able to build the RPC for the transfer transaction.
+ */
+export interface TokenContract {
+ /**
+ * Build transfer transaction RPC.
+ *
+ * @param to receiver of tokens
+ * @param amount number of tokens to send
+ * @param Large memo
+ */
+ readonly transfer: (
+ contractAddress: BlockchainAddress,
+ to: BlockchainAddress,
+ amount: BN,
+ memo: string,
+ ) => Promise;
+
+ /**
+ * Determines the basic state of the contract.
+ */
+ readonly basicState?: (contractAddress: BlockchainAddress) => Promise;
+
+ /**
+ * Fetch a specific balance
+ */
+ readonly tokenBalance?: (
+ contractAddress: BlockchainAddress,
+ owner: BlockchainAddress
+ ) => Promise;
+
+ /**
+ * Iterator for fetching token balances.
+ */
+ readonly tokenBalances?: (
+ contractAddress: BlockchainAddress,
+ cursor: string | undefined
+ ) => Promise;
+}
diff --git a/src/main/token/AppState.ts b/src/main/token/AppState.ts
new file mode 100644
index 0000000..1698d51
--- /dev/null
+++ b/src/main/token/AppState.ts
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2022 - 2023 Partisia Blockchain Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+import { ConnectedWallet } from "../shared/ConnectedWallet";
+import { ContractAbi, BlockchainAddress } from "@partisiablockchain/abi-client";
+import { ShardedClient } from "../client/ShardedClient";
+import { TokenContract } from "../shared/TokenContract";
+import { TransactionApi } from "../client/TransactionApi";
+import { updateContractState } from "./WalletIntegration";
+import { NODE_BASE_URL, NETWORK_SHARDS } from "../constant";
+
+export const CLIENT = new ShardedClient(NODE_BASE_URL, NETWORK_SHARDS);
+
+type TokenContractCreator = (
+ client: ShardedClient,
+ transactionApi: TransactionApi | undefined
+) => TokenContract;
+
+let lastBalanceKey: string | undefined;
+let contractAddress: BlockchainAddress | undefined;
+let currentAccount: ConnectedWallet | undefined;
+let contractAbi: ContractAbi | undefined;
+let tokenApi: TokenContract | undefined;
+
+/*eslint @typescript-eslint/no-unused-vars: ["error", { "argsIgnorePattern": "^unused" }]*/
+
+let tokenContractCreator: TokenContractCreator = (unusedClient, unusedContract) => {
+ throw new Error("tokenContractCreator was not set");
+};
+
+export function setTokenContractType(creator: TokenContractCreator) {
+ tokenContractCreator = creator;
+}
+
+export const setAccount = (account: ConnectedWallet | undefined) => {
+ currentAccount = account;
+ setTokenApi();
+};
+
+export const resetAccount = () => {
+ currentAccount = undefined;
+};
+
+export const isConnected = () => {
+ return currentAccount != null;
+};
+
+export const setContractAbi = (abi: ContractAbi) => {
+ contractAbi = abi;
+ setTokenApi();
+};
+
+export const getContractAbi = () => {
+ return contractAbi;
+};
+
+const setTokenApi = () => {
+ let transactionApi = undefined;
+ if (currentAccount != undefined) {
+ transactionApi = new TransactionApi(CLIENT, currentAccount, updateContractState);
+ }
+ tokenApi = tokenContractCreator(CLIENT, transactionApi);
+};
+
+export const getTokenApi = () => {
+ return tokenApi;
+};
+
+export const getContractAddress = () => {
+ return contractAddress;
+};
+
+export const setContractAddress = (address: BlockchainAddress) => {
+ contractAddress = address;
+ setTokenApi();
+};
+
+export const getContractLastBalanceKey = () => {
+ return lastBalanceKey;
+};
+
+export const setContractLastBalanceKey = (address: string | undefined) => {
+ lastBalanceKey = address;
+};
diff --git a/src/main/token/Main.ts b/src/main/token/Main.ts
new file mode 100644
index 0000000..5fb60d1
--- /dev/null
+++ b/src/main/token/Main.ts
@@ -0,0 +1,205 @@
+/*
+ * Copyright (C) 2022 - 2023 Partisia Blockchain Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+import {
+ setTokenContractType,
+ getTokenApi,
+ getContractAddress,
+ isConnected,
+ setContractAddress,
+} from "./AppState";
+import {
+ connectMetaMaskWalletClick,
+ connectMpcWalletClick,
+ connectLedgerWalletClick,
+ connectPrivateKeyWalletClick,
+ validateLedgerConnectionClick,
+ disconnectWalletClick,
+ fetchAndDisplayMoreBalances,
+ updateContractState,
+ updateInteractionVisibility,
+} from "./WalletIntegration";
+import { TokenV1Contract } from "./contract/TokenV1Contract";
+import { TokenV2Contract } from "./contract/TokenV2Contract";
+import { MpcTokenContract, MPC_TOKEN_CONTRACT_ADDRESS } from "./contract/MpcTokenContract";
+import BN from "bn.js";
+import { BlockchainAddress } from "@partisiablockchain/abi-client";
+import { TransactionFailedError } from "../client/TransactionApi";
+import { PutTransactionWasSuccessful } from "../client/TransactionData";
+import { BROWSER_BASE_URL } from "../constant";
+
+// Setup event listener to connect to the MPC wallet browser extension
+const connectWallet = document.querySelector("#wallet-connect-btn");
+connectWallet.addEventListener("click", connectMpcWalletClick);
+
+// Setup event listener to connect to the MetaMask snap
+const metaMaskConnect = document.querySelector("#metamask-connect-btn");
+metaMaskConnect.addEventListener("click", connectMetaMaskWalletClick);
+
+// Setup event listener to connect to the ledger snap
+const ledgerConnect = document.querySelector("#ledger-connect-btn");
+ledgerConnect.addEventListener("click", connectLedgerWalletClick);
+
+const ledgerConnectValidate = document.querySelector("#connection-link-ledger-validate");
+ledgerConnectValidate.addEventListener("click", validateLedgerConnectionClick);
+
+// Setup event listener to login using private key
+const pkConnect = document.querySelector("#private-key-connect-btn");
+pkConnect.addEventListener("click", connectPrivateKeyWalletClick);
+
+// Setup event listener to drop the connection again
+const disconnectWallet = document.querySelector("#wallet-disconnect-btn");
+disconnectWallet.addEventListener("click", disconnectWalletClick);
+
+// Setup event listener that sends a transfer transaction to the contract.
+// This requires that a wallet has been connected.
+
+const transferBtn = document.querySelector("#transfer-btn");
+transferBtn.addEventListener("click", transferAction);
+
+const addressBtn = document.querySelector("#address-btn");
+addressBtn.addEventListener("click", contractAddressClick);
+
+const updateStateBtn = document.querySelector("#update-state-btn");
+updateStateBtn.addEventListener("click", updateContractState);
+
+const getBalanceBtn = document.querySelector("#get-balance-btn");
+getBalanceBtn.addEventListener("click", getBalance);
+
+const loadMoreBtn = document.querySelector("#balances-load-more-btn");
+loadMoreBtn.addEventListener("click", fetchAndDisplayMoreBalances);
+
+function setModeText(modeText: string) {
+ let items = document.querySelectorAll("title");
+ items.forEach((item) => {
+ item.innerText = modeText;
+ });
+ items = document.querySelectorAll(".mode");
+ items.forEach((item) => {
+ item.innerText = modeText;
+ });
+}
+
+function setTokenContractByGetMode() {
+ const mode = window.location.search.substr(1);
+ if (mode == "mpc20-v1") {
+ setTokenContractType((client, transactionApi) => new TokenV1Contract(client, transactionApi));
+ setModeText("MPC20-V1");
+
+ const getBalanceForm = document.querySelector("#get-balance-form");
+
+ getBalanceForm.classList.add("hidden");
+ } else if (mode == "mpc20-v2") {
+ setTokenContractType((client, transactionApi) => new TokenV2Contract(client, transactionApi));
+ setModeText("MPC20-V2");
+ } else if (mode == "mpc-token") {
+ setTokenContractType((client, transactionApi) => new MpcTokenContract(client, transactionApi));
+ setContractAddressUI(MPC_TOKEN_CONTRACT_ADDRESS);
+ setModeText("MPC Token");
+ }
+}
+
+// Setup token contract type
+setTokenContractByGetMode();
+
+function setContractAddressUI(address: BlockchainAddress) {
+ const currentAddress = document.querySelector("#current-address");
+ const inputAddress = document.querySelector("#address-value");
+
+ currentAddress.innerText = address.asString();
+ currentAddress.href = `${BROWSER_BASE_URL}/contracts/${address.asString()}`;
+ inputAddress.value = address.asString();
+ setContractAddress(address);
+ updateInteractionVisibility();
+ updateContractState();
+}
+
+/** Function for the contract address form.
+ * This is called when the user clicks on the connect to contract button.
+ * It validates the address, and then gets the state for the contract.
+ */
+function contractAddressClick() {
+ const address = (document.querySelector("#address-value")).value;
+ const regex = /[0-9A-Fa-f]{42}/g;
+ if (address === undefined) {
+ throw new Error("Need to provide a contract address");
+ } else if (address.length != 42 || address.match(regex) == null) {
+ // Validate that address is 21 bytes in hexidecimal format
+ throw new Error(`${address} is not a valid PBC address`);
+ }
+
+ setContractAddressUI(BlockchainAddress.fromString(address));
+}
+
+const transactionErrorMessage = document.querySelector("#sign-transaction-error");
+const transactionLinkElement = document.querySelector("#sign-transaction-link");
+
+function setTransactionLink(transaction: PutTransactionWasSuccessful) {
+ const transactionLinkElement = document.querySelector("#sign-transaction-link");
+ transactionLinkElement.innerHTML = `Transaction link in browser`;
+ transactionErrorMessage.innerText = "";
+}
+
+/** Action for the sign petition button */
+function transferAction() {
+ const api = getTokenApi();
+ const contractAddress = getContractAddress();
+ if (isConnected() && api !== undefined && contractAddress !== undefined) {
+ const to = document.querySelector("#address-to");
+ const amount = document.querySelector("#amount");
+ const memo = document.querySelector("#memo");
+
+ transactionErrorMessage.innerHTML = '';
+ transactionLinkElement.innerText = "";
+ api
+ .transfer(contractAddress, BlockchainAddress.fromString(to.value), new BN(amount.value, 10), memo.value)
+ .then(setTransactionLink)
+ .catch((error) => {
+ console.error(error);
+ if (error instanceof TransactionFailedError) {
+ setTransactionLink(error.putTransaction);
+ }
+ transactionErrorMessage.innerText = error;
+ });
+ }
+}
+
+function getBalance() {
+ const address = getContractAddress();
+ const regex = /[0-9A-Fa-f]{42}/g;
+ const tokenAbi = getTokenApi();
+ if (address !== undefined && tokenAbi != undefined) {
+ const balanceAddress = (document.querySelector("#get-balance-address")).value;
+ if (balanceAddress.length != 42 || balanceAddress.match(regex) == null) {
+ // Validate that address is 21 bytes in hexidecimal format
+ console.error(`${address} is not a valid PBC address`);
+ } else if (tokenAbi.tokenBalance != undefined) {
+ const balanceValue = document.querySelector("#balance-value");
+ balanceValue.innerHTML = ' ';
+ tokenAbi
+ .tokenBalance(address, BlockchainAddress.fromString(balanceAddress))
+ .then((value) => {
+ balanceValue.innerHTML = ` Value: ${value.toString(10)}`;
+ })
+ .catch((error) => {
+ console.error(error);
+ balanceValue.innerText = error;
+ });
+ }
+ }
+}
diff --git a/src/main/token/WalletIntegration.ts b/src/main/token/WalletIntegration.ts
new file mode 100644
index 0000000..fde0fbe
--- /dev/null
+++ b/src/main/token/WalletIntegration.ts
@@ -0,0 +1,231 @@
+/*
+ * Copyright (C) 2022 - 2023 Partisia Blockchain Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+import {
+ resetAccount,
+ setAccount,
+ getContractAddress,
+ isConnected,
+ getContractLastBalanceKey,
+ setContractLastBalanceKey,
+ getTokenApi,
+} from "./AppState";
+import { ConnectedWallet } from "../shared/ConnectedWallet";
+import { connectMetaMask } from "../shared/MetaMaskIntegration";
+import { connectMpcWallet } from "../shared/MpcWalletIntegration";
+import { connectLedger, validateLedgerConnection } from "../shared/LedgerIntegration";
+import { connectPrivateKey } from "../shared/PrivateKeyIntegration";
+import { CryptoUtils } from "../client/CryptoUtils";
+
+/**
+ * Function for connecting to the MPC wallet and setting the connected wallet in the app state.
+ */
+export const connectMetaMaskWalletClick = () => {
+ handleWalletConnect(connectMetaMask());
+};
+
+/**
+ * Function for connecting to the MPC wallet and setting the connected wallet in the app state.
+ */
+export const connectLedgerWalletClick = () => {
+ handleWalletConnect(connectLedger());
+ setVisibility("#connection-link-ledger-validate", true);
+};
+
+/**
+ * Shows the address on the Ledger.
+ */
+export const validateLedgerConnectionClick = () => {
+ validateLedgerConnection();
+};
+
+/**
+ * Function for connecting to the MPC wallet and setting the connected wallet in the app state.
+ */
+export const connectMpcWalletClick = () => {
+ // Call Partisia SDK to initiate connection
+ handleWalletConnect(connectMpcWallet());
+};
+
+/**
+ * Connect to the blockchain using a private key. Reads the private key from the form.
+ */
+export const connectPrivateKeyWalletClick = () => {
+ const privateKey = document.querySelector("#private-key-value");
+ const keyPair = CryptoUtils.privateKeyToKeypair(privateKey.value);
+ const sender = CryptoUtils.keyPairToAccountAddress(keyPair);
+ handleWalletConnect(connectPrivateKey(sender, keyPair));
+};
+
+/**
+ * Common code for handling a generic wallet connection.
+ * @param connect the wallet connection. Can be Mpc Wallet, Metamask, or using a private key.
+ */
+const handleWalletConnect = (connect: Promise) => {
+ // Clean up state
+ resetAccount();
+ setConnectionStatus("Connecting...");
+ connect
+ .then((userAccount) => {
+ setAccount(userAccount);
+
+ // Fix UI
+ setConnectionStatus("Logged in: ", userAccount.address);
+ setVisibility("#wallet-connect", false);
+ setVisibility("#metamask-connect", false);
+ setVisibility("#ledger-connect", false);
+ setVisibility("#private-key-connect", false);
+ setVisibility("#wallet-disconnect", true);
+ updateInteractionVisibility();
+ })
+ .catch((error) => {
+ console.error(error);
+ if ("message" in error) {
+ setConnectionStatus(error.message);
+ } else {
+ setConnectionStatus("An error occurred trying to connect wallet: " + error);
+ }
+ });
+};
+
+/**
+ * Reset state to disconnect current user.
+ */
+export const disconnectWalletClick = () => {
+ resetAccount();
+ setConnectionStatus("Disconnected account");
+ setVisibility("#wallet-connect", true);
+ setVisibility("#metamask-connect", true);
+ setVisibility("#ledger-connect", true);
+ setVisibility("#private-key-connect", true);
+ setVisibility("#wallet-disconnect", false);
+ setVisibility("#connection-link-ledger-validate", false);
+ updateInteractionVisibility();
+};
+
+const ALL_BALANCES_LIST = document.querySelector("#all-balances");
+
+/**
+ * Write some of the state to the UI.
+ */
+export const updateContractState = () => {
+ const address = getContractAddress();
+ if (address === undefined) {
+ throw new Error("No address provided");
+ }
+ const tokenApi = getTokenApi();
+ if (tokenApi === undefined) {
+ throw new Error("Token API not setup");
+ }
+
+ const refreshLoader = document.querySelector("#refresh-loader");
+ refreshLoader.classList.remove("hidden");
+
+ if (tokenApi.basicState != undefined) {
+ tokenApi.basicState(address).then((state) => {
+ const stateHeader = document.querySelector("#state-header");
+ const updateStateButton = document.querySelector("#update-state");
+ stateHeader.classList.remove("hidden");
+ updateStateButton.classList.remove("hidden");
+
+ const name = document.querySelector("#name");
+ name.innerHTML = `${state.name}`;
+
+ const decimals = document.querySelector("#decimals");
+ decimals.innerHTML = `${state.decimals}`;
+
+ const symbol = document.querySelector("#symbol");
+ symbol.innerHTML = `${state.symbol}`;
+
+ const owner = document.querySelector("#owner");
+ owner.innerHTML = `${state.owner.asString()}`;
+
+ const totalSupply = document.querySelector("#total-supply");
+ totalSupply.innerHTML = `${state.totalSupply}`;
+
+ const contractState = document.querySelector("#contract-state");
+ contractState.classList.remove("hidden");
+ refreshLoader.classList.add("hidden");
+ });
+ }
+
+ setContractLastBalanceKey(undefined);
+ ALL_BALANCES_LIST.innerHTML = "";
+ fetchAndDisplayMoreBalances();
+};
+
+function setConnectionStatus(status: string, address: string | undefined = undefined) {
+ const statusText = document.querySelector("#connection-status");
+ const statusLink = document.querySelector("#connection-link");
+
+ statusText.innerHTML = status;
+ statusLink.innerText = "";
+ if (address != undefined) {
+ statusLink.href = `https://browser.testnet.partisiablockchain.com/accounts/${address}`;
+ statusLink.innerText = address;
+ }
+}
+
+const setVisibility = (selector: string, visible: boolean) => {
+ const element = document.querySelector(selector);
+ if (visible) {
+ element.classList.remove("hidden");
+ } else {
+ element.classList.add("hidden");
+ }
+};
+
+export const updateInteractionVisibility = () => {
+ const contractInteraction = document.querySelector("#contract-interaction");
+ if (isConnected() && getContractAddress() !== undefined) {
+ contractInteraction.classList.remove("hidden");
+ } else {
+ contractInteraction.classList.add("hidden");
+ }
+};
+
+export const fetchAndDisplayMoreBalances = () => {
+ const address = getContractAddress();
+ if (address == undefined) {
+ throw new Error("Address not set");
+ }
+ const tokenApi = getTokenApi();
+ if (tokenApi === undefined) {
+ throw new Error("Token API not setup");
+ }
+ if (tokenApi.tokenBalances == undefined) {
+ return; // Contract doesn't support tokenBalances
+ }
+
+ const lastKey = getContractLastBalanceKey();
+ tokenApi.tokenBalances(address, lastKey).then((balancesResult) => {
+ balancesResult.balances.forEach((amount, tokenOwner) => {
+ const balance = document.createElement("li");
+ balance.innerHTML = `${tokenOwner.asString()}: ${amount}`;
+ ALL_BALANCES_LIST.appendChild(balance);
+ });
+ setContractLastBalanceKey(balancesResult.next_cursor);
+
+ const loadMoreBtn = document.querySelector("#balances-load-more-btn");
+ if (balancesResult.next_cursor === undefined) {
+ loadMoreBtn.classList.add("hidden");
+ } else {
+ loadMoreBtn.classList.remove("hidden");
+ }
+ });
+};
diff --git a/src/main/token/contract/MpcTokenContract.ts b/src/main/token/contract/MpcTokenContract.ts
new file mode 100644
index 0000000..1d878a1
--- /dev/null
+++ b/src/main/token/contract/MpcTokenContract.ts
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2022 - 2023 Partisia Blockchain Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+import { BlockchainAddress } from "@partisiablockchain/abi-client";
+import BN from "bn.js";
+import { TransactionApi } from "../../client/TransactionApi";
+import { transferWithLargeMemo } from "../../abi/MpcToken";
+import { TokenContract } from "../../shared/TokenContract";
+import { ShardedClient } from "../../client/ShardedClient";
+import { PutTransactionWasSuccessful } from "../../client/TransactionData";
+
+export const MPC_TOKEN_CONTRACT_ADDRESS: BlockchainAddress = BlockchainAddress.fromString(
+ "01a4082d9d560749ecd0ffa1dcaaaee2c2cb25d881"
+);
+
+const GAS_COST_TRANSFER_WITH_LARGE_MEMO = 16_250;
+
+/*eslint @typescript-eslint/no-unused-vars: ["error", { "argsIgnorePattern": "^unused" }]*/
+export class MpcTokenContract implements TokenContract {
+ private readonly transactionApi: TransactionApi | undefined;
+ private readonly shardedClient: ShardedClient;
+
+ constructor(shardedClient: ShardedClient, transactionApi: TransactionApi | undefined) {
+ this.transactionApi = transactionApi;
+ this.shardedClient = shardedClient;
+ }
+
+ /**
+ * Build and send transfer transaction.
+ * @param to receiver of tokens
+ * @param amount number of tokens to send
+ */
+ public transfer(
+ contractAddress: BlockchainAddress,
+ to: BlockchainAddress,
+ amount: BN,
+ memo: string,
+ ): Promise {
+ if (this.transactionApi === undefined) {
+ throw new Error("No account logged in");
+ }
+ if (contractAddress.asString() !== MPC_TOKEN_CONTRACT_ADDRESS.asString()) {
+ throw new Error("MpcTokenContract is only supported with the actual MPC_TOKEN_CONTRACT");
+ }
+
+ // First build the RPC buffer that is the payload of the transaction.
+ const rpc = transferWithLargeMemo(to, amount, memo);
+ // Then send the payload via the transaction API.
+ // We are sending the transaction to the configured address of the token address, and use the
+ // GasCost utility to estimate how much the transaction costs.
+ return this.transactionApi.sendTransactionAndWait(contractAddress.asString(), rpc, GAS_COST_TRANSFER_WITH_LARGE_MEMO);
+ }
+}
diff --git a/src/main/token/contract/TokenV1Contract.ts b/src/main/token/contract/TokenV1Contract.ts
new file mode 100644
index 0000000..83c9745
--- /dev/null
+++ b/src/main/token/contract/TokenV1Contract.ts
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2022 - 2023 Partisia Blockchain Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+import { BlockchainAddress } from "@partisiablockchain/abi-client";
+import BN from "bn.js";
+import { TransactionApi } from "../../client/TransactionApi";
+import { transfer, TokenState, deserializeTokenState } from "../../abi/TokenV1";
+import {
+ TokenContract,
+ TokenContractBasicState,
+ TokenBalancesResult,
+} from "../../shared/TokenContract";
+import { ShardedClient } from "../../client/ShardedClient";
+import { PutTransactionWasSuccessful } from "../../client/TransactionData";
+
+/**
+ * Structure of the raw data from a WASM contract.
+ */
+interface RawContractData {
+ state: { data: string };
+}
+
+export class TokenV1Contract implements TokenContract {
+ private readonly transactionApi: TransactionApi | undefined;
+ private readonly shardedClient: ShardedClient;
+
+ constructor(shardedClient: ShardedClient, transactionApi: TransactionApi | undefined) {
+ this.transactionApi = transactionApi;
+ this.shardedClient = shardedClient;
+ }
+
+ /**
+ * Build and send transfer transaction.
+ * @param to receiver of tokens
+ * @param amount number of tokens to send
+ */
+ public transfer(
+ contractAddress: BlockchainAddress,
+ to: BlockchainAddress,
+ amount: BN,
+ memo: string,
+ ): Promise {
+ if (this.transactionApi === undefined) {
+ throw new Error("No account logged in");
+ }
+
+ // First build the RPC buffer that is the payload of the transaction.
+ const rpc = transfer(to, amount);
+ // Then send the payload via the transaction API.
+ // We are sending the transaction to the configured address of the token address, and use the
+ // GasCost utility to estimate how much the transaction costs.
+ return this.transactionApi.sendTransactionAndWait(contractAddress.asString(), rpc, 10_000);
+ }
+
+ private getState(contractAddress: BlockchainAddress): Promise {
+ return this.shardedClient
+ .getContractData(contractAddress.asString())
+ .then((contract) => {
+ if (contract == null) {
+ throw new Error("Could not find data for contract");
+ }
+
+ // Reads the state of the contract
+ const stateBuffer = Buffer.from(contract.serializedContract.state.data, "base64");
+
+ return deserializeTokenState({ state: stateBuffer });
+ });
+ }
+
+ public basicState(contractAddress: BlockchainAddress): Promise {
+ return this.getState(contractAddress);
+ }
+
+ /*eslint @typescript-eslint/no-unused-vars: ["error", { "argsIgnorePattern": "^unused" }]*/
+ public tokenBalances(
+ contractAddress: BlockchainAddress,
+ unusedCursor: string | undefined
+ ): Promise {
+ return this.getState(contractAddress).then((state) => {
+ return { balances: state.balances, next_cursor: undefined };
+ });
+ }
+}
diff --git a/src/main/token/contract/TokenV2Contract.ts b/src/main/token/contract/TokenV2Contract.ts
new file mode 100644
index 0000000..4ee12b7
--- /dev/null
+++ b/src/main/token/contract/TokenV2Contract.ts
@@ -0,0 +1,148 @@
+/*
+ * Copyright (C) 2022 - 2023 Partisia Blockchain Foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see .
+ *
+ */
+
+import BN from "bn.js";
+import { BlockchainAddress } from "@partisiablockchain/abi-client";
+import { TransactionApi } from "../../client/TransactionApi";
+import { AvlClient } from "../../client/AvlClient";
+import { LittleEndianByteInput } from "@secata-public/bitmanipulation-ts";
+import { Buffer } from "buffer";
+import { transfer, deserializeTokenState } from "../../abi/TokenV2";
+import {
+ TokenContract,
+ TokenContractBasicState,
+ TokenBalancesResult,
+} from "../../shared/TokenContract";
+import { ShardedClient } from "../../client/ShardedClient";
+import { PutTransactionWasSuccessful } from "../../client/TransactionData";
+import { NODE_BASE_URL, NETWORK_SHARDS } from "../../constant";
+
+const AVL_CLIENT = new AvlClient(NODE_BASE_URL, NETWORK_SHARDS);
+
+/**
+ * Structure of the raw data from a WASM contract.
+ */
+interface RawContractData {
+ state: { data: string };
+}
+
+/**
+ * API for the token contract.
+ * This minimal implementation only allows for transferring tokens to a single address.
+ *
+ * The implementation uses the TransactionApi to send transactions, and ABI for the contract to be
+ * able to build the RPC for the transfer transaction.
+ */
+export class TokenV2Contract implements TokenContract {
+ private readonly transactionApi: TransactionApi | undefined;
+ private readonly shardedClient: ShardedClient;
+
+ constructor(shardedClient: ShardedClient, transactionApi: TransactionApi | undefined) {
+ this.transactionApi = transactionApi;
+ this.shardedClient = shardedClient;
+ }
+
+ /**
+ * Build and send transfer transaction.
+ * @param to receiver of tokens
+ * @param amount number of tokens to send
+ */
+ public transfer(
+ contractAddress: BlockchainAddress,
+ to: BlockchainAddress,
+ amount: BN,
+ memo: string,
+ ): Promise {
+ if (this.transactionApi === undefined) {
+ throw new Error("No account logged in");
+ }
+
+ // First build the RPC buffer that is the payload of the transaction.
+ const rpc = transfer(to, amount);
+ // Then send the payload via the transaction API.
+ // We are sending the transaction to the configured address of the token address, and use the
+ // GasCost utility to estimate how much the transaction costs.
+ return this.transactionApi.sendTransactionAndWait(contractAddress.asString(), rpc, 10_000);
+ }
+
+ public basicState(contractAddress: BlockchainAddress): Promise {
+ return this.shardedClient
+ .getContractData(contractAddress.asString())
+ .then((contract) => {
+ if (contract == null) {
+ throw new Error("Could not find data for contract");
+ }
+
+ // Reads the state of the contract
+ const stateBuffer = Buffer.from(contract.serializedContract.state.data, "base64");
+
+ return deserializeTokenState({ state: stateBuffer });
+ });
+ }
+
+ public async tokenBalances(
+ contractAddress: BlockchainAddress,
+ keyAddress: string | undefined
+ ): Promise {
+ const keyBytes = keyAddress === undefined ? undefined : Buffer.from(keyAddress, "hex");
+ const values = await AVL_CLIENT.getContractStateAvlNextN(
+ contractAddress.asString(),
+ 0,
+ keyBytes,
+ 10
+ );
+ if (values === undefined) {
+ throw new Error("Could not fetch balances");
+ }
+
+ const balances: Map = new Map();
+ let lastKey: string | undefined = undefined;
+
+ values.forEach((val) => {
+ const tuple = Object.entries(val)[0];
+ const blockchainAddressRaw = Buffer.from(tuple[0], "base64").toString("hex");
+ const blockchainAddress = BlockchainAddress.fromString(blockchainAddressRaw);
+ const value = new LittleEndianByteInput(
+ Buffer.from(tuple[1], "base64")
+ ).readUnsignedBigInteger(16);
+ balances.set(blockchainAddress, value);
+ lastKey = blockchainAddressRaw;
+ });
+
+ return {
+ balances,
+ next_cursor: lastKey,
+ };
+ }
+
+ public async tokenBalance(
+ contractAddress: BlockchainAddress,
+ owner: BlockchainAddress
+ ): Promise {
+ const keyBytes = owner.asBuffer();
+ const value = await AVL_CLIENT.getContractStateAvlValue(
+ contractAddress.asString(),
+ 0,
+ keyBytes
+ );
+ if (value === undefined) {
+ throw new Error("No balance for user: " + owner.asString());
+ }
+ return new LittleEndianByteInput(value).readUnsignedBigInteger(16);
+ }
+}
diff --git a/src/main/token/index.html b/src/main/token/index.html
new file mode 100644
index 0000000..c0fb306
--- /dev/null
+++ b/src/main/token/index.html
@@ -0,0 +1,234 @@
+
+
+
+ MPC20-v2
+
+
+
+
+
+
+
+
+