denotify-client 1.0.0

package/README.md

@@ -0,0 +1 @@
+# denotify-client

package/dist/alertbuilder.js

@@ -0,0 +1,44 @@
+export 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,
+        };
+    }
+}

package/dist/denotifyclient.js

@@ -0,0 +1,108 @@
+import { createClient } from "@supabase/supabase-js";
+import axios from "axios";
+import { Notification } from "./notifications/notification.js";
+import { Trigger } from "./triggers/trigger.js";
+const toFunctionsUrl = (id) => {
+    return `https://${id}.functions.supabase.co/`;
+};
+const toApiUrl = (id) => {
+    return `https://${id}.supabase.co/`;
+};
+const PROD_PROJECT_ID = 'fdgtrxmmrtlokhgkvcjz';
+// const API_URL = ''
+const ANON_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImZkZ3RyeG1tcnRsb2toZ2t2Y2p6Iiwicm9sZSI6ImFub24iLCJpYXQiOjE2NzMwODcwNzYsImV4cCI6MTk4ODY2MzA3Nn0.sAMxjlcJSSozBGr-LNcsudyxzUEM9e-UspMHHQLqLr4';
+export class DeNotifyClient {
+    url;
+    token;
+    headers = {};
+    constructor(url, token) {
+        this.url = url;
+        this.token = token;
+        this.headers = {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json'
+        };
+    }
+    static async create(options) {
+        if (options.key) {
+            // TODO
+            throw new Error('Auth by key not yet supported');
+        }
+        else if (options.email && options.password) {
+            const url = options.projectId ? toApiUrl(options.projectId) : toApiUrl(PROD_PROJECT_ID);
+            const functionsUrl = options.projectId ? toFunctionsUrl(options.projectId) : toFunctionsUrl(PROD_PROJECT_ID);
+            const anonKey = options.anonKey ? options.anonKey : ANON_KEY;
+            const supabase = createClient(url, anonKey);
+            const { data: login, error } = await supabase.auth.signInWithPassword({
+                email: options.email,
+                password: options.password,
+            });
+            if (error)
+                throw error;
+            if (login.session?.access_token === undefined)
+                throw new Error('Access token not found');
+            return new DeNotifyClient(functionsUrl, login.session?.access_token);
+        }
+        else {
+            throw new Error('Authentication Required. DeNotify supports either username/password or API key authentication');
+        }
+    }
+    async alertHistory(id, pagination = {}) {
+        const alerts = await this.request('get', `alert-history${id ? '/' + id : ''}`, { params: pagination });
+        return alerts;
+    }
+    async getAlert(id) {
+        const alerts = await this.request('get', `alerts/${id}`);
+        return alerts[0];
+    }
+    async getAlerts() {
+        const alerts = await this.request('get', 'alerts');
+        return alerts;
+    }
+    async createAlert(config) {
+        const trigger = Trigger.SimpleToRaw(config.name, config.triggerId, config.network, config.trigger);
+        const notification = Notification.SimpleToRaw(config.notificationId, config.notification);
+        const alert = await this.request('post', `alerts`, { body: { trigger, notification } });
+        return alert;
+    }
+    async deleteAlert(id) {
+        const alerts = await this.request('delete', `alerts/${id}`);
+        return alerts;
+    }
+    async request(method, path, options = {}) {
+        const url = new URL(`${this.url}${path}`);
+        // append params
+        if (options.params) {
+            for (const param of Object.keys(options.params)) {
+                url.searchParams.append(param, options.params[param]);
+            }
+        }
+        const payload = {
+            method,
+            url: url.toString(),
+            headers: this.headers
+        };
+        if (options.body)
+            payload.data = options.body;
+        const res = await axios(payload);
+        return res.data;
+    }
+    async getAbi(network, address) {
+        const ret = await this.request('get', `abi/${network}/${address}`);
+        return ret;
+    }
+    async getAbiHash(abi) {
+        const ret = await this.request('post', 'abi', { body: abi });
+        return ret.hash;
+    }
+    async setAlertName(triggerId, name) {
+    }
+    async enableAlert(triggerId) {
+    }
+    async disableAlert(triggerId) {
+    }
+    async updateTrigger(triggerId, update) {
+        const ret = await this.request('patch', `alerts/trigger-handler/${triggerId}`, { body: update });
+        return ret;
+    }
+}

package/dist/examples/aave-healthcheck.js

@@ -0,0 +1,50 @@
+import { DeNotifyClient } from "../denotifyclient.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'
+    });
+    // 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' })
+    // 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)
+}
+main();

package/dist/examples/delete-alert.js

@@ -0,0 +1,13 @@
+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'
+    });
+    const alertId = 11;
+    await api.deleteAlert(alertId);
+}
+main();

package/dist/functionbuilder.js

@@ -0,0 +1,30 @@
+import { ethers } from "ethers";
+export 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.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;
+    }
+}