feat: invoke with tickets

Author: aguillon

deku-c/client/src/deku-c/contract.ts

@@ -1,5 +1,6 @@
 import { DekuCClient } from ".";
 import { DekuPClient } from "../deku-p/index";
+import Balances, { Balances as BalancesType } from "../deku-p/core/balances";
 import { compileExpression, compileLigoExpression } from "./utils";
 
 export type JSONType =
@@ -108,21 +109,25 @@ export class Contract {
    * @param parameter the parameter of the contract as provided by tunac
    * @returns the hash of the operation
    */
-  async invokeRaw(parameter: any): Promise<string> {
+  async invokeRaw(parameter: any, tickets?: BalancesType): Promise<string> {
+    if (tickets === undefined) tickets = [];
+
     const invoke = {
       operation: JSON.stringify({
         address: this.address,
         argument: parameter,
       }),
-      tickets: [],
+      tickets,
     };
     const hash = await this.deku.submitVmOperation(invoke);
     return hash;
   }
 
-  async invoke(expression: string): Promise<string> {
+  async invoke(expression: string, tickets?: BalancesType): Promise<string> {
+    if (!tickets) tickets = [];
     const parameter = { expression, address: this.address };
     const invoke = await compileExpression(this.deku.dekuRpc, parameter);
+    invoke.tickets = Balances.toDTO(tickets);
     const hash = await this.deku.submitVmOperation(invoke);
     return hash;
   }
@@ -132,7 +137,11 @@ export class Contract {
    * @param parameter the parameter of the contract, in Ligo // FIXME lang
    * @returns the hash of the operation
    */
-  async invokeLigo(kind: ligo_kind, code: string, expression: string): Promise<string> {
+  async invokeLigo(
+    kind: ligo_kind,
+    code: string,
+    expression: string
+  ): Promise<string> {
     // FIXME the need for the two RPCs stinks (also they're strings)
     const parameter = {
       kind,

deku-c/client/src/deku-c/index.ts

@@ -17,7 +17,6 @@ export type Settings = {
 export class DekuCClient extends DekuPClient {
   readonly ligoRpc?: string;
 
-
   constructor(settings: Settings) {
     super(settings);
     this.ligoRpc = settings.ligoRpc;

deku-c/client/src/deku-c/utils.ts

@@ -1,4 +1,5 @@
 import { JSONType } from "./contract";
+import Balances, { Balances as BalancesType } from "../deku-p/core/balances";
 import * as path from "path";
 
 export const originateTz = async (
@@ -35,7 +36,10 @@ export const originateLigo = async (
         method: "POST",
         body: JSON.stringify({ lang: kind, source: code }),
       };
-      const result = await fetch(path.join(ligoRpc, "/api/v1/ligo/originate"), options);
+      const result = await fetch(
+        path.join(ligoRpc, "/api/v1/ligo/originate"),
+        options
+      );
       const { code: source } = await result.json();
       return originateTz(dekuRpc, { code: source, initialStorage });
     }
@@ -88,7 +92,10 @@ export const compileLigoExpression = async (
           expression: ligoExpression,
         }),
       };
-      const result = await fetch(path.join(ligoRpc, "/api/v1/ligo/expression"), options);
+      const result = await fetch(
+        path.join(ligoRpc, "/api/v1/ligo/expression"),
+        options
+      );
       const { expression } = await result.json();
       return compileExpression(dekuRpc, { expression, address });
     }

deku-c/client/src/deku-p/core/address.ts

@@ -1 +1,21 @@
+import { validateKeyHash, validateContractAddress } from "@taquito/utils";
+
 export type Address = string;
+
+const parseAddress = (s: string): Address => {
+  if (s[0] === '"') {
+    if (!(s[s.length - 1] === '"')) throw Error(`Ill-formed address: ${s}`);
+    s = s.slice(1, -1);
+  }
+
+  // TODO: check that the address is correct for Deku
+  if (s.slice(0, 2) === "DK") return s;
+
+  if (validateKeyHash(s) || validateContractAddress(s)) return s;
+
+  throw Error(`Invalid address ${s}`);
+};
+
+export default {
+  parseAddress,
+};

deku-c/client/src/deku-p/core/balances.ts

@@ -1,3 +1,4 @@
+import Amount, { Amount as AmountType } from "./amount";
 import JSONValue, { JSONType } from "../utils/json";
 import TicketID, { TicketID as TicketIDType } from "./ticket-id";
 
@@ -23,6 +24,32 @@ const ofDTO = (json: JSONValue): Balances | null => {
   return balances;
 };
 
+const toDTO = (balances: Balances) => {
+  const DTO = balances.map((tamount) => {
+    const ticket = TicketID.toDTO(tamount.ticket);
+    const amount = tamount.amount.toString(); // FIXME please help
+    return [ticket, amount];
+  });
+  return DTO;
+};
+
+const parseTicketAmount = (s: string): TicketAmount => {
+  if (s[0] === "(") {
+    if (!(s[s.length - 1] === ")")) throw Error(`Ill-formed pair: ${s}`);
+    s = s.slice(1, -1);
+  }
+  const parts = s.split(" ").filter((x) => x);
+  let i = 0;
+  if (parts[0] == "Pair") i = 1;
+
+  const ticketID = TicketID.parseTicketID(parts[i] + " " + parts[i + 1]);
+  const amount = parseInt(parts[i + 2]);
+  if (amount) return { ticket: ticketID, amount };
+  else throw Error(`Incorrect amount: ${parts[i + 2]}`);
+};
+
 export default {
   ofDTO,
+  toDTO,
+  parseTicketAmount,
 };

deku-c/client/src/deku-p/core/ticket-id.ts

@@ -1,7 +1,8 @@
 import JSONValue, { JSONType } from "../utils/json";
+import Address, { Address as AddressType } from "./address";
 
 export type TicketID = {
-  ticketer: string;
+  ticketer: AddressType;
   data: string;
 };
 
@@ -25,18 +26,32 @@ const ofDTO = (json: JSONValue): TicketID | null => {
   return { ticketer, data };
 };
 
-const ofString = (str: String): TicketID | null => {
-  const split = str.split(" ");
+const toDTO = (ticket: TicketID) => {
+  let data = ticket.data;
+  if (data.startsWith("0x")) data = data.slice(2);
+
+  return [
+    "Ticket_id",
+    {
+      ticketer: ticket.ticketer,
+      data: data,
+    },
+  ];
+};
+
+const parseTicketID = (str: String): TicketID => {
+  const split = str.split(" ").filter((x) => x);
   if (split.length != 2) {
     throw Error(`Incorrect argument for TicketID: ${str}`);
   }
 
-  // TODO test ticketer and data are valid
-  return { ticketer: split[0], data: split[1] };
+  // TODO test that data is valid
+  return { ticketer: Address.parseAddress(split[0]), data: split[1] };
 };
 
 export default {
   createTicketID,
   ofDTO,
-  ofString,
+  toDTO,
+  parseTicketID,
 };

deku-c/client/src/deku-p/index.ts

@@ -357,14 +357,14 @@ export class DekuPClient {
     return this.submitOperation(noopOperation);
   }
 
-  async wait(operationHash: OperationHashType): Promise<LevelType> {
-    console.log(operationHash);
+  async wait(_operationHash: OperationHashType): Promise<LevelType> {
     throw "Feature not yet implemented"; // TODO: implement this feature
   }
 }
 
-export const parseTicketID = TicketID.ofString;
+export const parseTicketID = TicketID.parseTicketID;
 export const makeTicketID = TicketID.createTicketID;
+export const parseTicketAmount = Balances.parseTicketAmount;
 // TODO export type too?
 
 export {

deku-c/client/src/index.ts

@@ -5,5 +5,6 @@ export {
   fromMemorySigner,
   parseTicketID,
   makeTicketID,
+  parseTicketAmount,
 } from "./deku-p";
 export { DekuCClient, Contract } from "./deku-c";

deku-c/client/tsconfig.json

@@ -1,5 +1,5 @@
 {
-  "include": ["src/index.ts",],
+  "include": ["src/index.ts"],
   "exclude": ["node_modules", "**/*.spec.ts"],
   "compilerOptions": {
     "outDir": "dist",

deku-c/deku-cli/commands/invoke.ts

@@ -1,6 +1,6 @@
 import { fromMemorySigner } from "@marigold-dev/deku";
 import { InMemorySigner } from "@taquito/signer";
-import { Contract, DekuCClient } from "@marigold-dev/deku";
+import { Contract, DekuCClient, parseTicketAmount } from "@marigold-dev/deku";
 import { load } from "../core/wallet";
 import * as Commander from "commander";
 import { read, isLigo } from "../core/contract";
@@ -17,21 +17,28 @@ function getContract(apiUri, walletPath, contractAddress, ligoUri?) {
   return deku.contract(contractAddress);
 }
 
+function parseTicketAmounts(args: string[]) {
+  return args.map((str) => {
+    return parseTicketAmount(str);
+  });
+}
+
 async function invokeMain(
   apiUri,
   walletPath,
   contractAddress,
   parameter,
+  ticketAmounts,
   options
 ) {
   try {
     const contract = getContract(apiUri, walletPath, contractAddress);
     if (options.raw !== undefined) {
       const parameter_parsed = JSON.parse(parameter);
-      const hash = await contract.invokeRaw(parameter);
+      const hash = await contract.invokeRaw(parameter, ticketAmounts);
       console.log("Operation hash:", hash);
     } else {
-      const hash = await contract.invoke(parameter);
+      const hash = await contract.invoke(parameter, ticketAmounts);
       console.log("operation hash:", hash);
     }
   } catch (e) {
@@ -88,8 +95,19 @@ export default function make(command: Commander.Command) {
       `URI of the deku API to use (default ${default_.api})`
     )
     .action((walletPath, contractAddress, parameter, options) => {
+      const unparsedArguments = invoke.args.slice(3);
+      console.log("UNPARSED:", unparsedArguments);
       const apiUri = options.endpoint ?? default_.api;
-      invokeMain(apiUri, walletPath, contractAddress, parameter, options);
+      const tickets = parseTicketAmounts(unparsedArguments);
+
+      invokeMain(
+        apiUri,
+        walletPath,
+        contractAddress,
+        parameter,
+        tickets,
+        options
+      );
     });
 
   invokeLigo