Merge pull request #54 from input-output-hk/PLT-8261

Open Roles & Clean buildCreateContractTx Request

Author: nhenin

changelog.d/20231208_095010_nicolas.henin.md

@@ -0,0 +1,8 @@
+### @marlowe.io/runtime-rest-client
+
+- `createContract` Endpoint has been renamed to `buildCreateContractTx` ([PR#54](https://github.com/input-output-hk/marlowe-ts-sdk/pull/54))
+- `buildCreateContractTx` is 1-1 parity with REST API request-wise ([PR#54](https://github.com/input-output-hk/marlowe-ts-sdk/pull/54))
+
+### @marlowe.io/runtime-lifecycle
+
+- `createContract` is complete request-wise for creating non-merkleized contracts ([PR#54](https://github.com/input-output-hk/marlowe-ts-sdk/pull/54))

examples/rest-client-flow/index.html

@@ -76,14 +76,14 @@ <h2>Request</h2>
       >
       <br />
       <input
-        id="createContract"
+        id="buildCreateContractTx"
         type="button"
-        value="Create Contract"
+        value="Build Create Contract Tx"
         class="endpoint"
       />
       POSTs a new contract
       <a
-        href="https://input-output-hk.github.io/marlowe-ts-sdk/interfaces/_marlowe_io_runtime_rest_client.index.RestClient.html#createContract"
+        href="https://input-output-hk.github.io/marlowe-ts-sdk/interfaces/_marlowe_io_runtime_rest_client.index.RestClient.html#buildCreateContractTx"
         >/contracts</a
       >
       <br />

examples/run-lite/index.html

@@ -108,7 +108,9 @@ <h2>Console</h2>
           walletName,
         });
 
-        const contractId = await runtime.contracts.createContract({ contract });
+        const contractId = await runtime.contracts.createContract({
+          contract: contract,
+        });
         log("Contract created with id: " + contractId);
         setContractIdIndicator(contractId);
       }

examples/survey-workshop/participant/index.js

@@ -124,7 +124,7 @@ async function createContract(
 
   const lifecycle = await H.getLifecycle();
   const [contractId] = await lifecycle.contracts.createContract({
-    contract,
+    contract: contract,
     tags: { MarloweSurvey: "test 1" },
   });
 

jsdelivr-npm-importmap.js

@@ -5,6 +5,26 @@ import JSONbigint from "json-bigint";
 
 export type DecodingError = string[];
 
+/**
+ * ```ts
+ * try {
+ *  myRuntimeEndpoint(myRequest);
+ * } catch (error){
+ *  if(error instanceOf UnexpectedRuntimeResponse) {
+ *    console.error("The Runtime answered an unexpected message, please contact our desk support",error)
+ *  } else  {
+ *    console.error("another type of error",error)
+ *  }
+ * }
+ * ```
+ */
+export class UnexpectedRuntimeResponse extends Error {
+  public type = "UnexpectedRuntimeResponse" as const;
+  constructor(message: string) {
+    super(message);
+  }
+}
+
 export const MarloweJSON = JSONbigint({
   alwaysParseAsBig: true,
   useNativeBigInt: true,

packages/adapter/src/codec.ts

@@ -1,6 +1,5 @@
 import * as t from "io-ts/lib/index.js";
 
-// TODO: This should be DELETED as there is a newtype for this in runtime-core,
-//       but a preliminary change broke the build with weird type errors
+// TODO: This should be replaced by a Branded Version available in the Runtime Rest Client Package,
 export type AddressBech32 = string;
 export const AddressBech32 = t.string;

packages/language/core/v1/src/address.ts

@@ -13,6 +13,8 @@
   @packageDocumentation
  */
 
+export { PolicyIdGuard as PolicyId } from "./policyId.js";
+
 export {
   ActionGuard as Action,
   DepositGuard as Deposit,
@@ -58,6 +60,7 @@ export {
 
 export {
   RoleGuard as Role,
+  RoleNameGuard as RoleName,
   PartyGuard as Party,
   AddressGuard as Address,
 } from "./participants.js";

packages/language/core/v1/src/guards.ts

@@ -55,7 +55,7 @@ export {
   MerkleizedInput,
 } from "./inputs.js";
 
-export { role, Party, Address, Role } from "./participants.js";
+export { role, Party, Address, Role, RoleName } from "./participants.js";
 
 export { Payee, PayeeAccount, PayeeParty, AccountId } from "./payee.js";
 

packages/language/core/v1/src/index.ts

@@ -29,8 +29,8 @@ export interface Address {
  */
 export const AddressGuard: t.Type<Address> = t.type({ address: AddressBech32 });
 
-type RoleName = string;
-const RoleNameGuard: t.Type<RoleName> = t.string;
+export type RoleName = string;
+export const RoleNameGuard: t.Type<RoleName> = t.string;
 
 /**
  * Search [[lower-name-builders]]

packages/language/core/v1/src/participants.ts

@@ -8,4 +8,4 @@ export type PolicyId = string;
 /**
  * @category Token
  */
-export const PolicyId = t.string;
+export const PolicyIdGuard = t.string;

packages/language/core/v1/src/policyId.ts

@@ -1,6 +1,6 @@
 import { Sort, strCmp } from "@marlowe.io/adapter/assoc-map";
 import * as t from "io-ts/lib/index.js";
-import { PolicyId } from "./policyId.js";
+import { PolicyId, PolicyIdGuard } from "./policyId.js";
 /**
  * @see {@link @marlowe.io/language-core-v1!index.Token}.
  * @category Token
@@ -26,7 +26,7 @@ export interface Token {
  * @category Token
  */
 export const TokenGuard: t.Type<Token> = t.type({
-  currency_symbol: PolicyId,
+  currency_symbol: PolicyIdGuard,
   token_name: TokenNameGuard,
 });
 

packages/language/core/v1/src/token.ts

@@ -36,12 +36,21 @@
       "require": "./dist/bundled/cjs/transaction.cjs",
       "types": "./dist/esm/contract/transaction/index.d.ts"
     },
+    "./payout": {
+      "import": "./dist/esm/payout/index.js",
+      "require": "./dist/bundled/cjs/payout.cjs",
+      "types": "./dist/esm/payout/index.d.ts"
+    },
     "./withdrawal": {
       "import": "./dist/esm/withdrawal/index.js",
       "require": "./dist/bundled/cjs/withdrawal.cjs",
       "types": "./dist/esm/withdrawal/index.d.ts"
     },
-    "./contract/*": "./dist/esm/contract/*.js"
+    "./contract": {
+      "import": "./dist/esm/contract/index.js",
+      "require": "./dist/bundled/cjs/contract.cjs",
+      "types": "./dist/esm/contract/index.d.ts"
+    }
   },
   "dependencies": {
     "@marlowe.io/adapter": "0.3.0-beta-rc1",

packages/runtime/client/rest/package.json

@@ -4,10 +4,8 @@ import { Contract, MarloweState } from "@marlowe.io/language-core-v1";
 import * as G from "@marlowe.io/language-core-v1/guards";
 import { MarloweVersion } from "@marlowe.io/language-core-v1/version";
 import { ContractIdGuard } from "@marlowe.io/runtime-core";
-
 import { TxStatus } from "./transaction/status.js";
 
-import { RoleName } from "./role.js";
 import {
   TxOutRef,
   BlockHeaderGuard,
@@ -34,21 +32,23 @@ export const Payout = t.type({
    */
   payoutId: TxOutRef,
   /**
-   * The {@link RoleName} of the participant that has the unclaimed Payout.
+   * The {@link @marlowe.io/language-core-v1!index.RoleName | Role Name} of the participant that has the unclaimed Payout.
    */
-  role: RoleName,
+  role: G.RoleName,
 });
 
 /**
- * Represents the response of the {@link index.RestClient#getContractById | Get contract by id } endpoint
+ * Represents the response of the {@link index.RestClient#getContractById | Get Contract By Id } endpoint
  * @see The {@link ContractDetails:var | dynamic validator} for this type.
  * @interface
+ * @category Endpoint : Get Contract By Id
  */
 export interface ContractDetails extends t.TypeOf<typeof ContractDetails> {}
 
 /**
  * This is a {@link !io-ts-usage | Dynamic type validator} for the {@link ContractDetails:type}.
  * @category Validator
+ * @category Endpoint : Get Contract By Id
  */
 // DISCUSSION : Tags are missing in the ts-sdk and available in the REST API
 export const ContractDetails = t.type({

packages/runtime/client/rest/src/contract/details.ts

@@ -0,0 +1,27 @@
+/**
+  * This module offers {@link !io-ts-usage | dynamic type guards} for JSON schemas as specified in Runtime Rest API  
+  ```
+  import * as G from "@marlowe/language-core-v1/guards"
+  const jsonObject = JSON.parse(fileContents)
+
+  if (G.Contract.is(jsonObject)) {
+    // The jsonObject respects the JSON schema for Contract
+  } else {
+    // The jsonObject does not respect the JSON schema for Contract
+  }
+  ```
+  @packageDocumentation
+ */
+
+export {
+  ClosedRoleGuard as ClosedRole,
+  OpenRoleGuard as OpenRole,
+  OpennessGuard as Openess,
+  UsePolicyWithClosedRoleTokensGuard as UsePolicyWithClosedRoleTokens,
+  UsePolicyWithOpenRoleTokensGuard as UsePolicyWithOpenRoleTokens,
+  TokenMetadataFileGuard as TokenMetadataFile,
+  TokenMetadataGuard as TokenMetadata,
+  RoleTokenConfigurationGuard as RoleTokenConfiguration,
+  RolesConfigurationGuard as RolesConfiguration,
+  AddressBech32Guard as AddressBech32,
+} from "./rolesConfigurations.js";

packages/runtime/client/rest/src/contract/endpoints/collection.ts

@@ -22,7 +22,7 @@ import { TxStatus } from "./transaction/status.js";
  * Use {@link index.RestClient#getContractById} to get full contract details
  *
  * @see The {@link https://github.com/input-output-hk/marlowe-cardano/blob/b39fe3c3ed67d41cdea6d45700093e7ffa4fad62/marlowe-runtime-web/src/Language/Marlowe/Runtime/Web/Types.hs#L502 | The backend definition } of this type
- * @category GetContractsResponse
+ * @category Endpoint : Get Contracts
  */
 export interface ContractHeader {
   /**
@@ -58,7 +58,7 @@ export interface ContractHeader {
 /**
  * This is a {@link !io-ts-usage | Dynamic type validator} for a {@link ContractHeaderGuard:type}.
  * @category Validator
- * @category GetContractsResponse
+ * @category Endpoint : Get Contracts
  * @hidden
  */
 export const ContractHeaderGuard = t.type({

packages/runtime/client/rest/src/contract/guards.ts

@@ -2,22 +2,53 @@
  * ```ts
  * import * as C from "@marlowe.io/runtime-rest-client/contract";
  *```
+ * This package contains all the implementation and details related to 
+ * endpoints under the URI `/contracts/...` : 
+ *  - {@link index.RestClient#buildCreateContractTx | Build Create Contract Tx } 
+ *  - {@link index.RestClient#getContracts | Get contracts }
+ *  - {@link index.RestClient#getContractById | Get Contract By Id }
+
  * @packageDocumentation
  */
 
 export { ContractHeader } from "./header.js";
 export { ContractDetails } from "./details.js";
-export { RolesConfig } from "./role.js";
+export {
+  useMintedRoles,
+  mintRole,
+  AddressBech32Brand,
+  AddressBech32,
+  openRole,
+  ClosedRole,
+  OpenRole,
+  Openness,
+  UsePolicyWithClosedRoleTokens,
+  UsePolicyWithOpenRoleTokens,
+  MintRolesTokens,
+  TokenMetadataFile,
+  TokenMetadata,
+  Recipient,
+  TokenQuantity,
+  RoleTokenConfiguration,
+  RolesConfiguration,
+} from "./rolesConfigurations.js";
 export {
   GetContractsResponse,
   GetContractsRequest,
   ContractsRange,
-  CreateContractRequest,
-  CreateContractResponse,
+  ContractOrSourceId,
+  BuildCreateContractTxRequest,
+  BuildCreateContractTxRequestWithContract,
+  BuildCreateContractTxRequestWithSourceId,
+  BuildCreateContractTxRequestOptions,
+  BuildCreateContractTxResponse,
 } from "./endpoints/collection.js";
 export { TxHeader } from "./transaction/header.js";
 export {
   TransactionsRange,
   GetTransactionsForContractResponse,
 } from "./transaction/endpoints/collection.js";
+
 export { TransactionDetails } from "./transaction/details.js";
+
+export { TransactionTextEnvelope } from "./transaction/endpoints/collection.js";

packages/runtime/client/rest/src/contract/header.ts

@@ -0,0 +1,239 @@
+import * as t from "io-ts/lib/index.js";
+
+import { PolicyId, RoleName } from "@marlowe.io/language-core-v1";
+
+import * as G from "@marlowe.io/language-core-v1/guards";
+
+/**
+ *  @category Roles Configuration
+ */
+export interface AddressBech32Brand {
+  readonly AddressBech32: unique symbol;
+}
+
+export const AddressBech32Guard = t.brand(
+  t.string,
+  (s): s is t.Branded<string, AddressBech32Brand> => true,
+  "AddressBech32"
+);
+
+/**
+ *  Cardano Address in a Bech32 format
+ *  @category Roles Configuration
+ */
+export type AddressBech32 = t.TypeOf<typeof AddressBech32Guard>;
+
+/**
+ *  Definition a of Closed Role Tlken
+ *  @remarks
+ *    - It is only defined by the Address where the token is distributed
+ *  @category Roles Configuration
+ */
+export type ClosedRole = AddressBech32;
+export const ClosedRoleGuard: t.Type<ClosedRole, string> = AddressBech32Guard;
+
+/**
+ *  Definition of an Open Role Token
+ *  @category Roles Configuration
+ */
+export type OpenRole = "OpenRole";
+export const OpenRoleGuard = t.literal("OpenRole");
+
+/**
+ *  Construction of an Open Role Token
+ *  @category Roles Configuration
+ */
+export const openRole = "OpenRole";
+
+/**
+ *  Definition of the Openness of a Role Token
+ *  @category Roles Configuration
+ */
+export type Openness = ClosedRole | OpenRole;
+export const OpennessGuard: t.Type<Openness, string> = t.union([
+  ClosedRoleGuard,
+  OpenRoleGuard,
+]);
+
+/**
+ *  @category Roles Configuration
+ */
+export type UsePolicyWithClosedRoleTokens = PolicyId;
+
+export const UsePolicyWithClosedRoleTokensGuard: t.Type<UsePolicyWithClosedRoleTokens> =
+  G.PolicyId;
+
+/**
+ *  @category Roles Configuration
+ */
+export interface UsePolicyWithOpenRoleTokens {
+  script: OpenRole;
+  policyId: PolicyId;
+  openRoleNames: RoleName[];
+}
+export const UsePolicyWithOpenRoleTokensGuard: t.Type<UsePolicyWithOpenRoleTokens> =
+  t.type({
+    script: OpenRoleGuard,
+    policyId: G.PolicyId,
+    openRoleNames: t.array(G.RoleName),
+  });
+
+/**
+ *  @category Roles Configuration
+ */
+export interface TokenMetadataFile {
+  name: string;
+  src: string;
+  mediaType: string;
+}
+
+export const TokenMetadataFileGuard: t.Type<TokenMetadataFile> = t.type({
+  name: t.string,
+  src: t.string,
+  mediaType: t.string,
+});
+
+/**
+ *  Token Metadata (CIP-25)
+ *  @category Roles Configuration
+ *  @see
+ *  - https://github.com/cardano-foundation/CIPs/blob/master/CIP-0025/README.md
+ */
+export interface TokenMetadata {
+  name?: string;
+  image?: string;
+  mediaType: string;
+  description: string;
+  files: TokenMetadataFile[];
+}
+
+export const TokenMetadataGuard: t.Type<TokenMetadata> = t.intersection([
+  t.type({
+    mediaType: t.string,
+    description: t.string,
+    files: t.array(TokenMetadataFileGuard),
+  }),
+  t.partial({ name: t.string }),
+  t.partial({ image: t.string }),
+]);
+
+/**
+ *  @category Roles Configuration
+ */
+export interface ClosedNFTWithMetadata {
+  address: AddressBech32;
+  metadata?: TokenMetadata;
+}
+
+/**
+ *  @category Roles Configuration
+ */
+export type Recipient = Openness;
+
+export const RecipientGuard: t.Type<Recipient, string> = t.union([
+  OpenRoleGuard,
+  ClosedRoleGuard,
+]);
+
+/**
+ *  @category Roles Configuration
+ */
+export type TokenQuantity = bigint;
+
+export const TokenQuantityGuard: t.Type<TokenQuantity> = t.bigint;
+
+/**
+ *  @category Roles Configuration
+ */
+export interface RoleTokenConfiguration {
+  recipients:
+    | { [x: string & t.Brand<AddressBech32Brand>]: TokenQuantity }
+    | { OpenRole: TokenQuantity };
+  metadata?: TokenMetadata;
+}
+
+export const RoleTokenConfigurationGuard: t.Type<RoleTokenConfiguration> =
+  t.intersection([
+    t.type({
+      recipients: t.union([
+        t.record(OpenRoleGuard, TokenQuantityGuard),
+        t.record(ClosedRoleGuard, TokenQuantityGuard),
+      ]),
+    }),
+    t.partial({ metadata: TokenMetadataGuard }),
+  ]);
+
+/**
+ *  @category Roles Configuration
+ */
+export type MintRolesTokens = { [x: RoleName]: RoleTokenConfiguration };
+
+export const MintRolesTokensGuard: t.Type<MintRolesTokens> = t.record(
+  G.RoleName,
+  RoleTokenConfigurationGuard
+);
+
+/**
+ *  Defines how to configure Roles over Cardano at the creation of a Marlowe Contract.
+ *  @see
+ *   Smart Constructors are available to ease the configuration:
+ *    - {@link @marlowe.io/runtime-rest-client!contract.useMintedRoles}
+ *    - {@link @marlowe.io/runtime-rest-client!contract.mintRole}
+ *  @category Endpoint : Build Create Contract Tx
+ *  @category Roles Configuration
+ */
+export type RolesConfiguration =
+  | UsePolicyWithClosedRoleTokens
+  | UsePolicyWithOpenRoleTokens
+  | MintRolesTokens;
+
+export const RolesConfigurationGuard = t.union([
+  UsePolicyWithClosedRoleTokensGuard,
+  UsePolicyWithOpenRoleTokensGuard,
+  MintRolesTokensGuard,
+]);
+
+/**
+ * Configure Roles using tokens previously Minted. These Role Tokens are already defined (via an NFT platform, cardano-cli, another Marlowe Contract Created, etc.. )
+ * @param policyId The policy Id of All the token roles defined in the Marlowe Contract DSL
+ * @param openRoleNames defines all the Roles to be Open (Others will be Closed)
+ * @remarks
+ * It is under the user's responsability to create and distribute properly these role tokens
+ *  - Make sure all the Token Name are minted and match all the Role Names defined in the contract
+ *  - Depending on the Marlowe Contract logic, make sure the tokens are distributed to the right wallet
+ * When using Open Role Tokens
+ *  - Thread Role Token needs to me minted when using Open Roles (by default threadRoleName = "")
+ *  - see {@link index.RestClient#buildCreateContractTx | Build Create Contract Tx }
+ *  @category Endpoint : Build Create Contract Tx
+ *  @category Roles Configuration
+ */
+export const useMintedRoles = (
+  policyId: PolicyId,
+  openRoleNames?: RoleName[]
+): RolesConfiguration =>
+  openRoleNames
+    ? { script: openRole, policyId: policyId, openRoleNames: openRoleNames }
+    : (policyId as UsePolicyWithClosedRoleTokens);
+
+/**
+ *  Configure the minting of a Closed Role Token.
+ *  @param openness where to distribute the token (Either openly or closedly)
+ *  @param quantity Quantity of the Closed Role Token (by Default an NFT (==1))
+ *  @param metadata Token Metadata of the Token
+ *  @category Endpoint : Build Create Contract Tx
+ *  @category Roles Configuration
+ */
+export const mintRole = (
+  openness: Openness,
+  quantity?: TokenQuantity,
+  metadata?: TokenMetadata
+): RoleTokenConfiguration =>
+  OpenRoleGuard.is(openness)
+    ? {
+        recipients: { [openRole]: quantity ? quantity : 1n },
+        metadata: metadata,
+      }
+    : {
+        recipients: { [openness]: quantity ? quantity : 1n },
+        metadata: metadata,
+      };

packages/runtime/client/rest/src/contract/index.ts

@@ -41,20 +41,9 @@ import { submitContractViaAxios } from "./contract/endpoints/singleton.js";
 import { ContractDetails } from "./contract/details.js";
 import { TransactionDetails } from "./contract/transaction/details.js";
 import { CreateContractSourcesResponse } from "./contract/endpoints/sources.js";
+import { BuildCreateContractTxRequestWithContract } from "./contract/index.js";
 // import curlirize from 'axios-curlirize';
 
-// TODO: DELETE
-// export * from "./contract/index.js";
-// export * from "./withdrawal/index.js";
-// export * from "./payout/index.js";
-// TODO: Revisit
-export { Assets, Tokens } from "./payout/index.js";
-export { RolesConfig } from "./contract/index.js";
-// Jamie Straw suggestion: 20 endpoints
-// Runtime Rest API docs: 18 endpoints (missing, getPayouts and getPayoutById, I assume version 0.0.5)
-// Current TS-SDK: 16 endpoints
-//   https://docs.marlowe.iohk.io/api
-// openapi.json on main (RC 0.0.5): 20 endpoints
 /**
  * The RestClient offers a simple abstraction for the {@link https://docs.marlowe.iohk.io/api/ | Marlowe Runtime REST API}  endpoints.
  * You can create an instance of the RestClient using the {@link mkRestClient} function.
@@ -69,7 +58,6 @@ export { RolesConfig } from "./contract/index.js";
  *
  * **WARNING**: Not all endpoints are implemented yet.
  */
-// DISCUSSION: @N.H: Should we rename this to RestClient?
 export interface RestClient {
   /**
    * Gets a paginated list of contracts {@link contract.ContractHeader }
@@ -89,12 +77,9 @@ export interface RestClient {
    * @throws DecodingError - If the response from the server can't be decoded
    * @see {@link https://docs.marlowe.iohk.io/api/create-a-new-contract | The backend documentation}
    */
-  // TODO: Jamie, remove the `s from the end of the endpoint name in the docs site
-  // DISCUSSION: @Jamie, @N.H: Should this be called `buildCreateContractTx` instead? As it is not creating the
-  //             contract, rather it is creating the transaction to be signed
-  createContract(
-    request: Contracts.CreateContractRequest
-  ): Promise<Contracts.CreateContractResponse>;
+  buildCreateContractTx(
+    request: Contracts.BuildCreateContractTxRequest
+  ): Promise<Contracts.BuildCreateContractTxResponse>;
 
   /**
    * Uploads a marlowe-object bundle to the runtime, giving back the hash of the main contract and the hashes of the intermediate objects.
@@ -135,6 +120,9 @@ export interface RestClient {
    * Create an unsigned transaction which applies inputs to a contract.
    * @see {@link https://docs.marlowe.iohk.io/api/apply-inputs-to-contract | The backend documentation}
    */
+  // TODO: Jamie, remove the `s from the end of the endpoint name in the docs site
+  // DISCUSSION: @Jamie, @N.H: Should this be called `buildApplyInputsToContractTx` instead? As it is not applying inputs to the
+  //             contract, rather it is creating the transaction to be signed
   applyInputsToContract(
     request: Transactions.ApplyInputsToContractRequest
   ): Promise<Transactions.TransactionTextEnvelope>;
@@ -166,6 +154,9 @@ export interface RestClient {
    * Build an unsigned transaction (sign with the {@link @marlowe.io/wallet!api.WalletAPI#signTx} procedure) which withdraws available payouts from a contract (when applied with the {@link @marlowe.io/runtime-rest-client!index.RestClient#submitWithdrawal} procedure).
    * @see {@link https://docs.marlowe.iohk.io/api/withdraw-payouts | The backend documentation}
    */
+  // TODO: Jamie, remove the `s from the end of the endpoint name in the docs site
+  // DISCUSSION: @Jamie, @N.H: Should this be called `buildWithdrawPayoutsTx` instead? As it is not withdrawing the
+  //             payout, rather it is creating the transaction to be signed
   withdrawPayouts(
     request: Withdrawals.WithdrawPayoutsRequest
   ): Promise<Withdrawals.WithdrawPayoutsResponse>;
@@ -257,14 +248,21 @@ export function mkRestClient(baseURL: string): RestClient {
     getContractById(contractId) {
       return unsafeTaskEither(Contract.getViaAxios(axiosInstance)(contractId));
     },
-    createContract(request) {
+    buildCreateContractTx(request) {
       const postContractsRequest = {
-        contract: request.contract,
+        contract: "contract" in request ? request.contract : request.sourceId,
         version: request.version,
         metadata: request.metadata ?? {},
         tags: request.tags ?? {},
-        minUTxODeposit: request.minUTxODeposit,
-        roles: request.roles,
+        ...(request.minimumLovelaceUTxODeposit && {
+          minUTxODeposit: request.minimumLovelaceUTxODeposit,
+        }),
+        ...(request.roles && {
+          roles: request.roles,
+        }),
+        ...(request.threadRoleName && {
+          threadTokenName: request.threadRoleName,
+        }),
       };
       const addressesAndCollaterals = {
         changeAddress: request.changeAddress,
@@ -274,7 +272,8 @@ export function mkRestClient(baseURL: string): RestClient {
       return unsafeTaskEither(
         Contracts.postViaAxios(axiosInstance)(
           postContractsRequest,
-          addressesAndCollaterals
+          addressesAndCollaterals,
+          request.stakeAddress
         )
       );
     },
@@ -457,7 +456,7 @@ export interface ContractsAPI {
   /**
    * @see {@link https://docs.marlowe.iohk.io/api/create-contracts}
    */
-  post: Contracts.POST;
+  post: Contracts.BuildCreateContractTxEndpoint;
   contract: {
     /**
      * Get a single contract by id
@@ -500,7 +499,7 @@ export interface ContractsAPI {
  * @description Dependency Injection for the Rest Client API
  * @hidden
  */
-export type RestDI = { rest: FPTSRestAPI };
+export type RestDI = { deprecatedRestAPI: FPTSRestAPI; restClient: RestClient };
 
 /**
  * @hidden

packages/runtime/client/rest/src/contract/role.ts

@@ -1,7 +1,6 @@
 import * as t from "io-ts/lib/index.js";
 import { iso, Newtype } from "newtype-ts";
 import { fromNewtype } from "io-ts-types";
-import { optionFromNullable } from "io-ts-types";
 import { TxOutRef } from "./tx/outRef.js";
 
 export type AddressBech32 = Newtype<
@@ -18,3 +17,11 @@ export const AddressesAndCollaterals = t.type({
   usedAddresses: t.array(AddressBech32),
   collateralUTxOs: t.array(TxOutRef),
 });
+
+export type StakeAddressBech32 = Newtype<
+  { readonly StakeAddressBech32: unique symbol },
+  string
+>;
+export const StakeAddressBech32 = fromNewtype<StakeAddressBech32>(t.string);
+export const unStakeAddressBech32 = iso<StakeAddressBech32>().unwrap;
+export const stakeAddressBech32 = iso<StakeAddressBech32>().wrap;

packages/runtime/client/rest/src/contract/rolesConfigurations.ts

@@ -6,5 +6,6 @@ export * from "./tx/index.js";
 export * from "./metadata.js";
 export * from "./tag.js";
 export * from "./contract/id.js";
+export * from "./sourceId.js";
 export * from "./asset/index.js";
 export * from "./payout/index.js";

packages/runtime/client/rest/src/index.ts

@@ -0,0 +1,4 @@
+import * as t from "io-ts/lib/index.js";
+
+export type SourceId = string;
+export const SourceIdGuard = t.string;

packages/runtime/core/src/address.ts

@@ -6,12 +6,19 @@ import {
   PayoutAvailable,
   PayoutId,
   PayoutWithdrawn,
+  StakeAddressBech32,
   Tags,
   TxId,
 } from "@marlowe.io/runtime-core";
-import { RestDI, RolesConfig } from "@marlowe.io/runtime-rest-client";
+import { RestDI } from "@marlowe.io/runtime-rest-client";
+import { RolesConfiguration } from "@marlowe.io/runtime-rest-client/contract";
 import { ISO8601 } from "@marlowe.io/adapter/time";
-import { Contract, Environment, Input } from "@marlowe.io/language-core-v1";
+import {
+  Contract,
+  Environment,
+  Input,
+  RoleName,
+} from "@marlowe.io/language-core-v1";
 import { Next } from "@marlowe.io/language-core-v1/next";
 
 export type RuntimeLifecycle = {
@@ -28,14 +35,179 @@ export type RuntimeLifecycle = {
 export type ContractsDI = WalletDI & RestDI;
 
 export type CreateContractRequest = {
+  /**
+   * A Marlowe Contract to create over Cardano
+   */
   contract: Contract;
-  roles?: RolesConfig;
+
+  /**
+   * Marlowe contracts can have staking rewards for the ADA locked in the contract.
+   * Use this field to set the recipient address of those rewards
+   */
+  stakeAddress?: StakeAddressBech32;
+  /**
+   * @experimental
+   * The Thread Roles capability is an implementation details of the runtime.
+   * It allows you to provide a custom name if the thread role name is conflicting with other role names used.
+   * @default
+   *  - the Thread Role Name is "" by default.
+   * @see
+   *  - https://github.com/input-output-hk/marlowe-cardano/blob/main/marlowe-runtime/doc/open-roles.md
+   */
+  threadRoleName?: RoleName;
+
+  /**
+     * Role Token Configuration for the new contract passed in the `contract` field.
+     *
+     * <h4>Participants</h4>
+     * <p>
+     * Participants ({@link @marlowe.io/language-core-v1!index.Party | Party}) in a Marlowe Contract can be expressed in 2 ways:
+     * 
+     *  1. **By Adressses** : When an address is fixed in the contract we don't need to provide further configuration.
+     *  2. **By Roles** : When the participation is done through a Role Token, we need to define if that token is minted as part of the contract creation transaction or if it was minted beforehand.
+     * 
+     * </p>
+     *
+     * <h4>Configuration Options</h4>
+     * <p>
+     *  
+     * - **When to create (mint)**
+     *   - **Within the Runtime** : At the contrat creation, these defined Roles Tokens will be minted "on the fly" by the runtime.
+     *   - **Without the Runtime** : before the creation, these Role Tokens are already defined (via an NFT platform, `cardano-cli`, another Marlowe Contract Created, etc.. )
+     * - **How to distribute**
+     *   - **Closedly** (Closed Roles) : At the creation of contract or before, the Role Tokens are released to the participants. All the participants are known at the creation and therefore we consider the participation as being closed.
+     *   - **Openly** (Open Roles) : Whoever applies an input (IDeposit or IChoice) on the contract `contract` first will be identified as a participant by receiving the Role Token in their wallet. In that case, participants are unknown at the creation and the participation is open to any meeting the criteria.
+     * - **With or without Metadata**
+     * - **Quantities to create(Mint)** : When asking to mint the tokens within the Runtime, quantities can defined as well.
+     * 
+     * Smart Constructors are available to ease these configuration: 
+     *    - {@link @marlowe.io/runtime-rest-client!contract.useMintedRoles}
+     *    - {@link @marlowe.io/runtime-rest-client!contract.mintRole}
+     * 
+     * @remarks
+     *  - The Distribution can be a mix of Closed and Open Role Tokens configuration. See examples below.
+     * </p>
+     *
+     * @example
+     *
+     * ```ts
+     *  ////////////// 
+     *  // #1 - Mint Role Tokens
+     *  ////////////// 
+     * const anAddressBech32 = "addr_test1qqe342swyfn75mp2anj45f8ythjyxg6m7pu0pznptl6f2d84kwuzrh8c83gzhrq5zcw7ytmqc863z5rhhwst3w4x87eq0td9ja"
+     * const aMintingConfiguration =
+     *   { "closed_Role_A_NFT" : mintRole(anAddressBech32)
+     *   , "closed_Role_B_FT" :
+     *        mintRole(
+     *          anAddressBech32,
+     *          5, // Quantities
+     *          { "name": "closed_Role_B_FT Marlowe Role Token",
+                  "description": "These are metadata for closedRoleB",
+      *            image": "ipfs://QmaQMH7ybS9KmdYQpa4FMtAhwJH5cNaacpg4fTwhfPvcwj",
+      *            "mediaType": "image/png",
+      *            "files": [
+      *                {
+      *                  "name": "icon-1000",
+      *                  "mediaType": "image/webp",
+      *                  "src": "ipfs://QmUbvavFxGSSEo3ipQf7rjrELDvXHDshWkHZSpV8CVdSE5"
+      *                }
+      *              ]
+      *          })
+      *   , "open_Role_C" : mkMintOpenRoleToken()
+      *   , "open_Role_D" : mkMintOpenRoleToken(
+      *          2, // Quantities
+      *          { "name": "open_Role_D Marlowe Role Token",
+                  "description": "These are metadata for closedRoleB",
+      *            image": "ipfs://QmaQMH7ybS9KmdYQpa4FMtAhwJH5cNaacpg4fTwhfPvcwj",
+      *            "mediaType": "image/png",
+      *            "files": [
+      *                {
+      *                  "name": "icon-1000",
+      *                  "mediaType": "image/webp",
+      *                  "src": "ipfs://QmUbvavFxGSSEo3ipQf7rjrELDvXHDshWkHZSpV8CVdSE5"
+      *                }
+      *              ]
+      *          })
+      * }
+      *
+      *  ////////////// 
+      *  // #2 Use Minted Roles Tokens 
+      *  const aUseMintedRoleTokensConfiguration =
+      *      useMintedRoles(
+      *        "e68f1cea19752d1292b4be71b7f5d2b3219a15859c028f7454f66cdf",
+      *        ["role_A","role_C"]
+      *      )
+      * ```
+      *
+      * @see
+      * - {@link @marlowe.io/runtime-rest-client!contract.useMintedRoles}
+      * - {@link @marlowe.io/runtime-rest-client!contract.mintRole}
+      * - Open Roles Runtime Implementation : https://github.com/input-output-hk/marlowe-cardano/blob/main/marlowe-runtime/doc/open-roles.md
+      */
+  roles?: RolesConfiguration;
+
+  /**
+   * Marlowe Tags are stored as Metadata within the Transaction Metadata under the top-level Marlowe Reserved Key (`1564`).
+   * Tags allows to Query created Marlowe Contracts via {@link @marlowe.io/runtime-rest-client!index.RestClient#getContracts | Get contracts }
+   *
+   * <h4>Properties</h4>
+   *
+   * 1. They aren't limited size-wise like regular metadata fields are over Cardano.
+   * 2. Metadata can be associated under each tag
+   *
+   * @example
+   * ```ts
+   * const myTags : Tags = { "My Tag 1 That can be as long as I want": // Not limited to 64 bytes
+   *                            { a: 0
+   *                            , b : "Tag 1 content" // Limited to 64 bytes (Cardano Metadata constraint)
+   *                            },
+   *                         "MyTag2": { c: 0, d : "Tag 2 content"}};
+   * ```
+   */
   tags?: Tags;
+  /**
+   * Cardano Metadata about the contract creation.
+   * <h4>Properties</h4>
+   * <p>
+   * Metadata can be expressed as a JSON object with some restrictions:
+   *   - All top-level keys must be integers between 0 and 2^63 - 1.
+   *   - Each metadata value is tagged with its type.
+   *   - Strings must be at most 64 characters long (64 bytes) when UTF-8 is encoded.
+   *   - Bytestrings are hex-encoded, with a maximum length of 64 bytes.
+   *
+   * Metadata aren't stored as JSON on the Cardano blockchain but are instead stored using a compact binary encoding (CBOR).
+   * The binary encoding of metadata values supports three simple types:
+   *    - Integers in the range `-(2^63 - 1)` to `2^63 - 1`
+   *    - Strings (UTF-8 encoded)
+   *    - Bytestrings
+   *    - And two compound types:
+   *        - Lists of metadata values
+   *        - Mappings from metadata values to metadata values
+   * </p>
+   * It is possible to transform any JSON object into this schema (See https://developers.cardano.org/docs/transaction-metadata )
+   * @see
+   * https://developers.cardano.org/docs/transaction-metadata
+   */
   metadata?: Metadata;
-  minUTxODeposit?: number;
-};
 
-export const minUTxODepositDefault: number = 3_000_000;
+  /**
+   * Minimum Lovelace value to add on the UTxO created (Representing the Marlowe Contract Created on the ledger).This value
+   * is computed automatically within the Runtime, so this parameter is only necessary if you need some custom adjustment.
+   *
+   * <h4>Justification</h4>
+   * <p>Creating a Marlowe contract over Cardano is about creating UTxO entries on the Ledger.
+   *
+   * To protect the ledger from growing beyond a certain size that will cost too much to maintain,
+   * a constraint called "Minimum ada value requirement (minimumLovelaceUTxODeposit)" that adjust
+   * the value (in ADA) of each UTxO has been added.
+   *
+   * The bigger the UTxOs entries are in terms of bytesize, the higher the value if minimum ADA required.</p>
+   *
+   * @see
+   * https://docs.cardano.org/native-tokens/minimum-ada-value-requirement
+   */
+  minimumLovelaceUTxODeposit?: number;
+};
 
 export type ApplyInputsRequest = {
   inputs: Input[];

packages/runtime/core/src/index.ts

@@ -4,7 +4,10 @@ import {
 } from "@marlowe.io/wallet/browser";
 import * as Generic from "../generic/runtime.js";
 
-import { mkFPTSRestClient } from "@marlowe.io/runtime-rest-client";
+import {
+  mkFPTSRestClient,
+  mkRestClient,
+} from "@marlowe.io/runtime-rest-client";
 
 /**
  * Options for creating a RuntimeLifecycle instance using the browser wallet.
@@ -31,6 +34,7 @@ export async function mkRuntimeLifecycle({
   walletName,
 }: BrowserRuntimeLifecycleOptions) {
   const wallet = await mkBrowserWallet(walletName);
-  const restClient = mkFPTSRestClient(runtimeURL);
-  return Generic.mkRuntimeLifecycle(restClient, wallet);
+  const deprecatedRestAPI = mkFPTSRestClient(runtimeURL);
+  const restClient = mkRestClient(runtimeURL);
+  return Generic.mkRuntimeLifecycle(deprecatedRestAPI, restClient, wallet);
 }

packages/runtime/core/src/sourceId.ts

@@ -7,7 +7,6 @@ import {
   ContractsAPI,
   ContractsDI,
   CreateContractRequest,
-  minUTxODepositDefault,
 } from "../api.js";
 
 import { getAddressesAndCollaterals, WalletAPI } from "@marlowe.io/wallet/api";
@@ -20,20 +19,26 @@ import {
   HexTransactionWitnessSet,
   unAddressBech32,
   unPolicyId,
+  transactionWitnessSetTextEnvelope,
 } from "@marlowe.io/runtime-core";
 
-import { FPTSRestAPI } from "@marlowe.io/runtime-rest-client";
+import { FPTSRestAPI, RestClient } from "@marlowe.io/runtime-rest-client";
 import { DecodingError } from "@marlowe.io/adapter/codec";
-import { TransactionTextEnvelope } from "@marlowe.io/runtime-rest-client/contract/transaction/endpoints/collection";
+
 import { Next, noNext } from "@marlowe.io/language-core-v1/next";
 import { isNone, none, Option } from "fp-ts/lib/Option.js";
-import { ContractsRange } from "@marlowe.io/runtime-rest-client/contract/index";
+import {
+  BuildCreateContractTxResponse,
+  ContractsRange,
+  TransactionTextEnvelope,
+} from "@marlowe.io/runtime-rest-client/contract";
 
 export function mkContractLifecycle(
   wallet: WalletAPI,
-  rest: FPTSRestAPI
+  deprecatedRestAPI: FPTSRestAPI,
+  restClient: RestClient
 ): ContractsAPI {
-  const di = { wallet, rest };
+  const di = { wallet, deprecatedRestAPI, restClient };
   return {
     createContract: submitCreateTx(di),
     applyInputs: submitApplyInputsTx(di),
@@ -43,31 +48,33 @@ export function mkContractLifecycle(
 }
 
 const submitCreateTx =
-  ({ wallet, rest }: ContractsDI) =>
+  ({ wallet, restClient }: ContractsDI) =>
   (
     createContractRequest: CreateContractRequest
   ): Promise<[ContractId, TxId]> => {
     return unsafeTaskEither(
-      submitCreateTxFpTs(rest)(wallet)(createContractRequest)
+      submitCreateTxFpTs(restClient)(wallet)(createContractRequest)
     );
   };
 
 const submitApplyInputsTx =
-  ({ wallet, rest }: ContractsDI) =>
+  ({ wallet, deprecatedRestAPI }: ContractsDI) =>
   async (
     contractId: ContractId,
     applyInputsRequest: ApplyInputsRequest
   ): Promise<TxId> => {
     return unsafeTaskEither(
-      submitApplyInputsTxFpTs(rest)(wallet)(contractId)(applyInputsRequest)
+      submitApplyInputsTxFpTs(deprecatedRestAPI)(wallet)(contractId)(
+        applyInputsRequest
+      )
     );
   };
 
 const getApplicableInputs =
-  ({ wallet, rest }: ContractsDI) =>
+  ({ wallet, deprecatedRestAPI }: ContractsDI) =>
   async (contractId: ContractId, environement: Environment): Promise<Next> => {
     const contractDetails = await unsafeTaskEither(
-      rest.contracts.contract.get(contractId)
+      deprecatedRestAPI.contracts.contract.get(contractId)
     );
     if (isNone(contractDetails.currentContract)) {
       return noNext;
@@ -76,13 +83,15 @@ const getApplicableInputs =
         contractDetails.roleTokenMintingPolicyId
       );
       return await unsafeTaskEither(
-        rest.contracts.contract.next(contractId)(environement)(parties)
+        deprecatedRestAPI.contracts.contract.next(contractId)(environement)(
+          parties
+        )
       );
     }
   };
 
 const getContractIds =
-  ({ rest, wallet }: ContractsDI) =>
+  ({ deprecatedRestAPI, wallet }: ContractsDI) =>
   async (): Promise<ContractId[]> => {
     const partyAddresses = [
       await wallet.getChangeAddress(),
@@ -93,7 +102,9 @@ const getContractIds =
       range: Option<ContractsRange>,
       acc: ContractId[]
     ): Promise<ContractId[]> => {
-      const result = await rest.contracts.getHeadersByRange(range)(kwargs)();
+      const result = await deprecatedRestAPI.contracts.getHeadersByRange(range)(
+        kwargs
+      )();
       if (result._tag === "Left") throw result.left;
       const response = result.right;
       const contractIds = [
@@ -128,7 +139,7 @@ const getParties: (
   };
 
 export const submitCreateTxFpTs: (
-  client: FPTSRestAPI
+  client: RestClient
 ) => (
   wallet: WalletAPI
 ) => (
@@ -138,39 +149,48 @@ export const submitCreateTxFpTs: (
     pipe(
       tryCatchDefault(() => getAddressesAndCollaterals(wallet)),
       TE.chain((addressesAndCollaterals) =>
-        client.contracts.post(
-          {
-            contract: createContractRequest.contract,
+        tryCatchDefault(() =>
+          client.buildCreateContractTx({
             version: "v1",
+
+            changeAddress: addressesAndCollaterals.changeAddress,
+            usedAddresses: addressesAndCollaterals.usedAddresses,
+            collateralUTxOs: addressesAndCollaterals.collateralUTxOs,
+            stakeAddress: createContractRequest.stakeAddress,
+
+            contract: createContractRequest.contract,
+            threadRoleName: createContractRequest.threadRoleName,
             roles: createContractRequest.roles,
-            tags: createContractRequest.tags ? createContractRequest.tags : {},
-            metadata: createContractRequest.metadata
-              ? createContractRequest.metadata
-              : {},
-            minUTxODeposit: createContractRequest.minUTxODeposit
-              ? createContractRequest.minUTxODeposit
-              : minUTxODepositDefault,
-          },
-          addressesAndCollaterals
+
+            tags: createContractRequest.tags,
+            metadata: createContractRequest.metadata,
+            minimumLovelaceUTxODeposit:
+              createContractRequest.minimumLovelaceUTxODeposit,
+          })
         )
       ),
-      TE.chainW((contractTextEnvelope) =>
-        pipe(
-          tryCatchDefault(() => wallet.signTx(contractTextEnvelope.tx.cborHex)),
-          TE.chain((hexTransactionWitnessSet) =>
-            client.contracts.contract.put(
-              contractTextEnvelope.contractId,
-              hexTransactionWitnessSet
-            )
-          ),
-          TE.map(() => contractTextEnvelope.contractId)
-        )
+      TE.chainW(
+        (buildCreateContractTxResponse: BuildCreateContractTxResponse) =>
+          pipe(
+            tryCatchDefault(() =>
+              wallet.signTx(buildCreateContractTxResponse.tx.cborHex)
+            ),
+            TE.chain((hexTransactionWitnessSet) =>
+              tryCatchDefault(() =>
+                client.submitContract(
+                  buildCreateContractTxResponse.contractId,
+                  transactionWitnessSetTextEnvelope(hexTransactionWitnessSet)
+                )
+              )
+            ),
+            TE.map(() => buildCreateContractTxResponse.contractId)
+          )
       ),
       TE.map((contractId) => [contractId, contractIdToTxId(contractId)])
     );
 
 export const createContractFpTs: (
-  client: FPTSRestAPI
+  client: RestClient
 ) => (
   wallet: WalletAPI
 ) => (

packages/runtime/lifecycle/src/api.ts

@@ -17,18 +17,19 @@ import {
   withdrawalIdToTxId,
 } from "@marlowe.io/runtime-core";
 
-import { FPTSRestAPI } from "@marlowe.io/runtime-rest-client";
+import { FPTSRestAPI, RestClient } from "@marlowe.io/runtime-rest-client";
 
-import * as Rest from "@marlowe.io/runtime-rest-client";
+import * as RestPayout from "@marlowe.io/runtime-rest-client/payout";
 
 import { DecodingError } from "@marlowe.io/adapter/codec";
 import { stringify } from "json-bigint";
 
 export function mkPayoutLifecycle(
   wallet: WalletAPI,
-  rest: FPTSRestAPI
+  deprecatedRestAPI: FPTSRestAPI,
+  restClient: RestClient
 ): PayoutsAPI {
-  const di = { wallet, rest };
+  const di = { wallet, deprecatedRestAPI, restClient };
   return {
     available: fetchAvailablePayouts(di),
     withdraw: withdrawPayouts(di),
@@ -37,22 +38,28 @@ export function mkPayoutLifecycle(
 }
 
 const fetchAvailablePayouts =
-  ({ wallet, rest }: PayoutsDI) =>
+  ({ wallet, deprecatedRestAPI }: PayoutsDI) =>
   (filters?: Filters): Promise<PayoutAvailable[]> => {
     return unsafeTaskEither(
-      fetchAvailablePayoutsFpTs(rest)(wallet)(O.fromNullable(filters))
+      fetchAvailablePayoutsFpTs(deprecatedRestAPI)(wallet)(
+        O.fromNullable(filters)
+      )
     );
   };
 const withdrawPayouts =
-  ({ wallet, rest }: PayoutsDI) =>
+  ({ wallet, deprecatedRestAPI }: PayoutsDI) =>
   (payoutIds: PayoutId[]): Promise<void> => {
-    return unsafeTaskEither(withdrawPayoutsFpTs(rest)(wallet)(payoutIds));
+    return unsafeTaskEither(
+      withdrawPayoutsFpTs(deprecatedRestAPI)(wallet)(payoutIds)
+    );
   };
 const fetchWithdrawnPayouts =
-  ({ wallet, rest }: PayoutsDI) =>
+  ({ wallet, deprecatedRestAPI }: PayoutsDI) =>
   (filters?: Filters): Promise<PayoutWithdrawn[]> => {
     return unsafeTaskEither(
-      fetchWithdrawnPayoutsFpTs(rest)(wallet)(O.fromNullable(filters))
+      fetchWithdrawnPayoutsFpTs(deprecatedRestAPI)(wallet)(
+        O.fromNullable(filters)
+      )
     );
   };
 
@@ -163,12 +170,12 @@ const fetchWithdrawnPayoutsFpTs: (
       )
     );
 
-const convertAsset: (assets: Rest.Assets) => Assets = (restAssets) => ({
+const convertAsset: (assets: RestPayout.Assets) => Assets = (restAssets) => ({
   lovelaces: restAssets.lovelace,
   tokens: convertTokens(restAssets.tokens),
 });
 
-const convertTokens: (tokens: Rest.Tokens) => Tokens = (restTokens) =>
+const convertTokens: (tokens: RestPayout.Tokens) => Tokens = (restTokens) =>
   Object.entries(restTokens)
     .map(([policyId, x]) =>
       Object.entries(x).map(([assetName, quantity]) =>

packages/runtime/lifecycle/src/browser/index.ts

@@ -1,18 +1,19 @@
 import { RuntimeLifecycle } from "../api.js";
 import { WalletAPI } from "@marlowe.io/wallet/api";
 
-import { FPTSRestAPI } from "@marlowe.io/runtime-rest-client";
+import { FPTSRestAPI, RestClient } from "@marlowe.io/runtime-rest-client";
 
 import { mkPayoutLifecycle } from "./payouts.js";
 import { mkContractLifecycle } from "./contracts.js";
 
 export function mkRuntimeLifecycle(
-  restAPI: FPTSRestAPI,
+  deprecatedRestAPI: FPTSRestAPI,
+  restClient: RestClient,
   wallet: WalletAPI
 ): RuntimeLifecycle {
   return {
     wallet: wallet,
-    contracts: mkContractLifecycle(wallet, restAPI),
-    payouts: mkPayoutLifecycle(wallet, restAPI),
+    contracts: mkContractLifecycle(wallet, deprecatedRestAPI, restClient),
+    payouts: mkPayoutLifecycle(wallet, deprecatedRestAPI, restClient),
   };
 }

packages/runtime/lifecycle/src/generic/contracts.ts

@@ -17,7 +17,7 @@
 
 import { WalletAPI } from "@marlowe.io/wallet";
 import * as Generic from "./generic/runtime.js";
-import { mkFPTSRestClient } from "@marlowe.io/runtime-rest-client";
+import { mkFPTSRestClient, mkRestClient } from "@marlowe.io/runtime-rest-client";
 
 export * as Browser from "./browser/index.js";
 
@@ -42,6 +42,7 @@ export function mkRuntimeLifecycle({
   runtimeURL,
   wallet,
 }: RuntimeLifecycleOptions) {
-  const restClient = mkFPTSRestClient(runtimeURL);
-  return Generic.mkRuntimeLifecycle(restClient, wallet);
+  const deprecatedRestAPI = mkFPTSRestClient(runtimeURL);
+  const restClient = mkRestClient(runtimeURL);
+  return Generic.mkRuntimeLifecycle(deprecatedRestAPI,restClient, wallet);
 }

packages/runtime/lifecycle/src/generic/payouts.ts

@@ -0,0 +1,25 @@
+import {
+  mkFPTSRestClient,
+  mkRestClient,
+} from "@marlowe.io/runtime-rest-client";
+import * as S from "@marlowe.io/wallet/nodejs";
+import * as Generic from "../generic/runtime.js";
+
+export async function mkRuntimeLifecycle({
+  runtimeURL,
+  context,
+  privateKeyBech32,
+}: {
+  runtimeURL: string;
+  context: S.Context;
+  privateKeyBech32: string;
+}) {
+  const wallet = await S.SingleAddressWallet.Initialise(
+    context,
+    privateKeyBech32
+  );
+
+  const deprecatedRestAPI = mkFPTSRestClient(runtimeURL);
+  const restClient = mkRestClient(runtimeURL);
+  return Generic.mkRuntimeLifecycle(deprecatedRestAPI, restClient, wallet);
+}

packages/runtime/lifecycle/src/generic/runtime.ts

@@ -13,9 +13,17 @@ import {
 } from "../context.js";
 import { provisionAnAdaAndTokenProvider } from "../provisionning.js";
 import console from "console";
-import { runtimeTokenToMarloweTokenValue } from "@marlowe.io/runtime-core";
+import {
+  runtimeTokenToMarloweTokenValue,
+  unAddressBech32,
+} from "@marlowe.io/runtime-core";
 import { onlyByContractIds } from "@marlowe.io/runtime-lifecycle/api";
 import { MINUTES } from "@marlowe.io/adapter/time";
+import { mintRole, openRole } from "@marlowe.io/runtime-rest-client/contract";
+import {
+  AddressBech32,
+  AddressBech32Guard,
+} from "@marlowe.io/runtime-rest-client/contract/rolesConfigurations.js";
 
 global.console = console;
 
@@ -59,8 +67,12 @@ describe("swap", () => {
       ).contracts.createContract({
         contract: swapContract,
         roles: {
-          [swapRequest.provider.roleName]: adaProvider.address,
-          [swapRequest.swapper.roleName]: tokenProvider.address,
+          [swapRequest.provider.roleName]: mintRole(
+            adaProvider.address as unknown as AddressBech32
+          ),
+          [swapRequest.swapper.roleName]: mintRole(
+            tokenProvider.address as unknown as AddressBech32
+          ),
         },
       });
       await runtime(adaProvider).wallet.waitConfirmation(txIdContractCreated);

packages/runtime/lifecycle/src/index.ts

@@ -16,6 +16,8 @@ import console from "console";
 import { runtimeTokenToMarloweTokenValue } from "@marlowe.io/runtime-core";
 import { onlyByContractIds } from "@marlowe.io/runtime-lifecycle/api";
 import { MINUTES } from "@marlowe.io/adapter/time";
+import { mintRole } from "@marlowe.io/runtime-rest-client/contract";
+import { AddressBech32 } from "@marlowe.io/runtime-rest-client/contract/rolesConfigurations.js";
 
 global.console = console;
 
@@ -52,8 +54,12 @@ describe("Payouts", () => {
     ).contracts.createContract({
       contract: swapContract,
       roles: {
-        [swapRequest.provider.roleName]: adaProvider.address,
-        [swapRequest.swapper.roleName]: tokenProvider.address,
+        [swapRequest.provider.roleName]: mintRole(
+          adaProvider.address as unknown as AddressBech32
+        ),
+        [swapRequest.swapper.roleName]: mintRole(
+          tokenProvider.address as unknown as AddressBech32
+        ),
       },
     });
     await runtime(adaProvider).wallet.waitConfirmation(txCreatedContract);

packages/runtime/lifecycle/src/nodejs/index.ts

@@ -78,8 +78,8 @@ export async function mkBrowserWallet(
 ): Promise<WalletAPI> {
   if (
     getInstalledWalletExtensions()
-      .map((extension) => extension.name)
-      .includes(walletName)
+      .map((extension) => extension.name.toLowerCase())
+      .includes(walletName.toLowerCase())
   ) {
     const extension = await window.cardano[walletName.toLowerCase()].enable();
     const di = { extension };