heimdall-tide 0.13.16 → 0.13.21

package/src/enclaves/RequestEnclave.ts

@@ -1,6 +1,7 @@
-import { BaseTideRequest } from "asgard-tide";
 import { Heimdall, HiddenInit, windowType } from "../heimdall";
-import { TideMemory } from "asgard-tide";
+import { Cryptide, Models, Clients, Tools } from "@tideorg/js";
+const TideMemory = Tools.TideMemory;
+const BaseTideRequest = Models.BaseTideRequest;
 
 enum State{
     Closed,
@@ -18,19 +19,28 @@ export class RequestEnclave extends Heimdall<RequestEnclave>{
     protected requireReloginCallback: () => Promise<string>;
     private state: State = State.Closed;
 
+    protected bgUrl: string;
+    protected logoUrl: string;
+
     _windowType: windowType = windowType.Hidden;
 
     protected initDone: Promise<any> = this.recieve("init done");
+    private sessionId?: string;
 
     init(data: HiddenInit): RequestEnclave {
         if(!data.doken) throw 'Doken not provided';
 
+        if(data.backgroundUrl) this.bgUrl = data.backgroundUrl
+        if(data.logoUrl) this.logoUrl = data.logoUrl
+
         this.doken = data.doken;
         let parsedDoken = decodeToken(this.doken);
         if(parsedDoken["t.uho"]) this.enclaveOrigin = parsedDoken["t.uho"]; // use tidecloak set user home ork from doken
         this.dokenRefreshCallback = data.dokenRefreshCallback;
         this.requireReloginCallback = data.requireReloginCallback;
 
+        this.handleSessionCheck();
+
         if(this.state !== State.Closed) return; // someone has already called init
         
         if(this._windowType === windowType.Hidden){
@@ -129,6 +139,11 @@ export class RequestEnclave extends Heimdall<RequestEnclave>{
         // Set requestsed enclave
         url.searchParams.set("type", this.name);
 
+        this.doken
+
+        if(this.bgUrl) url.searchParams.set("backgroundUrl", this.bgUrl)
+        if(this.logoUrl) url.searchParams.set("logoUrl", this.logoUrl)
+
         return url;
     }
     checkEnclaveOpen(){
@@ -165,10 +180,14 @@ export class RequestEnclave extends Heimdall<RequestEnclave>{
             console.log(`[HEIMDALL] Attempting to open ${windowType[this._windowType]} window`);
             this.open().then((success: boolean) => {
                 if(success){
+                    const session = new Uint32Array(5);
+                    self.crypto.getRandomValues(session);
+                    this.sessionId = Array.from(session, v => v.toString(16).padStart(8, '0')).join('');
                     this.send({
                         type: "init",
                         message:{
-                            doken: this.doken
+                            doken: this.doken,
+                            sessionId: this.sessionId
                         }
                     });
                     console.log(`[HEIMDALL] Successfully opened ${windowType[this._windowType]} window`);
@@ -187,7 +206,7 @@ export class RequestEnclave extends Heimdall<RequestEnclave>{
         }
     }
 
-    async initializeRequest(request: TideMemory): Promise<Uint8Array>{
+    async initializeRequest(request: Tools.TideMemory): Promise<Uint8Array>{
         // construct request to sign this request's creation
         const requestToInitialize = BaseTideRequest.decode(request);
         const requestToInitializeDetails = await requestToInitialize.getRequestInitDetails();
@@ -210,7 +229,7 @@ export class RequestEnclave extends Heimdall<RequestEnclave>{
         return requestToInitialize.addCreationSignature(requestToInitializeDetails.creationTime, creationSig).encode();
     }
 
-    async execute(data: TideMemory, waitForAll: boolean = false): Promise<Uint8Array[]>{
+    async execute(data: Tools.TideMemory, waitForAll: boolean = false): Promise<Uint8Array[]>{
         this.checkEnclaveOpen();
         await this.initDone;
         const pre_resp = this.recieve("sign request completed");
@@ -223,38 +242,129 @@ export class RequestEnclave extends Heimdall<RequestEnclave>{
             }
         })
         const resp = await pre_resp;
+        if(typeof resp.error === 'string') {
+            throw Error(resp.error);
+        }
         if(!Array.isArray(resp)) throw 'Expecting request completed data to be an array, not' + resp;
         if(!resp.every((d: any) => d instanceof Uint8Array)) throw 'Expecting all entries in response to be Uint8Arrays';
         return resp;
     }
-    async decrypt(data: decryptRequest): Promise<Uint8Array[]>{
+    async decrypt(data: decryptRequest[], policy?: Uint8Array): Promise<Uint8Array[]>{
         this.checkEnclaveOpen();
         await this.initDone;
         const pre_resp = this.recieve("decrypt request completed");
         this.send({
             type: "request",
             message:{
-                flow: "decrypt",
-                request: data
+                flow: policy ? "policy decrypt" : "decrypt",
+                request: data,
+                policy: policy
             }
         })
         const resp = await pre_resp;
+        if(typeof resp.error === 'string') {
+            throw Error(resp.error);
+        }        
         if(!Array.isArray(resp)) throw 'Expecting request completed data to be an array, not' + resp;
         if(!resp.every((d: any) => d instanceof Uint8Array)) throw 'Expecting all entries in response to be Uint8Arrays';
         return resp;
     }
-    async encrypt(data: encryptRequest): Promise<Uint8Array[]>{
+    async encrypt(data: encryptRequest[], policy?: Uint8Array): Promise<Uint8Array[]>{
         this.checkEnclaveOpen();
         await this.initDone;
         const pre_resp = this.recieve("encrypt request completed");
         this.send({
             type: "request",
             message: {
-                flow: "encrypt",
-                request: data
+                flow: policy ? "policy encrypt" : "encrypt",
+                request: data,
+                policy: policy
+            }
+        })
+        const resp = await pre_resp;
+        if(typeof resp.error === 'string') {
+            throw Error(resp.error);
+        }
+        if(!Array.isArray(resp)) throw 'Expecting request completed data to be an array, not' + resp;
+        if(!resp.every((d: any) => d instanceof Uint8Array)) throw 'Expecting all entries in response to be Uint8Arrays';
+        return resp;
+    }
+
+    async draftEncryption(data: encryptRequest[]) : Promise<Uint8Array> {
+        this.checkEnclaveOpen();
+        await this.initDone;
+        const pre_resp = this.recieve("encrypt request completed");
+        this.send({
+            type: "request",
+            message: {
+                flow: "policy encrypt",
+                request: data,
+            }
+        })
+        const resp = await pre_resp;
+        if(typeof resp.error === 'string') {
+            throw Error(resp.error);
+        }
+        if(!(resp instanceof Uint8Array)) throw `Expecting response type to be Uint8Array`;
+        return resp;
+    }
+
+    async draftDecryption(data: decryptRequest[]) : Promise<Uint8Array> {
+        this.checkEnclaveOpen();
+        await this.initDone;
+        const pre_resp = this.recieve("decrypt request completed");
+        this.send({
+            type: "request",
+            message: {
+                flow: "policy decrypt",
+                request: data,
+            }
+        })
+        const resp = await pre_resp;
+        if(typeof resp.error === 'string') {
+            throw Error(resp.error);
+        }
+        if(!(resp instanceof Uint8Array)) throw `Expecting response type to be Uint8Array`;
+        return resp;
+    }
+
+    async commitEncryption(readyEncryptionRequest: Uint8Array, policy: Uint8Array): Promise<Uint8Array[]> {
+        this.checkEnclaveOpen();
+        await this.initDone;
+        const pre_resp = this.recieve("commit encrypt request completed");
+        this.send({
+            type: "request",
+            message: {
+                flow: "commit encrypt",
+                request: readyEncryptionRequest,
+                policy: policy
             }
         })
         const resp = await pre_resp;
+        if(typeof resp.error === 'string') {
+            throw Error(resp.error);
+        }
+        if(!Array.isArray(resp)) throw 'Expecting request completed data to be an array, not' + resp;
+        if(!resp.every((d: any) => d instanceof Uint8Array)) throw 'Expecting all entries in response to be Uint8Arrays';
+        return resp;
+    }
+
+    async commitDecryption(readyDecryptionRequest: Uint8Array, policy: Uint8Array): Promise<Uint8Array[]> {
+        this.checkEnclaveOpen();
+        await this.initDone;
+        const pre_resp = this.recieve("commit decrypt request completed");
+        this.send({
+            type: "request",
+            message: {
+                flow: "commit decrypt",
+                request: readyDecryptionRequest,
+                policy: policy
+            }
+        })
+        const resp = await pre_resp;
+        if(typeof resp.error === 'string') {
+            throw Error(resp.error);
+        }
         if(!Array.isArray(resp)) throw 'Expecting request completed data to be an array, not' + resp;
         if(!resp.every((d: any) => d instanceof Uint8Array)) throw 'Expecting all entries in response to be Uint8Arrays';
         return resp;
@@ -270,6 +380,14 @@ export class RequestEnclave extends Heimdall<RequestEnclave>{
         });
     }
 
+    async handleSessionCheck() {
+        this.recieve("session check", true).then(() => this.handleSessionCheck());
+        this.send({
+            type: "current session",
+            message: this.sessionId
+        })
+    }
+
     async onerror(data: any) {
         if(typeof data.message === "string"){
             switch(data.message){

package/src/heimdall.ts

@@ -74,14 +74,14 @@ export abstract class Heimdall<T> implements EnclaveFlow<T> {
                 break;
         }
     }
-    public async recieve(type: string): Promise<any> {
+    public async recieve(type: string, silent: boolean = false): Promise<any> {
         switch(this._windowType){
             case windowType.Popup:
-                return this.waitForWindowPostMessage(type);
+                return this.waitForWindowPostMessage(type, silent);
             case windowType.Redirect:
                 throw new Error("Method not implemented.");
             case windowType.Hidden:
-                return this.waitForWindowPostMessage(type);
+                return this.waitForWindowPostMessage(type, silent);
         }
     }
     public close() {
@@ -170,10 +170,10 @@ export abstract class Heimdall<T> implements EnclaveFlow<T> {
         this.enclaveWindow?.close();
     }
 
-    private async waitForWindowPostMessage(responseTypeToAwait: string) {
+    private async waitForWindowPostMessage(responseTypeToAwait: string, silent: boolean = false) {
         return new Promise((resolve) => {
             const handler = (event) => {
-                const response = this.processEvent(event.data, event.origin, responseTypeToAwait);
+                const response = this.processEvent(event.data, event.origin, responseTypeToAwait, silent);
                 if (response.ok) {
                     resolve(response.message);
                     window.removeEventListener("message", handler);
@@ -189,7 +189,7 @@ export abstract class Heimdall<T> implements EnclaveFlow<T> {
         this.enclaveWindow?.postMessage(message, this.enclaveOrigin);
     }
 
-    private processEvent(data: any, origin: string, expectedType: string){
+    private processEvent(data: any, origin: string, expectedType: string, silent: boolean){
         if (origin !== new URL(this.enclaveOrigin).origin) {
             // Something's not right... The message has come from an unknown domain... 
             return {ok: false, print: false, error: "WRONG WINDOW SENT MESSAGE"};
@@ -205,10 +205,10 @@ export abstract class Heimdall<T> implements EnclaveFlow<T> {
         }
 
         if(expectedType !== data.type) {
-            console.log("[HEIMDALL] Received type{" + data.type + "} but waiting for type{" + expectedType + "}");
+            if(!silent) console.log("[HEIMDALL] Received type{" + data.type + "} but waiting for type{" + expectedType + "}");
             return {ok: false, print: false, error: "handled error"}
         }else{
-            console.log("[HEIMDALL] Correctly received type{" + data.type + "}");
+            if(!silent) console.log("[HEIMDALL] Correctly received type{" + data.type + "}");
             return {ok: true, message: data.message}
         }
     }
@@ -219,6 +219,10 @@ export enum windowType{
     Hidden
 };
 export interface HiddenInit{
+    backgroundUrl: string;
+
+    logoUrl: string;
+
     doken: string;
     /**
      * @returns A refresh doken for Heimdall

package/src/index.ts

@@ -2,10 +2,8 @@ import { ApprovalEnclave } from "./enclaves/ApprovalEnclave"
 import { RequestEnclave } from "./enclaves/RequestEnclave"
 import { ApprovalEnclaveNew } from "./enclaves/ApprovalEnclaveNEW"
 import PolicySignRequest from "./models/PolicySignRequest"
-import { TideMemory, Policy, BaseTideRequest, PolicyParameters } from "asgard-tide"
 
 export { ApprovalEnclave }
 export { RequestEnclave }
 export { ApprovalEnclaveNew }
 export { PolicySignRequest }
-export { TideMemory, Policy, BaseTideRequest, PolicyParameters }

package/src/models/PolicySignRequest.ts

@@ -1,19 +1,38 @@
-import { TideMemory } from "asgard-tide";
-import { BaseTideRequest } from "asgard-tide";
-import { Policy } from "asgard-tide";
+import { Cryptide, Models, Clients, Tools, Contracts } from "@tideorg/js";
+const TideMemory = Tools.TideMemory;
+const BaseTideRequest = Models.BaseTideRequest;
+const Policy = Models.Policy;
+const GenericResourceAccessThresholdRoleContract = Contracts.GenericResourceAccessThresholdRoleContract
+
+const forsetiType = "forseti";
+const forsetiEntryType = "Contract";
 
 export default class PolicySignRequest extends BaseTideRequest {
+    private new_policy: Models.Policy;
     constructor(name: string, version: string, authFlow: string, draft: Uint8Array, dyanmicData: Uint8Array) {
         super(name, version, authFlow, draft, dyanmicData);
     }
-    static New(policy: Policy) : PolicySignRequest{
-        return new PolicySignRequest(
+    static New(policy: Models.Policy) : PolicySignRequest{
+        const p = new PolicySignRequest(
             "Policy",
             "1",
             "Policy:1",
             TideMemory.CreateFromArray([policy.toBytes()]),
             new TideMemory()
         );
+        p.new_policy = policy;
+        return p;
+    }
+
+    addForsetiContractToUpload(source: Uint8Array | string){
+        const te = new TextEncoder();
+        const s = typeof source === "string" ? te.encode(source) : source;
+        const innerPayload = TideMemory.CreateFromArray([s, te.encode(forsetiEntryType)]);
+        const forsetiData = TideMemory.CreateFromArray([new Uint8Array(0), innerPayload]);
+        const contractTransport = TideMemory.CreateFromArray([te.encode(forsetiType), forsetiData]);
+        const draft = TideMemory.CreateFromArray([this.new_policy.toBytes(), contractTransport]);
+        this.draft = draft;
+        return this;
     }
 
     getRequestedPolicy(){

package/src/wrapper.ts

@@ -1,7 +1,8 @@
-import { TideMemory } from "asgard-tide";
+import { Tools } from "@tideorg/js";
+const TideMemory = Tools.TideMemory;
 export const version = "1";
 
-export function wrapper(arr: NestedEntry): TideMemory {
+export function wrapper(arr: NestedEntry): Tools.TideMemory {
     // If array is only Uint8Arrays - create a TideMemory out of it 
     // If there is any entry in an array that is another array
     //     -> Go inside that array and repeat the process