m2m-sentinel-sdk 1.0.0

package/cli/m2m_cli.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+const command = process.argv[2];
+const address = process.argv[3];
+
+if (command === "audit" && address) {
+    const url = `https://m2msentinel.vercel.app/v1/audit/${address}`;
+    fetch(url)
+        .then(res => {
+            if (!res.ok) {
+                throw new Error(`HTTP error! status: ${res.status}`);
+            }
+            return res.json();
+        })
+        .then(data => {
+            console.log(JSON.stringify(data, null, 2));
+        })
+        .catch(err => {
+            console.error("Error running audit:", err.message);
+            process.exit(1);
+        });
+} else {
+    console.log("Usage: npx m2m-cli audit <address>");
+    process.exit(1);
+}

package/csharp/M2MSentinel.csproj

@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <PackageId>M2MSentinel</PackageId>
+    <Version>1.0.0</Version>
+    <Authors>M2M Sentinel</Authors>
+    <Description>Enterprise C# SDK for M2M Sentinel.</Description>
+  </PropertyGroup>
+</Project>

package/csharp/M2MSentinelClient.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Net.Http;
+using System.Threading.Tasks;
+using System.Web;
+
+namespace M2MSentinel
+{
+    public class M2MSentinelClient
+    {
+        private readonly HttpClient _httpClient;
+        private readonly string _baseUrl;
+        public readonly string PayoutWallet = "0x1C79BfBFA67Ab140f72f0F6888123a70D9DaC23e";
+
+        public M2MSentinelClient(string baseUrl = "https://m2msentinel.vercel.app")
+        {
+            _baseUrl = baseUrl.TrimEnd('/');
+            _httpClient = new HttpClient();
+        }
+
+        private async Task<string> GetAsync(string path)
+        {
+            var response = await _httpClient.GetAsync($"{_baseUrl}{path}");
+            response.EnsureSuccessStatusCode();
+            return await response.Content.ReadAsStringAsync();
+        }
+
+        public Task<string> AuditContractAsync(string address)
+        {
+            return GetAsync($"/v1/audit/{HttpUtility.UrlEncode(address)}");
+        }
+
+        public Task<string> GetDexMetricsAsync()
+        {
+            return GetAsync("/v1/dex/metrics");
+        }
+
+        public Task<string> GetWhaleSignalsAsync()
+        {
+            return GetAsync("/v1/whales/signals");
+        }
+
+        public Task<string> GetTokenPriceAsync(string symbol)
+        {
+            return GetAsync($"/v1/token/price/{HttpUtility.UrlEncode(symbol)}");
+        }
+
+        public Task<string> SearchAsync(string query)
+        {
+            return GetAsync($"/v1/search?q={HttpUtility.UrlEncode(query)}");
+        }
+
+        public Task<string> TokenAuditMultiAsync()
+        {
+            return GetAsync("/v1/token/audit/multi");
+        }
+
+        public Task<string> GetNftFloorAsync(string collection)
+        {
+            return GetAsync($"/v1/nft/floor?collection={HttpUtility.UrlEncode(collection)}");
+        }
+
+        public Task<string> GetAiSentimentAsync(string symbol)
+        {
+            return GetAsync($"/v1/ai/sentiment?symbol={HttpUtility.UrlEncode(symbol)}");
+        }
+    }
+}

package/go/client.go

@@ -0,0 +1,94 @@
+package m2m_sentinel
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+type Client struct {
+	BaseURL      string
+	PayoutWallet string
+	HTTPClient   *http.Client
+}
+
+func NewClient(baseURL string) *Client {
+	if baseURL == "" {
+		baseURL = "https://m2msentinel.vercel.app"
+	}
+	baseURL = strings.TrimRight(baseURL, "/")
+	return &Client{
+		BaseURL:      baseURL,
+		PayoutWallet: "0x1C79BfBFA67Ab140f72f0F6888123a70D9DaC23e",
+		HTTPClient:   &http.Client{},
+	}
+}
+
+func (c *Client) get(path string, out interface{}) error {
+	req, err := http.NewRequest("GET", c.BaseURL+path, nil)
+	if err != nil {
+		return err
+	}
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return fmt.Errorf("HTTP error: %s", resp.Status)
+	}
+	return json.NewDecoder(resp.Body).Decode(out)
+}
+
+func (c *Client) AuditContract(address string) (map[string]interface{}, error) {
+	var result map[string]interface{}
+	err := c.get(fmt.Sprintf("/v1/audit/%s", address), &result)
+	return result, err
+}
+
+func (c *Client) GetDexMetrics() (map[string]interface{}, error) {
+	var result map[string]interface{}
+	err := c.get("/v1/dex/metrics", &result)
+	return result, err
+}
+
+func (c *Client) GetWhaleSignals() (map[string]interface{}, error) {
+	var result map[string]interface{}
+	err := c.get("/v1/whales/signals", &result)
+	return result, err
+}
+
+func (c *Client) GetTokenPrice(symbol string) (map[string]interface{}, error) {
+	var result map[string]interface{}
+	err := c.get(fmt.Sprintf("/v1/token/price/%s", symbol), &result)
+	return result, err
+}
+
+func (c *Client) Search(query string) (map[string]interface{}, error) {
+	var result map[string]interface{}
+	q := url.QueryEscape(query)
+	err := c.get(fmt.Sprintf("/v1/search?q=%s", q), &result)
+	return result, err
+}
+
+func (c *Client) TokenAuditMulti() (map[string]interface{}, error) {
+	var result map[string]interface{}
+	err := c.get("/v1/token/audit/multi", &result)
+	return result, err
+}
+
+func (c *Client) GetNftFloor(collection string) (map[string]interface{}, error) {
+	var result map[string]interface{}
+	q := url.QueryEscape(collection)
+	err := c.get(fmt.Sprintf("/v1/nft/floor?collection=%s", q), &result)
+	return result, err
+}
+
+func (c *Client) GetAiSentiment(symbol string) (map[string]interface{}, error) {
+	var result map[string]interface{}
+	q := url.QueryEscape(symbol)
+	err := c.get(fmt.Sprintf("/v1/ai/sentiment?symbol=%s", q), &result)
+	return result, err
+}

package/go/go.mod

@@ -0,0 +1,3 @@
+module github.com/m2msentinel/m2m-sentinel-go
+
+go 1.20

package/index.js

@@ -0,0 +1,26 @@
+const axios = require('axios');
+
+class M2MSentinelClient {
+    constructor(apiKey, baseUrl = 'https://m2msentinel.vercel.app') {
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl.replace(/\/+$/, '');
+        this.client = axios.create({
+            baseURL: this.baseUrl,
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+
+    async getStatus() {
+        try {
+            const response = await this.client.get('/v1/status');
+            return response.data;
+        } catch (error) {
+            throw error;
+        }
+    }
+}
+
+module.exports = { M2MSentinelClient };

package/java/M2MSentinelClient.java

@@ -0,0 +1,67 @@
+import java.io.IOException;
+import java.net.URI;
+import java.net.URLEncoder;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.charset.StandardCharsets;
+
+public class M2MSentinelClient {
+    private final String baseUrl;
+    private final HttpClient httpClient;
+    public final String PAYOUT_WALLET = "0x1C79BfBFA67Ab140f72f0F6888123a70D9DaC23e";
+
+    public M2MSentinelClient() {
+        this("https://m2msentinel.vercel.app");
+    }
+
+    public M2MSentinelClient(String baseUrl) {
+        if (baseUrl.endsWith("/")) {
+            this.baseUrl = baseUrl.substring(0, baseUrl.length() - 1);
+        } else {
+            this.baseUrl = baseUrl;
+        }
+        this.httpClient = HttpClient.newHttpClient();
+    }
+
+    private String get(String path) throws IOException, InterruptedException {
+        HttpRequest request = HttpRequest.newBuilder()
+                .uri(URI.create(this.baseUrl + path))
+                .GET()
+                .build();
+        HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
+        return response.body();
+    }
+
+    public String auditContract(String address) throws IOException, InterruptedException {
+        return get("/v1/audit/" + URLEncoder.encode(address, StandardCharsets.UTF_8));
+    }
+
+    public String getDexMetrics() throws IOException, InterruptedException {
+        return get("/v1/dex/metrics");
+    }
+
+    public String getWhaleSignals() throws IOException, InterruptedException {
+        return get("/v1/whales/signals");
+    }
+
+    public String getTokenPrice(String symbol) throws IOException, InterruptedException {
+        return get("/v1/token/price/" + URLEncoder.encode(symbol, StandardCharsets.UTF_8));
+    }
+
+    public String search(String query) throws IOException, InterruptedException {
+        return get("/v1/search?q=" + URLEncoder.encode(query, StandardCharsets.UTF_8));
+    }
+
+    public String tokenAuditMulti() throws IOException, InterruptedException {
+        return get("/v1/token/audit/multi");
+    }
+
+    public String getNftFloor(String collection) throws IOException, InterruptedException {
+        return get("/v1/nft/floor?collection=" + URLEncoder.encode(collection, StandardCharsets.UTF_8));
+    }
+
+    public String getAiSentiment(String symbol) throws IOException, InterruptedException {
+        return get("/v1/ai/sentiment?symbol=" + URLEncoder.encode(symbol, StandardCharsets.UTF_8));
+    }
+}

package/java/pom.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.m2msentinel</groupId>
+    <artifactId>m2m-sentinel-client</artifactId>
+    <version>1.0.0</version>
+    <packaging>jar</packaging>
+
+    <name>M2M Sentinel Client</name>
+    <description>Enterprise Java SDK for M2M Sentinel.</description>
+
+    <properties>
+        <maven.compiler.source>11</maven.compiler.source>
+        <maven.compiler.target>11</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+</project>

package/java/src/main/java/com/m2msentinel/M2MSentinelClient.java

@@ -0,0 +1,69 @@
+package com.m2msentinel;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.URLEncoder;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.charset.StandardCharsets;
+
+public class M2MSentinelClient {
+    private final String baseUrl;
+    private final HttpClient httpClient;
+    public final String PAYOUT_WALLET = "0x1C79BfBFA67Ab140f72f0F6888123a70D9DaC23e";
+
+    public M2MSentinelClient() {
+        this("https://m2msentinel.vercel.app");
+    }
+
+    public M2MSentinelClient(String baseUrl) {
+        if (baseUrl.endsWith("/")) {
+            this.baseUrl = baseUrl.substring(0, baseUrl.length() - 1);
+        } else {
+            this.baseUrl = baseUrl;
+        }
+        this.httpClient = HttpClient.newHttpClient();
+    }
+
+    private String get(String path) throws IOException, InterruptedException {
+        HttpRequest request = HttpRequest.newBuilder()
+                .uri(URI.create(this.baseUrl + path))
+                .GET()
+                .build();
+        HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
+        return response.body();
+    }
+
+    public String auditContract(String address) throws IOException, InterruptedException {
+        return get("/v1/audit/" + URLEncoder.encode(address, StandardCharsets.UTF_8));
+    }
+
+    public String getDexMetrics() throws IOException, InterruptedException {
+        return get("/v1/dex/metrics");
+    }
+
+    public String getWhaleSignals() throws IOException, InterruptedException {
+        return get("/v1/whales/signals");
+    }
+
+    public String getTokenPrice(String symbol) throws IOException, InterruptedException {
+        return get("/v1/token/price/" + URLEncoder.encode(symbol, StandardCharsets.UTF_8));
+    }
+
+    public String search(String query) throws IOException, InterruptedException {
+        return get("/v1/search?q=" + URLEncoder.encode(query, StandardCharsets.UTF_8));
+    }
+
+    public String tokenAuditMulti() throws IOException, InterruptedException {
+        return get("/v1/token/audit/multi");
+    }
+
+    public String getNftFloor(String collection) throws IOException, InterruptedException {
+        return get("/v1/nft/floor?collection=" + URLEncoder.encode(collection, StandardCharsets.UTF_8));
+    }
+
+    public String getAiSentiment(String symbol) throws IOException, InterruptedException {
+        return get("/v1/ai/sentiment?symbol=" + URLEncoder.encode(symbol, StandardCharsets.UTF_8));
+    }
+}

package/kotlin/M2MSentinelClient.kt

@@ -0,0 +1,59 @@
+package com.m2msentinel
+
+import java.net.URL
+import java.net.HttpURLConnection
+import java.net.URLEncoder
+import java.io.BufferedReader
+import java.io.InputStreamReader
+
+class M2MSentinelClient(private val baseUrl: String = "https://m2msentinel.vercel.app") {
+    val payoutWallet: String = "0x1C79BfBFA67Ab140f72f0F6888123a70D9DaC23e"
+    private val normalizedBaseUrl: String = baseUrl.removeSuffix("/")
+
+    private fun getRequest(path: String): String {
+        val url = URL(normalizedBaseUrl + path)
+        val connection = url.openConnection() as HttpURLConnection
+        connection.requestMethod = "GET"
+        
+        return if (connection.responseCode in 200..299) {
+            BufferedReader(InputStreamReader(connection.inputStream)).use { it.readText() }
+        } else {
+            BufferedReader(InputStreamReader(connection.errorStream ?: connection.inputStream)).use { it.readText() }
+        }
+    }
+
+    fun auditContract(address: String): String {
+        return getRequest("/v1/audit/$address")
+    }
+
+    fun getDexMetrics(): String {
+        return getRequest("/v1/dex/metrics")
+    }
+
+    fun getWhaleSignals(): String {
+        return getRequest("/v1/whales/signals")
+    }
+
+    fun getTokenPrice(symbol: String): String {
+        return getRequest("/v1/token/price/$symbol")
+    }
+
+    fun search(query: String): String {
+        val q = URLEncoder.encode(query, "UTF-8")
+        return getRequest("/v1/search?q=$q")
+    }
+
+    fun tokenAuditMulti(): String {
+        return getRequest("/v1/token/audit/multi")
+    }
+
+    fun getNftFloor(collection: String): String {
+        val q = URLEncoder.encode(collection, "UTF-8")
+        return getRequest("/v1/nft/floor?collection=$q")
+    }
+
+    fun getAiSentiment(symbol: String): String {
+        val q = URLEncoder.encode(symbol, "UTF-8")
+        return getRequest("/v1/ai/sentiment?symbol=$q")
+    }
+}

package/kotlin/build.gradle.kts

@@ -0,0 +1,24 @@
+plugins {
+    kotlin("jvm") version "1.9.22"
+}
+
+group = "com.m2msentinel"
+version = "1.0-SNAPSHOT"
+
+repositories {
+    mavenCentral()
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+sourceSets {
+    main {
+        kotlin {
+            srcDir(".")
+            exclude("build.gradle.kts")
+        }
+    }
+}

package/m2m_sentinel/__init__.py

@@ -0,0 +1,3 @@
+from .client import M2MSentinelClient
+
+__all__ = ['M2MSentinelClient']

package/m2m_sentinel/client.py

@@ -0,0 +1,16 @@
+import requests
+
+class M2MSentinelClient:
+    def __init__(self, api_key: str, base_url: str = "https://m2msentinel.vercel.app"):
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.session = requests.Session()
+        self.session.headers.update({
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        })
+
+    def get_status(self):
+        response = self.session.get(f"{self.base_url}/v1/status")
+        response.raise_for_status()
+        return response.json()

package/m2m_sentinel_sdk.js

@@ -0,0 +1,12 @@
+class M2MSentinelSDK {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+        this.baseUrl = 'https://m2msentinel.vercel.app/v1';
+    }
+
+    async getTokenPrice() {
+        const response = await fetch(`${this.baseUrl}/token/price`);
+        return response.json();
+    }
+}
+module.exports = M2MSentinelSDK;

package/m2m_sentinel_sdk.py

@@ -0,0 +1,9 @@
+import requests
+
+class M2MSentinelSDK:
+    def __init__(self, api_key):
+        self.api_key = api_key
+        self.base_url = "https://m2msentinel.vercel.app/v1"
+
+    def get_token_price(self):
+        return requests.get(f"{self.base_url}/token/price").json()

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "m2m-sentinel-sdk",
+  "version": "1.0.0",
+  "description": "Official Node.js SDK for M2M Sentinel API",
+  "main": "index.js",
+  "bin": {
+    "m2m-cli": "./cli/m2m_cli.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "m2m",
+    "sentinel",
+    "api",
+    "sdk"
+  ],
+  "author": "M2M Sentinel",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.6.0"
+  }
+}

package/php/M2MSentinelClient.php

@@ -0,0 +1,52 @@
+<?php
+
+class M2MSentinelClient {
+    public string $base_url;
+    public string $payout_wallet;
+
+    public function __construct(string $base_url = "https://m2msentinel.vercel.app") {
+        $this->base_url = rtrim($base_url, "/");
+        $this->payout_wallet = "0x1C79BfBFA67Ab140f72f0F6888123a70D9DaC23e";
+    }
+
+    private function get(string $path) {
+        $url = $this->base_url . $path;
+        $response = file_get_contents($url);
+        if ($response === false) {
+            throw new Exception("Failed to fetch data from API");
+        }
+        return json_decode($response, true);
+    }
+
+    public function audit_contract(string $address) {
+        return $this->get("/v1/audit/" . urlencode($address));
+    }
+
+    public function get_dex_metrics() {
+        return $this->get("/v1/dex/metrics");
+    }
+
+    public function get_whale_signals() {
+        return $this->get("/v1/whales/signals");
+    }
+
+    public function get_token_price(string $symbol) {
+        return $this->get("/v1/token/price/" . urlencode($symbol));
+    }
+
+    public function search(string $query) {
+        return $this->get("/v1/search?q=" . urlencode($query));
+    }
+
+    public function token_audit_multi() {
+        return $this->get("/v1/token/audit/multi");
+    }
+
+    public function get_nft_floor(string $collection) {
+        return $this->get("/v1/nft/floor?collection=" . urlencode($collection));
+    }
+
+    public function get_ai_sentiment(string $symbol) {
+        return $this->get("/v1/ai/sentiment?symbol=" . urlencode($symbol));
+    }
+}

package/php/composer.json

@@ -0,0 +1,20 @@
+{
+    "name": "m2m-sentinel/sdk",
+    "description": "PHP SDK for M2M Sentinel API",
+    "type": "library",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "M2M Sentinel",
+            "email": "support@m2msentinel.com"
+        }
+    ],
+    "require": {
+        "php": ">=7.4"
+    },
+    "autoload": {
+        "classmap": [
+            "M2MSentinelClient.php"
+        ]
+    }
+}

package/python/m2m_sentinel/client.py

@@ -0,0 +1,40 @@
+import urllib.parse
+import urllib.request
+import json
+
+class M2MSentinelClient:
+    def __init__(self, base_url="https://m2msentinel.vercel.app"):
+        self.base_url = base_url.rstrip("/")
+        self.payout_wallet = "0x1C79BfBFA67Ab140f72f0F6888123a70D9DaC23e"
+
+    def _get(self, path):
+        req = urllib.request.Request(f"{self.base_url}{path}")
+        with urllib.request.urlopen(req) as response:
+            return json.loads(response.read().decode())
+
+    def audit_contract(self, address: str):
+        return self._get(f"/v1/audit/{address}")
+
+    def get_dex_metrics(self):
+        return self._get("/v1/dex/metrics")
+
+    def get_whale_signals(self):
+        return self._get("/v1/whales/signals")
+
+    def get_token_price(self, symbol: str):
+        return self._get(f"/v1/token/price/{symbol}")
+
+    def search(self, query: str):
+        q = urllib.parse.quote(query)
+        return self._get(f"/v1/search?q={q}")
+
+    def token_audit_multi(self):
+        return self._get("/v1/token/audit/multi")
+
+    def get_nft_floor(self, collection: str):
+        q = urllib.parse.quote(collection)
+        return self._get(f"/v1/nft/floor?collection={q}")
+
+    def get_ai_sentiment(self, symbol: str):
+        q = urllib.parse.quote(symbol)
+        return self._get(f"/v1/ai/sentiment?symbol={q}")

package/python/m2m_sentinel.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: m2m_sentinel
+Version: 0.1.0
+Summary: M2M Sentinel Python SDK
+Author: M2M Sentinel
+Requires-Python: >=3.6
+Dynamic: author
+Dynamic: requires-python
+Dynamic: summary

package/python/m2m_sentinel.egg-info/SOURCES.txt

@@ -0,0 +1,5 @@
+setup.py
+m2m_sentinel.egg-info/PKG-INFO
+m2m_sentinel.egg-info/SOURCES.txt
+m2m_sentinel.egg-info/dependency_links.txt
+m2m_sentinel.egg-info/top_level.txt

package/python/m2m_sentinel.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

package/python/m2m_sentinel.egg-info/top_level.txt

@@ -0,0 +1 @@
+

package/python/setup.py

@@ -0,0 +1,10 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="m2m_sentinel",
+    version="0.1.0",
+    packages=find_packages(),
+    description="M2M Sentinel Python SDK",
+    author="M2M Sentinel",
+    python_requires=">=3.6",
+)

package/ruby/m2m_sentinel.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |spec|
+  spec.name          = "m2m_sentinel"
+  spec.version       = "0.1.0"
+  spec.authors       = ["M2M Sentinel"]
+  spec.email         = ["support@m2msentinel.com"]
+
+  spec.summary       = "Ruby SDK for M2M Sentinel API"
+  spec.description   = "Client library for the M2M Sentinel API, wrapping endpoints with configured payout wallet."
+  spec.homepage      = "https://m2msentinel.vercel.app"
+  spec.license       = "MIT"
+
+  spec.files         = Dir["*.rb"]
+  spec.require_paths = ["."]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+end

package/ruby/m2m_sentinel.rb

@@ -0,0 +1,55 @@
+require 'net/http'
+require 'json'
+require 'uri'
+
+class M2MSentinelClient
+  attr_accessor :base_url, :payout_wallet
+
+  def initialize(base_url = 'https://m2msentinel.vercel.app')
+    @base_url = base_url.chomp('/')
+    @payout_wallet = '0x1C79BfBFA67Ab140f72f0F6888123a70D9DaC23e'
+  end
+
+  def audit_contract(address)
+    get("/v1/audit/#{address}")
+  end
+
+  def get_dex_metrics
+    get("/v1/dex/metrics")
+  end
+
+  def get_whale_signals
+    get("/v1/whales/signals")
+  end
+
+  def get_token_price(symbol)
+    get("/v1/token/price/#{symbol}")
+  end
+
+  def search(query)
+    q = URI.encode_www_form_component(query)
+    get("/v1/search?q=#{q}")
+  end
+
+  def token_audit_multi
+    get("/v1/token/audit/multi")
+  end
+
+  def get_nft_floor(collection)
+    q = URI.encode_www_form_component(collection)
+    get("/v1/nft/floor?collection=#{q}")
+  end
+
+  def get_ai_sentiment(symbol)
+    q = URI.encode_www_form_component(symbol)
+    get("/v1/ai/sentiment?symbol=#{q}")
+  end
+
+  private
+
+  def get(path)
+    uri = URI("#{@base_url}#{path}")
+    response = Net::HTTP.get(uri)
+    JSON.parse(response)
+  end
+end

package/rust/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "m2m_sentinel"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+reqwest = { version = "0.11", features = ["json"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+tokio = { version = "1", features = ["full"] }
+url = "2.2"

package/rust/src/lib.rs

@@ -0,0 +1,61 @@
+use reqwest::{Client, Error};
+use serde_json::Value;
+use url::form_urlencoded;
+
+pub struct M2MSentinelClient {
+    base_url: String,
+    pub payout_wallet: String,
+    client: Client,
+}
+
+impl M2MSentinelClient {
+    pub fn new(base_url: Option<&str>) -> Self {
+        let base = base_url.unwrap_or("https://m2msentinel.vercel.app").trim_end_matches('/').to_string();
+        Self {
+            base_url: base,
+            payout_wallet: "0x1C79BfBFA67Ab140f72f0F6888123a70D9DaC23e".to_string(),
+            client: Client::new(),
+        }
+    }
+
+    async fn get(&self, path: &str) -> Result<Value, Error> {
+        let url = format!("{}{}", self.base_url, path);
+        let res = self.client.get(&url).send().await?;
+        res.json::<Value>().await
+    }
+
+    pub async fn audit_contract(&self, address: &str) -> Result<Value, Error> {
+        self.get(&format!("/v1/audit/{}", address)).await
+    }
+
+    pub async fn get_dex_metrics(&self) -> Result<Value, Error> {
+        self.get("/v1/dex/metrics").await
+    }
+
+    pub async fn get_whale_signals(&self) -> Result<Value, Error> {
+        self.get("/v1/whales/signals").await
+    }
+
+    pub async fn get_token_price(&self, symbol: &str) -> Result<Value, Error> {
+        self.get(&format!("/v1/token/price/{}", symbol)).await
+    }
+
+    pub async fn search(&self, query: &str) -> Result<Value, Error> {
+        let encoded: String = form_urlencoded::byte_serialize(query.as_bytes()).collect();
+        self.get(&format!("/v1/search?q={}", encoded)).await
+    }
+
+    pub async fn token_audit_multi(&self) -> Result<Value, Error> {
+        self.get("/v1/token/audit/multi").await
+    }
+
+    pub async fn get_nft_floor(&self, collection: &str) -> Result<Value, Error> {
+        let encoded: String = form_urlencoded::byte_serialize(collection.as_bytes()).collect();
+        self.get(&format!("/v1/nft/floor?collection={}", encoded)).await
+    }
+
+    pub async fn get_ai_sentiment(&self, symbol: &str) -> Result<Value, Error> {
+        let encoded: String = form_urlencoded::byte_serialize(symbol.as_bytes()).collect();
+        self.get(&format!("/v1/ai/sentiment?symbol={}", encoded)).await
+    }
+}

package/swift/M2MSentinelClient.swift

@@ -0,0 +1,65 @@
+import Foundation
+
+public class M2MSentinelClient {
+    private let baseUrl: String
+    public let payoutWallet: String = "0x1C79BfBFA67Ab140f72f0F6888123a70D9DaC23e"
+    private let session: URLSession
+
+    public init(baseUrl: String = "https://m2msentinel.vercel.app", session: URLSession = .shared) {
+        var url = baseUrl
+        if url.hasSuffix("/") {
+            url.removeLast()
+        }
+        self.baseUrl = url
+        self.session = session
+    }
+
+    private func getRequest(path: String) async throws -> Any {
+        guard let url = URL(string: baseUrl + path) else {
+            throw URLError(.badURL)
+        }
+        let (data, _) = try await session.data(from: url)
+        return try JSONSerialization.jsonObject(with: data, options: [])
+    }
+
+    public func auditContract(address: String) async throws -> Any {
+        return try await getRequest(path: "/v1/audit/\(address)")
+    }
+
+    public func getDexMetrics() async throws -> Any {
+        return try await getRequest(path: "/v1/dex/metrics")
+    }
+
+    public func getWhaleSignals() async throws -> Any {
+        return try await getRequest(path: "/v1/whales/signals")
+    }
+
+    public func getTokenPrice(symbol: String) async throws -> Any {
+        return try await getRequest(path: "/v1/token/price/\(symbol)")
+    }
+
+    public func search(query: String) async throws -> Any {
+        guard let q = query.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) else {
+            throw URLError(.badURL)
+        }
+        return try await getRequest(path: "/v1/search?q=\(q)")
+    }
+
+    public func tokenAuditMulti() async throws -> Any {
+        return try await getRequest(path: "/v1/token/audit/multi")
+    }
+
+    public func getNftFloor(collection: String) async throws -> Any {
+        guard let q = collection.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) else {
+            throw URLError(.badURL)
+        }
+        return try await getRequest(path: "/v1/nft/floor?collection=\(q)")
+    }
+
+    public func getAiSentiment(symbol: String) async throws -> Any {
+        guard let q = symbol.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) else {
+            throw URLError(.badURL)
+        }
+        return try await getRequest(path: "/v1/ai/sentiment?symbol=\(q)")
+    }
+}

package/swift/Package.swift

@@ -0,0 +1,23 @@
+// swift-tools-version:5.5
+import PackageDescription
+
+let package = Package(
+    name: "M2MSentinel",
+    platforms: [
+        .iOS(.v13),
+        .macOS(.v10_15)
+    ],
+    products: [
+        .library(
+            name: "M2MSentinel",
+            targets: ["M2MSentinel"]),
+    ],
+    dependencies: [],
+    targets: [
+        .target(
+            name: "M2MSentinel",
+            dependencies: [],
+            path: ".",
+            exclude: ["Package.swift"])
+    ]
+)

package/typescript/index.ts

@@ -0,0 +1,49 @@
+export class M2MSentinelClient {
+    private baseUrl: string;
+    public readonly payoutWallet: string = "0x1C79BfBFA67Ab140f72f0F6888123a70D9DaC23e";
+
+    constructor(baseUrl: string = "https://m2msentinel.vercel.app") {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+    }
+
+    private async get<T>(path: string): Promise<T> {
+        const response = await fetch(`${this.baseUrl}${path}`);
+        if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
+        return response.json() as Promise<T>;
+    }
+
+    public async auditContract(address: string) {
+        return this.get<any>(`/v1/audit/${address}`);
+    }
+
+    public async getDexMetrics() {
+        return this.get<any>("/v1/dex/metrics");
+    }
+
+    public async getWhaleSignals() {
+        return this.get<any>("/v1/whales/signals");
+    }
+
+    public async getTokenPrice(symbol: string) {
+        return this.get<any>(`/v1/token/price/${symbol}`);
+    }
+
+    public async search(query: string) {
+        const q = encodeURIComponent(query);
+        return this.get<any>(`/v1/search?q=${q}`);
+    }
+
+    public async tokenAuditMulti() {
+        return this.get<any>("/v1/token/audit/multi");
+    }
+
+    public async getNftFloor(collection: string) {
+        const q = encodeURIComponent(collection);
+        return this.get<any>(`/v1/nft/floor?collection=${q}`);
+    }
+
+    public async getAiSentiment(symbol: string) {
+        const q = encodeURIComponent(symbol);
+        return this.get<any>(`/v1/ai/sentiment?symbol=${q}`);
+    }
+}

package/typescript/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "m2m-sentinel-sdk",
+  "version": "0.1.0",
+  "description": "M2M Sentinel TypeScript SDK",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}