ledger: Boyscout compile errors for multi-backend adaptation

src/api/responses/balanceproof.spec.ts

@@ -8,7 +8,7 @@ import { Address } from "#erdstall/ledger";
 import {
 	Erdstall,
 	Erdstall__factory,
-} from "#erdstall/ledger/backend/contracts";
+} from "#erdstall/ledger/backend/ethereum/contracts";
 
 import * as test from "#erdstall/test";
 import { Environment, setupEnv } from "#erdstall/test/ledger";

src/api/transactions/trade.ts

@@ -11,7 +11,8 @@ import {
 } from "#erdstall/export/typedjson";
 import { ABIEncoder, ABIPacked } from "#erdstall/api/util";
 import { Signature } from "#erdstall/api";
-import { Signer, utils } from "ethers";
+import { utils } from "ethers";
+import { Signer } from "#erdstall/ledger/backend";
 
 @jsonObject
 export class TradeFees {

src/api/transactions/transaction.ts

@@ -12,8 +12,9 @@ import {
 	Serializable,
 	jsonBigIntMember,
 } from "#erdstall/export/typedjson";
-import { utils, Signer } from "ethers";
+import { utils } from "ethers";
 import { ETHZERO } from "#erdstall/ledger/assets";
+import { Signer } from "#erdstall/ledger/backend";
 
 const transactionImpls = new Map<string, Serializable<Transaction>>();
 const transactionTypeName = "Transaction";

src/client.spec.ts

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: Apache-2.0
+"use strict";
+
+import { ErdstallSession, ErdstallClient, Client, Session } from "#erdstall";
+import { expect } from "chai";
+
+describe("ErdstallClient", () => {
+	const enclaveConn = new URL("http://localhost:8080");
+	const cl: ErdstallClient<["ethereum", "substrate"]> = new Client<
+		["ethereum", "substrate"]
+	>(
+		enclaveConn,
+		{
+			backend: "ethereum",
+			encConn: enclaveConn,
+			provider: {} as any,
+		},
+		{
+			backend: "substrate",
+			arg: 420,
+		},
+	);
+
+	cl.on("Withdrawn", (e) => {});
+});
+
+describe("ErdstallSession", () => {
+	const singleSession: ErdstallSession<["ethereum"]> = new Session<
+		["ethereum"]
+	>({
+		backend: "ethereum",
+		encConn: new URL("http://localhost:8545"),
+		provider: {} as any,
+		signer: {} as any,
+		address: {} as any,
+	});
+
+	const _addr = singleSession.erdstall();
+
+	const multiSession = new Session<["ethereum", "substrate"]>(
+		{
+			backend: "ethereum",
+			encConn: new URL("http://localhost:8545"),
+			provider: {} as any,
+			signer: {} as any,
+			address: {} as any,
+		},
+		{
+			backend: "substrate",
+			arg: 420,
+		},
+	);
+
+	const _multiAddr = multiSession.erdstall();
+
+	singleSession.on("Withdrawn", (e) => {});
+});

src/e2e/sdk_actions.ts

@@ -8,7 +8,7 @@ import { Session, Client } from "#erdstall";
 import {
 	PerunArt__factory,
 	PerunToken__factory,
-} from "#erdstall/ledger/backend/contracts";
+} from "#erdstall/ledger/backend/ethereum/contracts";
 import {
 	Transfer,
 	Mint,
@@ -19,9 +19,17 @@ import {
 
 import { ethers, utils } from "ethers";
 import { PERUN_ADDR, PART_ADDR } from "./parameters";
+import {
+	mkDefaultEthereumClientConstructor,
+	mkDefaultEthereumSessionConstructor,
+} from "#erdstall/ledger/backend/ethereum";
+import { SubstrateClient } from "#erdstall/ledger/backend/substrate";
 
 export type SDKActions = typeof sdkActions;
 
+// The list of backends used for this test trace.
+export type TestBackends = ["ethereum", "substrate"];
+
 // sdkActions shows how to use the SDK for each step in a hypothetical
 // scenario. Each key stands for one step a user might do when acting within
 // the Erdstall system and shows how to assemble required parameter structures
@@ -38,7 +46,7 @@ export const sdkActions = {
 		nodeUrl: string,
 		signer: ethers.Signer,
 		operatorUrl: URL,
-	): Promise<Session> => {
+	): Promise<Session<TestBackends>> => {
 		// First we need a provider which allows the SDK to communicate with the
 		// underlying ledger. In the case of creating an `ErdstallClient` simply
 		// creating the provider or querying it from the environment (e.g. MetaMask
@@ -47,7 +55,16 @@ export const sdkActions = {
 
 		// Using the provider and the URL for the operator allows creating an
 		// `ErdstallClient`.
-		const client = new Client(provider, operatorUrl);
+		// const client = new Client(provider, operatorUrl);
+		const client = new Client<TestBackends>(
+			operatorUrl,
+			mkDefaultEthereumClientConstructor(provider),
+			{
+				backend: "substrate",
+				arg: 42,
+				initializer: (_c) => new SubstrateClient(42),
+			},
+		);
 		// One could use this readonly client to listen for various events within
 		// Erdstall by registering callbacks before issuing the
 		// `client.initialize()` call.
@@ -61,7 +78,18 @@ export const sdkActions = {
 		// calling the `provider.getSigner()` method (if the user has granted
 		// access to your app using his account).
 		const userAddr = Address.fromString(await signer.getAddress());
-		const session = new Session(userAddr, signer, operatorUrl);
+		// const session = new Session(userAddr, signer, operatorUrl);
+		const session = new Session<TestBackends>(
+			userAddr,
+			operatorUrl,
+			signer,
+			mkDefaultEthereumSessionConstructor(signer),
+			{
+				backend: "substrate",
+				arg: 42,
+				initializer: (_c) => new SubstrateClient(42),
+			},
+		);
 
 		// We could now proactively set eventhandlers in place:
 		//
@@ -93,6 +121,11 @@ export const sdkActions = {
 		});
 
 		// (Onchain) Erdstall handlers:
+		//
+		// The origin of each on-chain event is tagged in each event under the
+		// event.source field.
+		// If your Session is defined as `Session<["ethereum" | "substrate"]>`, the
+		// `event.source` field has the type `"ethereum" | "substrate"`.
 		session.on("TokenTypeRegistered", (_tokenTypeRegisteredEvent) => {
 			// A new token type with its token holder contract was registered on the
 			// Erdstall smart contract.
@@ -124,19 +157,23 @@ export const sdkActions = {
 		return session;
 	},
 
-	initialize: async (session: Session) => {
+	initialize: async (session: Session<TestBackends>) => {
 		// Initialize the session. This connects us to the operator and grants us
 		// the ability to extend our subscriptions in the next step.
 		await session.initialize();
 	},
 
 	// Subscribing ensures that the `ErdstallClient` or `ErdstallSession`
 	// receives events for phaseshifts, balanceproofs and tx-receipts.
-	subscribe: async (session: Session) => {
+	subscribe: async (session: Session<TestBackends>) => {
 		return session.subscribeSelf();
 	},
 
-	deposit: async (session: Session, ethAmount: bigint, prnAmount: bigint) => {
+	deposit: async (
+		session: Session<TestBackends>,
+		ethAmount: bigint,
+		prnAmount: bigint,
+	) => {
 		// Erdstall balances are abstract `Assets`. These assets contain individual
 		// assets of the `Asset` type. Currently the SDK supports two types of assets:
 		//
@@ -157,6 +194,7 @@ export const sdkActions = {
 		);
 
 		const { stages, numStages: _numStages } = await session.deposit(
+			"ethereum",
 			depositBal,
 		);
 		// Depositing is a multi-stage process. ERC20 tokens like PRN have to be
@@ -184,8 +222,8 @@ export const sdkActions = {
 	},
 
 	offchainTransfer: async (
-		alice: Session,
-		bob: Session,
+		alice: Session<TestBackends>,
+		bob: Session<TestBackends>,
 		prnAmount: bigint,
 	): Promise<void> => {
 		const amount = new Assets({
@@ -253,7 +291,7 @@ export const sdkActions = {
 		});
 	},
 
-	leave: async (session: Session) => {
+	leave: async (session: Session<TestBackends>) => {
 		// `leave` is a convenience function for first `exit`ing the Erdstall
 		// system and afterwards `withdrawing` all available funds for the user.
 		// So alternatively, if more control is required:
@@ -265,13 +303,13 @@ export const sdkActions = {
 		// --   callback!
 		//
 		// const { stages } = await session.withdraw(exitProof);
-		const { stages } = await session.leave();
+		const { stages } = await session.leave("ethereum");
 		for await (const [_name, stage] of stages) {
 			await stage.wait();
 		}
 	},
 
-	mint: async (session: Session, nftID: bigint) => {
+	mint: async (session: Session<TestBackends>, nftID: bigint) => {
 		// Offchain minting is simply a matter of passing an ERC721 contract
 		// address and an ID (unique!). Currently it is possible to mint for any
 		// contract offchain which is registered in Erdstall and counts as an
@@ -280,8 +318,8 @@ export const sdkActions = {
 	},
 
 	trade: async (
-		charlie: Session,
-		dagobert: Session,
+		charlie: Session<TestBackends>,
+		dagobert: Session<TestBackends>,
 		charlieNft: bigint,
 		wantedPrnAmount: bigint,
 	) => {
@@ -324,7 +362,7 @@ export const sdkActions = {
 		return (await dagobert.acceptTrade(tradeOffer)).receipt;
 	},
 
-	burn: async (dagobert: Session, formerCharlieNft: bigint) => {
+	burn: async (dagobert: Session<TestBackends>, formerCharlieNft: bigint) => {
 		// Burning a NFT requires being the owner of it. Since Charlie transferred
 		// his NFT in the step before, Dagobert is now able to do as he pleases.
 		// Maybe he was not a fan of monkeys and now wants some lit whales.
@@ -337,10 +375,10 @@ export const sdkActions = {
 	},
 
 	leavingAndSeeFundsOnchain: async function (
-		session: Session,
+		session: Session<TestBackends>,
 		provider: ethers.providers.Provider,
 	) {
-		const { stages } = await session.leave();
+		const { stages } = await session.leave("ethereum");
 		for await (const [, stage] of stages) {
 			await stage.wait();
 		}
@@ -354,16 +392,18 @@ export const sdkActions = {
 		// Erdstall related contracts, which frees you of the burden to come up
 		// with bindings on your own.
 
-		// The SDK provides a convenience field for on chain calls which will grow
-		// over time. E.g.
-		[PERUN_ADDR, PART_ADDR]
-			.map((addr) => addr.toString())
-			.map((addr) => {
-				session.onChainQuerier.queryTokensOwnedByAddress(
-					addr,
-					session.address.toString(),
-				);
-			});
+		// TODO: REINTRODUCE
+		// // The SDK provides a convenience field for on chain calls which will grow
+		// // over time. E.g.
+		// [PERUN_ADDR, PART_ADDR]
+		// 	.map((addr) => addr.toString())
+		// 	.map((addr) => {
+		// 		session.onChainQuerier.queryTokensOwnedByAddress(
+		// 			"ethereum",
+		// 			addr,
+		// 			session.address.toString(),
+		// 		);
+		// 	});
 
 		// The tokenProvider can be used to query information about tokens related
 		// to Erdstall. The necessary `erdstallAddr` for these calls can be

src/e2e/test_harness.ts

@@ -11,7 +11,7 @@ import * as test from "#erdstall/test";
 import {
 	PerunArt__factory,
 	PerunToken__factory,
-} from "#erdstall/ledger/backend/contracts";
+} from "#erdstall/ledger/backend/ethereum/contracts";
 import { withTimeout } from "#erdstall/utils";
 
 import { ethers, utils } from "ethers";
@@ -91,9 +91,9 @@ export function endToEndTestHarness(sdkActions: SDKActions) {
 		});
 		after(async () => erdstallProcessTerminate);
 
-		const sessions: Session[] = [];
+		const sessions: Session<["ethereum", "substrate"]>[] = [];
 		const forSessionsDo = async <R>(
-			action: (client: Session) => Promise<R>,
+			action: (client: Session<["ethereum", "substrate"]>) => Promise<R>,
 			range: { from?: number; upto?: number } = {},
 		) => {
 			return Promise.all(

src/ledger/address.ts

@@ -6,6 +6,14 @@ import { jsonObject } from "#erdstall/export/typedjson";
 import { equalArray } from "#erdstall/utils/arrays";
 import { ABIValue, customJSON } from "#erdstall/api/util";
 
+// // Map key
+// TODO: Substrate uses Pallets, we do not have an address for each pallet?
+// type AddrKey struct {
+// 	Type string `json:"type"` // addr.Type()
+// 	Key  string `json:"key"`  // addr.Key()
+// }
+// TODO: Switch over type, parse key as expected by backends.
+
 /**
  * This class implements an address representation and is used within the SDK
  * wherever an address is required.

src/ledger/assets/assets.ts

@@ -8,7 +8,7 @@ import { ABIValue, customJSON } from "#erdstall/api/util";
 import { ErdstallToken } from "#erdstall/api/responses";
 import { Address, addressKey } from "#erdstall/ledger";
 import { TokenProvider } from "#erdstall/ledger/backend";
-import { Erdstall } from "#erdstall/ledger/backend/contracts";
+import { Erdstall } from "#erdstall/ledger/backend/ethereum/contracts";
 import { decodePackedAmount } from "./amount";
 import { Tokens, decodePackedIds } from "./tokens";
 import { TokenType } from "./asset";
@@ -160,7 +160,7 @@ function isProperSubset(
 
 export async function decodePackedAssets(
 	erdstall: Erdstall,
-	tokenProvider: Pick<TokenProvider, "tokenTypeOf">,
+	tokenProvider: Pick<TokenProvider<"ethereum">, "tokenTypeOf">,
 	values: [string, string][],
 ): Promise<Assets> {
 	const assets = new Assets();

src/ledger/backend/index.ts

@@ -1,10 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 "use strict";
 
-export * from "./readconn";
-export * from "./writeconn";
-export * from "./contracts";
-export * from "./contracts_deposit";
-export * from "./tokencache";
-export * from "./tokenmanager";
+export * from "./tokenprovider";
+export * from "./backends";
 export * from "./metadata";
+export * from "./reader";
+export * from "./writer";
+export * from "./signer";

src/ledger/backend/metadata.spec.ts

@@ -6,7 +6,7 @@ import { Client, ErdstallClient } from "#erdstall";
 import { ClientConfig } from "#erdstall/api/responses";
 import { Enclave } from "#erdstall/enclave";
 import { Address } from "#erdstall/ledger";
-import { PerunArt__factory } from "#erdstall/ledger/backend/contracts";
+import { PerunArt__factory } from "#erdstall/ledger/backend/ethereum/contracts";
 import * as test from "#erdstall/test";
 import { Environment, setupEnv, PERUNART_URI } from "#erdstall/test/ledger";
 import nock from "nock";