denotify-client 1.0.0 → 1.1.2

package/dist/denotifyclient.js

@@ -96,12 +96,19 @@ export class DeNotifyClient {
         return ret.hash;
     }
     async setAlertName(triggerId, name) {
+        throw new Error('Not yet supported - Sorry!');
     }
     async enableAlert(triggerId) {
+        throw new Error('Not yet supported - Sorry!');
     }
     async disableAlert(triggerId) {
+        throw new Error('Not yet supported - Sorry!');
+    }
+    async updateNotification(triggerId) {
+        throw new Error('Not yet supported - Sorry!');
     }
     async updateTrigger(triggerId, update) {
+        // TODO - Input validation
         const ret = await this.request('patch', `alerts/trigger-handler/${triggerId}`, { body: update });
         return ret;
     }

package/dist/examples/aave-healthcheck.js

@@ -1,50 +1,47 @@
+import { AlertBuilder } from "../alertbuilder.js";
 import { DeNotifyClient } from "../denotifyclient.js";
+import { FunctionBuilder } from "../functionbuilder.js";
 import { FilterBuilder } from "../util/filter.js";
 // Simple App to demonstrate usage. Created a balance monitoring alert, updates it and deletes it
 async function main() {
     const api = await DeNotifyClient.create({
-        email: 's.battenally@gmail.com',
-        password: 'Password',
-        projectId: 'xfxplbmdcoukaitzxzei',
-        anonKey: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InhmeHBsYm1kY291a2FpdHp4emVpIiwicm9sZSI6ImFub24iLCJpYXQiOjE2NzgwMDg4NzMsImV4cCI6MTk5MzU4NDg3M30.WLk7bR5syQ4YJ8_jNOAuaT1UMvl7E2MS_VYMs7sN56c'
+        email: process.env.EMAIL,
+        password: process.env.PASSWORD,
     });
-    // const network = 'avalanche'
-    // const address = '0x26985888d5b7019ff2A7444fB567D8F386c3b538'
-    // const myAddress = '0x7601630eC802952ba1ED2B6e4db16F699A0a5A87'
-    // const { abi } = await api.getAbi(network, address)
-    // const webhook = 'https://discord.com/api/webhooks/1063967722276388874/VrdsvfyCTEtnRIk5Vzhj1Y0Fi7pFueN5dH9Bz7OeXyNpwJUI7ucIzdIQwpOq8amVgCbW'
-    // const builder = FunctionBuilder.create(api)
-    // await builder.addFunction(address, 'getBalance', [myAddress], abi)
-    // // Create the Balance Monitor alert
-    // const alert = AlertBuilder.create('Test Alert')
-    // 	.onNetwork('avalanche')
-    // 	.withTrigger<PollFunctionV2>('PollFunctionV2', {
-    // 		timeBase: 'time',
-    // 		timePeriod: '100s',
-    // 		functions: builder.get(),
-    // 		triggerOn: 'always',
-    // 	})
-    // 	.withNotification<DiscordWebhook>('Discord', {
-    // 		url: webhook,
-    // 		message: 
-    // 		`
-    // 		Your avax balance is [{func_0_ret_0 / 1e18}](https://snowtrace.io/address/${myAddress})
-    // 		`,
-    // 	})
-    // 	.config()
-    // // Create the alert with the API
-    // const triggerId = await api.createAlert(alert)
-    // console.log(triggerId)
-    // // Update the period to every 10s
-    // await api.updateTrigger(triggerId, { timePeriod: '10s' })
+    const network = 'avalanche';
+    const address = '0x26985888d5b7019ff2A7444fB567D8F386c3b538';
+    const myAddress = '0x7601630eC802952ba1ED2B6e4db16F699A0a5A87';
+    const { abi } = await api.getAbi(network, address);
+    const webhook = process.env.DISCORD_WEBHOOK;
+    const builder = FunctionBuilder.create(api);
+    await builder.addFunction(address, 'getBalance', [myAddress], abi);
+    // Create the Balance Monitor alert
+    const alert = AlertBuilder.create('Test Alert')
+        .onNetwork('avalanche')
+        .withTrigger('PollFunctionV2', {
+        timeBase: 'time',
+        timePeriod: '100s',
+        functions: builder.get(),
+        triggerOn: 'always',
+    })
+        .withNotification('Discord', {
+        url: webhook,
+        message: `Your avax balance is [{func_0_ret_0 / 1e18}](https://snowtrace.io/address/${myAddress})`,
+    })
+        .config();
+    // Create the alert with the API
+    const triggerId = await api.createAlert(alert);
+    console.log(triggerId);
+    // Update the period to every 10s
+    await api.updateTrigger(triggerId, { timePeriod: '10s' });
     // Update the Filter using the filter builder
     const filter = FilterBuilder.new()
         .addCondition('WHERE', 'func_0_ret_0', 'Number', 'gt', 3)
         .finalise();
     await api.updateTrigger(13, { triggerOn: 'filter', filter, filterVersion: FilterBuilder.version() });
     // Delete the filter in 10s
-    // setTimeout(async () => {
-    // 	await api.deleteAlert(triggerId)
-    // }, 10 * 1000)
+    setTimeout(async () => {
+        await api.deleteAlert(triggerId);
+    }, 10 * 1000);
 }
 main();

package/dist/examples/delete-alert.js

@@ -2,10 +2,8 @@ import { DeNotifyClient } from "../denotifyclient.js";
 // Simple App to demonstrate deleting an alert
 async function main() {
     const api = await DeNotifyClient.create({
-        email: 's.battenally@gmail.com',
-        password: 'Password',
-        projectId: 'xfxplbmdcoukaitzxzei',
-        anonKey: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InhmeHBsYm1kY291a2FpdHp4emVpIiwicm9sZSI6ImFub24iLCJpYXQiOjE2NzgwMDg4NzMsImV4cCI6MTk5MzU4NDg3M30.WLk7bR5syQ4YJ8_jNOAuaT1UMvl7E2MS_VYMs7sN56c'
+        email: process.env.EMAIL,
+        password: process.env.PASSWORD,
     });
     const alertId = 11;
     await api.deleteAlert(alertId);

package/dist/index.js

@@ -11,6 +11,7 @@ var followRedirects = require('follow-redirects');
 var zlib = require('zlib');
 var stream = require('stream');
 var EventEmitter = require('events');
+var ethers = require('ethers');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -4084,6 +4085,32 @@ class Notification {
     }
 }
 
+const HANDLER_FUNCTION_CALL_V1_RAW_ID = 'handler_function_call';
+class HandlerFunctionCall {
+    static SimpleToRaw(name, network, config) {
+        return {
+            alertType: 'event',
+            network,
+            nickname: name,
+            type: HANDLER_FUNCTION_CALL_V1_RAW_ID,
+            handler: config
+        };
+    }
+}
+
+const HANDLER_ONCHAIN_EVENT_V1_RAW_ID = 'handler_onchain_event';
+class HandlerOnchainEvent {
+    static SimpleToRaw(name, network, config) {
+        return {
+            alertType: 'event',
+            network,
+            nickname: name,
+            type: HANDLER_ONCHAIN_EVENT_V1_RAW_ID,
+            handler: config
+        };
+    }
+}
+
 const HANDLER_FUNCTION_CALL_V2_RAW_ID = 'handler_function_call_v2';
 class HandlerFunctionCallV2 {
     static SimpleToRaw(name, network, config) {
@@ -4101,6 +4128,8 @@ class Trigger {
     static SimpleToRaw(name, id, network, config) {
         switch (id) {
             case 'PollFunctionV2': return HandlerFunctionCallV2.SimpleToRaw(name, network, config);
+            case 'PollFunctionV1': return HandlerFunctionCall.SimpleToRaw(name, network, config);
+            case 'OnchainEventV2': return HandlerOnchainEvent.SimpleToRaw(name, network, config);
             default:
                 throw new Error('Invalid Trigger ID');
         }
@@ -4201,15 +4230,249 @@ class DeNotifyClient {
         return ret.hash;
     }
     async setAlertName(triggerId, name) {
+        throw new Error('Not yet supported - Sorry!');
     }
     async enableAlert(triggerId) {
+        throw new Error('Not yet supported - Sorry!');
     }
     async disableAlert(triggerId) {
+        throw new Error('Not yet supported - Sorry!');
+    }
+    async updateNotification(triggerId) {
+        throw new Error('Not yet supported - Sorry!');
     }
     async updateTrigger(triggerId, update) {
+        // TODO - Input validation
         const ret = await this.request('patch', `alerts/trigger-handler/${triggerId}`, { body: update });
         return ret;
     }
 }
 
+class AlertBuilder {
+    name;
+    network;
+    triggerId;
+    trigger;
+    notificationId;
+    notification;
+    constructor(name) {
+        this.name = name;
+    }
+    static create(name) {
+        return new AlertBuilder(name);
+    }
+    onNetwork(network) {
+        this.network = network;
+        return this;
+    }
+    withTrigger(id, options) {
+        this.triggerId = id;
+        this.trigger = options;
+        return this;
+    }
+    withNotification(id, options) {
+        this.notificationId = id;
+        this.notification = options;
+        return this;
+    }
+    config() {
+        if (this.trigger === undefined || this.triggerId === undefined)
+            throw new Error('Trigger not configured');
+        if (this.notification === undefined || this.notificationId === undefined)
+            throw new Error('Notification not configured');
+        if (this.network === undefined)
+            throw new Error('Network not configured');
+        return {
+            name: this.name,
+            network: this.network,
+            triggerId: this.triggerId,
+            trigger: this.trigger,
+            notificationId: this.notificationId,
+            notification: this.notification,
+        };
+    }
+}
+
+class FunctionBuilder {
+    api;
+    data = [];
+    constructor(api) {
+        this.api = api;
+    }
+    static create(api) {
+        return new FunctionBuilder(api);
+    }
+    getAbiHash(abi) {
+        if (this.api === undefined)
+            throw new Error('FunctionBuilder must be initialised with api');
+        return this.api.getAbiHash(abi);
+    }
+    async addFunction(address, func, args, abi) {
+        const contract = new ethers.ethers.Contract(address, abi);
+        contract.interface.encodeFunctionData(func, args);
+        this.data.push({
+            address,
+            bytecode: contract.interface.encodeFunctionData(func, args),
+            abiHash: await this.getAbiHash(abi),
+            function: func,
+        });
+        return this;
+    }
+    get() {
+        return this.data;
+    }
+}
+
+class Filter {
+    static version() {
+        return 'v1';
+    }
+    static execute(record, groupsIn, version = 'v1') {
+        // Deep copy to so we can edit the object during recursion
+        const groups = JSON.parse(JSON.stringify(groupsIn));
+        let lhs = true;
+        for (const group of groups) {
+            const rhs = Filter.process(record, group.conditions);
+            lhs = Filter.execLogic(lhs, group.logic, rhs);
+        }
+        return lhs;
+    }
+    static process(record, conditions, lhs) {
+        const condition = conditions.shift();
+        if (!condition) {
+            if (lhs === undefined)
+                return true;
+            return lhs;
+        }
+        // lhs <logic> rhs
+        const rhs = Filter.execCondition(record, condition);
+        if (lhs === undefined || condition.logic === 'WHERE')
+            return Filter.process(record, conditions, rhs);
+        if (condition.logic === undefined)
+            throw new Error('Invalid filter. Condition must have logic value');
+        const next = Filter.execLogic(lhs, condition.logic, rhs);
+        return Filter.process(record, conditions, next);
+    }
+    static execLogic(lhs, logic, rhs) {
+        switch (logic) {
+            case 'AND': return lhs && rhs;
+            case 'OR': return lhs || rhs;
+            case 'XOR': return (lhs || rhs) && !(lhs && rhs);
+            case 'NAND': return !(lhs && rhs);
+            case 'NOR': return !(lhs && rhs);
+            case 'WHERE': return rhs;
+            default: throw new Error(`Invalid Filter. Bad logic value: ${logic}`);
+        }
+    }
+    static execCondition(record, condition) {
+        const data = record[condition.key];
+        if (condition.type === 'Number') {
+            if (typeof condition.constant !== 'number' || typeof data !== 'number')
+                throw new Error(`Invalid filter. Type miss-match. Type: ${condition.type}, Variable: ${condition.constant}, Data: ${data}`);
+            const n = data;
+            const constant = condition.constant;
+            switch (condition.operation) {
+                case 'eq': return n === constant;
+                case '!eq': return n !== constant;
+                case 'gt': return n > constant;
+                case 'gte': return n >= constant;
+                case 'lt': return n < constant;
+                case 'lte': return n <= constant;
+                default: throw new Error('Invalid Filter. Operation does not match type');
+            }
+        }
+        if (condition.type === 'String') {
+            if (typeof condition.constant !== 'string' || typeof data !== 'string')
+                throw new Error(`Invalid filter. Type miss-match. Type: ${condition.type}, Variable: ${condition.constant}, Data: ${data}`);
+            const str = data;
+            const constant = condition.constant;
+            switch (condition.operation) {
+                case 'contains': return str.includes(constant);
+                case '!contains': return !str.includes(constant);
+                case 'is': return str === constant;
+                case '!is': return str !== constant;
+                case 'isEmpty': return str === '';
+                case '!isEmpty': return str !== '';
+                default: throw new Error('Invalid Filter. Operation does not match type');
+            }
+        }
+        if (condition.type === 'Address') {
+            if (typeof condition.constant !== 'string' || typeof data !== 'string')
+                throw new Error(`Invalid filter. Type miss-match. Type: ${condition.type}, Variable: ${condition.constant}, Data: ${data}`);
+            const str = data;
+            const constant = condition.constant;
+            switch (condition.operation) {
+                case 'contains': return str.toLowerCase().includes(constant.toLowerCase());
+                case '!contains': return !str.toLowerCase().includes(constant.toLowerCase());
+                case 'is': return str.toLowerCase() === constant.toLowerCase();
+                case '!is': return str.toLowerCase() !== constant.toLowerCase();
+                case 'isEmpty': return str === '';
+                case '!isEmpty': return str !== '';
+                default: throw new Error('Invalid Filter. Operation does not match type');
+            }
+        }
+        throw new Error('Invalid Filter. Unknown Type');
+    }
+}
+class FilterBuilder {
+    groups = [];
+    constructor() {
+        this.newGroup('WHERE');
+    }
+    static version() {
+        return Filter.version();
+    }
+    static new() {
+        return new FilterBuilder();
+    }
+    newGroup(logic) {
+        if (this.groups.length !== 0 && logic === 'WHERE')
+            throw new Error('Only the first groups can start with "WHERE"');
+        this.groups.push({ logic: 'WHERE', conditions: [] });
+        return this;
+    }
+    addCondition(logic, key, type, operation, constant) {
+        const group = this.groups[this.groups.length - 1];
+        if (group.conditions.length === 0 && logic !== 'WHERE')
+            throw new Error('Logic for the first condition of a group must be "WHERE"');
+        if (group.conditions.length > 0 && logic === 'WHERE')
+            throw new Error('Only the first condition of a group can be "WHERE"');
+        group.conditions.push({
+            logic,
+            key,
+            type,
+            operation,
+            constant
+        });
+        return this;
+    }
+    finalise() {
+        for (const group of this.groups) {
+            if (group.conditions.length === 0)
+                throw new Error('Bad Filter. All Groups must have atleast one condition');
+        }
+        return this.groups;
+    }
+}
+
+var index$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Trigger: Trigger,
+  HandlerFunctionCallV2: HandlerFunctionCallV2,
+  HandlerFunctionCall: HandlerFunctionCall,
+  HandlerOnchainEvent: HandlerOnchainEvent
+});
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  NOTIFY_DISCORD_WEBHOOK_RAW_ID: NOTIFY_DISCORD_WEBHOOK_RAW_ID,
+  NotifyDiscordWebhook: NotifyDiscordWebhook,
+  Notification: Notification
+});
+
+exports.AlertBuilder = AlertBuilder;
 exports.DeNotifyClient = DeNotifyClient;
+exports.FilterBuilder = FilterBuilder;
+exports.FunctionBuilder = FunctionBuilder;
+exports.Notification = index;
+exports.Trigger = index$1;