1 files changed, 173 insertions, 27 deletions

diff --git a/extension/background/emscriptif.ts b/extension/background/emscriptif.ts
index b99b471f1..7a775d19a 100644
--- a/extension/background/emscriptif.ts
+++ b/extension/background/emscriptif.ts
@@ -46,7 +46,25 @@ var emsc = {
                             ['number']),
   amount_cmp: getEmsc('TALER_amount_cmp',
                       'number',
-                      ['number', 'number'])
+                      ['number', 'number']),
+  amount_hton: getEmsc('TALER_amount_hton',
+                      'void',
+                      ['number', 'number']),
+  amount_ntoh: getEmsc('TALER_amount_ntoh',
+                      'void',
+                      ['number', 'number']),
+  hash: getEmsc('GNUNET_CRYPTO_hash',
+                'void',
+                ['number', 'number', 'number']),
+  memmove: getEmsc('memmove',
+                   'number',
+                   ['number', 'number', 'number']),
+  rsa_public_key_free: getEmsc('GNUNET_CRYPTO_rsa_public_key_free',
+                               'void',
+                               ['number']),
+  string_to_data: getEmsc('GNUNET_STRINGS_string_to_data',
+                          'void',
+                          ['number', 'number', 'number', 'number'])
 };
 
 var emscAlloc = {
@@ -59,11 +77,22 @@ var emscAlloc = {
                                          'number',
                                          ['number']),
   data_to_string_alloc: getEmsc('GNUNET_STRINGS_data_to_string_alloc',
-                                         'number',
-                                         ['number', 'number']),
-  malloc: (size : number) => Module._malloc(size),
+                                'number',
+                                ['number', 'number']),
+  purpose_create: getEmsc('TALER_WRALL_purpose_create',
+                          'number',
+                          ['number', 'number', 'number']),
+  rsa_blind: getEmsc('GNUNET_CRYPTO_rsa_blind',
+                          'number',
+                          ['number', 'number', 'number', 'number']),
+  malloc: (size: number) => Module._malloc(size),
 };
 
+
+enum SignaturePurpose {
+}
+
+
 abstract class ArenaObject {
   nativePtr: number;
   arena: Arena;
@@ -114,6 +143,16 @@ class Amount extends ArenaObject {
     }
   }
 
+  toNbo(a?: Arena): AmountNbo {
+    let x = new AmountNbo(null, a);
+    emsc.amount_hton(x.nativePtr, this.nativePtr);
+    return x;
+  }
+
+  fromNbo(nbo: AmountNbo): void {
+    emsc.amount_ntoh(this.nativePtr, nbo.nativePtr);
+  }
+
   get value() {
     return emsc.get_value(this.nativePtr);
   }
@@ -172,78 +211,185 @@ class Amount extends ArenaObject {
 
 
 abstract class PackedArenaObject extends ArenaObject {
-  size: number;
+  abstract size(): number;
+
+  constructor(init?: number, a?: Arena) {
+    super(a);
+    if (init === null || init === undefined) {
+      this.nativePtr = emscAlloc.malloc(this.size());
+    } else {
+      this.nativePtr = init;
+    }
+  }
 
   encode(): string {
-    var d = emscAlloc.data_to_string_alloc(this.nativePtr, this.size);
+    var d = emscAlloc.data_to_string_alloc(this.nativePtr, this.size());
     var s = Module.Pointer_stringify(d);
     emsc.free(d);
     return s;
   }
+
+  decode(s: string) {
+    // We need to get the javascript string
+    // to the emscripten heap first.
+    // XXX: Does this work with multi-bytes code points?
+    let hstr = emscAlloc.malloc(s.length + 1);
+    Module.writeStringToMemory(s, hstr);
+    let res = emsc.string_to_data(hstr, s.length, this.nativePtr, this.size());
+    if (res < 1) {
+      throw {error: "wrong encoding"};
+    }
+  }
+
+  destroy() {
+    emsc.free(this.nativePtr);
+    this.nativePtr = 0;
+  }
+
+  hash(): HashCode {
+    var x = new HashCode();
+    emsc.hash(this.nativePtr, this.size(), x.nativePtr);
+    return x;
+  }
+}
+
+
+class AmountNbo extends PackedArenaObject {
+  size() { return 24; }
 }
 
 
 class EddsaPrivateKey extends PackedArenaObject {
   static create(a?: Arena): EddsaPrivateKey {
-    let k = new EddsaPrivateKey(a);
-    k.nativePtr = emscAlloc.eddsa_key_create();
-    return k;
+    let p = emscAlloc.eddsa_key_create();
+    return new EddsaPrivateKey(p, a);
   }
 
-  get size() { return 32; }
+  size() { return 32; }
 
   getPublicKey(): EddsaPublicKey {
-    let pk = new EddsaPublicKey(this.arena);
-    pk.nativePtr = emscAlloc.eddsa_public_key_from_private(this.nativePtr);
-    return pk;
+    let p = emscAlloc.eddsa_public_key_from_private(this.nativePtr);
+    return new EddsaPublicKey(p, this.arena);
   }
 }
 
 
 class EddsaPublicKey extends PackedArenaObject {
+  size() { return 32; }
+}
+
+
+class RsaBlindingKey extends ArenaObject {
   destroy() {
     // TODO
   }
+}
+
+
+class HashCode extends PackedArenaObject {
+  size() { return 64; }
+}
+
 
-  get size() {
-    return 32;
+class ByteArray extends PackedArenaObject {
+  private allocatedSize: number;
+  size() { return this.allocatedSize; }
+  constructor(desiredSize: number, init: number, a?: Arena) {
+    super(init, a);
+    if (init === undefined || init === null) {
+      this.nativePtr = emscAlloc.malloc(desiredSize);
+    } else {
+      this.nativePtr = init;
+    }
+    this.allocatedSize = desiredSize;
   }
 }
 
 
-class RsaBlindingKey extends ArenaObject {
-  destroy() {
-    // TODO
+class EccSignaturePurpose extends PackedArenaObject {
+  size() { return this.payload.size() + 8; }
+  payload: PackedArenaObject;
+  constructor(purpose: SignaturePurpose, payload: PackedArenaObject, a?: Arena) {
+    this.payload = payload;
+    let p = emscAlloc.purpose_create(purpose, payload.nativePtr, payload.size());
+    super(p, a);
   }
 }
 
 
-class HashCode extends ArenaObject {
-  destroy() {
-    // TODO
+abstract class SignatureStruct {
+  abstract fieldTypes(): Array<any>;
+  abstract purpose(): SignaturePurpose;
+  private members: any = {};
+  toPurpose(a?: Arena): EccSignaturePurpose {
+    let totalSize = 0;
+    for (let f of this.fieldTypes()) {
+      let name = f[0];
+      let member = this.members[name];
+      if (!member) {
+        throw {error: "Member not set", key: name};
+      }
+      totalSize += this.members[name].size();
+    }
+    let buf = emscAlloc.malloc(totalSize);
+    let ptr = buf;
+    for (let f of this.fieldTypes()) {
+      let name = f[0];
+      let member = this.members[name];
+      let size = member.size();
+      emsc.memmove(ptr, member.nativePtr, size);
+      ptr += size;
+    }
+    let ba = new ByteArray(totalSize, buf, a);
+    let x = new EccSignaturePurpose(this.purpose(), ba, a);
+    return x;
+  }
+  set(name: string, value: any) {
+    let typemap: any = {}
+    for (let f of this.fieldTypes()) {
+      typemap[f[0]] = f[1];
+    }
+    if (!(name in typemap)) {
+      throw {error: "Key not found", key: name};
+    }
+    if (!(value instanceof typemap[name])) {
+      throw {error: "Wrong type", key: name};
+    }
+    // TODO: check type!
+    this.members[name] = value;
   }
 }
 
 
-class ByteArray extends PackedArenaObject {
-  destroy() {
-    // TODO
+class WithdrawRequestPS extends SignatureStruct {
+  purpose() { return undefined; }
+  fieldTypes() {
+    return [
+       ["reserve_pub", EddsaPublicKey],
+       ["amount_with_fee", Amount],
+       ["withdraw_fee", Amount],
+       ["h_denomination_pub", HashCode],
+       ["h_coin_envelope", HashCode]];
   }
 }
 
 
 class RsaPublicKey extends ArenaObject {
   destroy() {
-    // TODO
+    emsc.rsa_public_key_free(this.nativePtr);
+    this.nativePtr = 0;
   }
 }
 
 
 function rsaBlind(hashCode: HashCode,
                   blindingKey: RsaBlindingKey, 
-                  pkey: RsaPublicKey,
+                  pkey: EddsaPublicKey,
                   arena?: Arena): ByteArray
 {
-  return null;
+  let ptr = emscAlloc.malloc(PTR_SIZE);
+  let s = emscAlloc.rsa_blind(hashCode.nativePtr, blindingKey.nativePtr, pkey.nativePtr, ptr);
+  let res = new ByteArray(s, Module.getValue(ptr, '*'), arena);
+  return res;
 }