Merge pull request #15 from ar-io/add-observation

feat(gar): add observations

contract/spec/token_spec.lua

@@ -31,7 +31,6 @@ describe("vaults", function()
         local reply, err = token.createVault("Bob", testSettings.testTransferQuantity, constants.MIN_TOKEN_LOCK_TIME,
             startTimestamp,
             "msgId")
-        print(err)
         assert.are.same(reply, {
             balance = testSettings.testTransferQuantity,
             startTimestamp = startTimestamp,

contract/src/base64.lua

@@ -0,0 +1,205 @@
+--[[
+
+ base64 -- v1.5.3 public domain Lua base64 encoder/decoder
+ no warranty implied; use at your own risk
+
+ Needs bit32.extract function. If not present it's implemented using BitOp
+ or Lua 5.3 native bit operators. For Lua 5.1 fallbacks to pure Lua
+ implementation inspired by Rici Lake's post:
+   http://ricilake.blogspot.co.uk/2007/10/iterating-bits-in-lua.html
+
+ author: Ilya Kolbin ([email protected])
+ url: github.com/iskolbin/lbase64
+
+ COMPATIBILITY
+
+ Lua 5.1+, LuaJIT
+
+ LICENSE
+
+ See end of file for license information.
+
+--]]
+
+
+local base64 = {}
+
+local extract = _G.bit32 and _G.bit32.extract -- Lua 5.2/Lua 5.3 in compatibility mode
+if not extract then
+    if _G.bit then                            -- LuaJIT
+        local shl, shr, band = _G.bit.lshift, _G.bit.rshift, _G.bit.band
+        extract = function(v, from, width)
+            return band(shr(v, from), shl(1, width) - 1)
+        end
+    elseif _G._VERSION == "Lua 5.1" then
+        extract = function(v, from, width)
+            local w = 0
+            local flag = 2 ^ from
+            for i = 0, width - 1 do
+                local flag2 = flag + flag
+                if v % flag2 >= flag then
+                    w = w + 2 ^ i
+                end
+                flag = flag2
+            end
+            return w
+        end
+    else -- Lua 5.3+
+        extract = load [[return function( v, from, width )
+			return ( v >> from ) & ((1 << width) - 1)
+		end]]()
+    end
+end
+
+
+function base64.makeencoder(s62, s63, spad)
+    local encoder = {}
+    for b64code, char in pairs { [0] = 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
+        'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y',
+        'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+        'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2',
+        '3', '4', '5', '6', '7', '8', '9', s62 or '+', s63 or '/', spad or '=' } do
+        encoder[b64code] = char:byte()
+    end
+    return encoder
+end
+
+function base64.makedecoder(s62, s63, spad)
+    local decoder = {}
+    for b64code, charcode in pairs(base64.makeencoder(s62, s63, spad)) do
+        decoder[charcode] = b64code
+    end
+    return decoder
+end
+
+local DEFAULT_ENCODER = base64.makeencoder()
+local DEFAULT_DECODER = base64.makedecoder()
+
+local char, concat = string.char, table.concat
+
+function base64.encode(str, encoder, usecaching)
+    encoder = encoder or DEFAULT_ENCODER
+    local t, k, n = {}, 1, #str
+    local lastn = n % 3
+    local cache = {}
+    for i = 1, n - lastn, 3 do
+        local a, b, c = str:byte(i, i + 2)
+        local v = a * 0x10000 + b * 0x100 + c
+        local s
+        if usecaching then
+            s = cache[v]
+            if not s then
+                s = char(encoder[extract(v, 18, 6)], encoder[extract(v, 12, 6)], encoder[extract(v, 6, 6)],
+                    encoder[extract(v, 0, 6)])
+                cache[v] = s
+            end
+        else
+            s = char(encoder[extract(v, 18, 6)], encoder[extract(v, 12, 6)], encoder[extract(v, 6, 6)],
+                encoder[extract(v, 0, 6)])
+        end
+        t[k] = s
+        k = k + 1
+    end
+    if lastn == 2 then
+        local a, b = str:byte(n - 1, n)
+        local v = a * 0x10000 + b * 0x100
+        t[k] = char(encoder[extract(v, 18, 6)], encoder[extract(v, 12, 6)], encoder[extract(v, 6, 6)], encoder[64])
+    elseif lastn == 1 then
+        local v = str:byte(n) * 0x10000
+        t[k] = char(encoder[extract(v, 18, 6)], encoder[extract(v, 12, 6)], encoder[64], encoder[64])
+    end
+    return concat(t)
+end
+
+function base64.decode(b64, decoder, usecaching)
+    decoder = decoder or DEFAULT_DECODER
+    local pattern = '[^%w%+%/%=]'
+    if decoder then
+        local s62, s63
+        for charcode, b64code in pairs(decoder) do
+            if b64code == 62 then
+                s62 = charcode
+            elseif b64code == 63 then
+                s63 = charcode
+            end
+        end
+        pattern = ('[^%%w%%%s%%%s%%=]'):format(char(s62), char(s63))
+    end
+    b64 = b64:gsub(pattern, '')
+    local cache = usecaching and {}
+    local t, k = {}, 1
+    local n = #b64
+    local padding = b64:sub(-2) == '==' and 2 or b64:sub(-1) == '=' and 1 or 0
+    for i = 1, padding > 0 and n - 4 or n, 4 do
+        local a, b, c, d = b64:byte(i, i + 3)
+        local s
+        if usecaching then
+            local v0 = a * 0x1000000 + b * 0x10000 + c * 0x100 + d
+            s = cache[v0]
+            if not s then
+                local v = decoder[a] * 0x40000 + decoder[b] * 0x1000 + decoder[c] * 0x40 + decoder[d]
+                s = char(extract(v, 16, 8), extract(v, 8, 8), extract(v, 0, 8))
+                cache[v0] = s
+            end
+        else
+            local v = decoder[a] * 0x40000 + decoder[b] * 0x1000 + decoder[c] * 0x40 + decoder[d]
+            s = char(extract(v, 16, 8), extract(v, 8, 8), extract(v, 0, 8))
+        end
+        t[k] = s
+        k = k + 1
+    end
+    if padding == 1 then
+        local a, b, c = b64:byte(n - 3, n - 1)
+        local v = decoder[a] * 0x40000 + decoder[b] * 0x1000 + decoder[c] * 0x40
+        t[k] = char(extract(v, 16, 8), extract(v, 8, 8))
+    elseif padding == 2 then
+        local a, b = b64:byte(n - 3, n - 2)
+        local v = decoder[a] * 0x40000 + decoder[b] * 0x1000
+        t[k] = char(extract(v, 16, 8))
+    end
+    return concat(t)
+end
+
+return base64
+
+--[[
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2018 Ilya Kolbin
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+--]]

contract/src/constants.lua

@@ -1,5 +1,14 @@
 local constants = {}
 
+-- OIP
+constants.epochTimeLength = 24 * 60 * 60 * 1000     -- One day of miliseconds
+constants.epochZeroStartTimestamp = 0
+constants.EPOCH_DISTRIBUTION_DELAY = 30 * 60 * 1000 -- 30 minutes of miliseconds
+constants.TENURE_WEIGHT_DAYS = 180
+constants.TENURE_WEIGHT_PERIOD = constants.TENURE_WEIGHT_DAYS * 24 * 60 * 60 * 1000
+constants.MAX_TENURE_WEIGHT = 4
+constants.MAXIMUM_OBSERVERS_PER_EPOCH = 50
+
 -- GAR
 constants.DEFAULT_UNDERNAME_COUNT = 10
 constants.DEADLINE_DURATION_MS = 60 * 60 * 1000 -- One hour of miliseconds
@@ -17,6 +26,7 @@ constants.GATEWAY_REGISTRY_SETTINGS = {
 	operatorStakeWithdrawLength = 30 * 24 * 60 * 60 * 1000, -- 30 days
 	delegatedStakeWithdrawLength = 30 * 24 * 60 * 60 * 1000, -- 30 days
 }
+constants.NETWORK_JOIN_STATUS = 'joined'
 
 -- ARNS
 constants.DEFAULT_UNDERNAME_COUNT = 10

contract/src/crypto/cipher/aes.lua

@@ -0,0 +1,142 @@
+local Stream = require(".crypto.util.stream")
+local Hex = require(".crypto.util.hex")
+local Array = require(".crypto.util.array")
+
+-- Ciphers
+local AES128Cipher = require(".crypto.cipher.aes128")
+local AES192Cipher = require(".crypto.cipher.aes192")
+local AES256Cipher = require(".crypto.cipher.aes256")
+
+-- Modes
+local CBCMode = require(".crypto.cipher.mode.cbc")
+local ECBMode = require(".crypto.cipher.mode.ecb")
+local CFBMode = require(".crypto.cipher.mode.cfb")
+local OFBMode = require(".crypto.cipher.mode.ofb")
+local CTRMode = require(".crypto.cipher.mode.ctr")
+
+-- Padding
+local ZeroPadding = require(".crypto.padding.zero")
+
+local public = {}
+
+local getBlockCipher = function(keyLength)
+    if keyLength == 128 then
+        return AES128Cipher
+    elseif keyLength == 192 then
+        return AES192Cipher
+    elseif keyLength == 256 then
+        return AES256Cipher
+    elseif keyLength == nil then
+        return AES128Cipher
+    else
+        return nil
+    end
+end
+
+local getMode = function(mode)
+    if mode == "CBC" then
+        return CBCMode
+    elseif mode == "ECB" then
+        return ECBMode
+    elseif mode == "CFB" then
+        return CFBMode
+    elseif mode == "OFB" then
+        return OFBMode
+    elseif mode == "CTR" then
+        return CTRMode
+    else
+        return nil
+    end
+end
+
+
+--- Encrypts the given data using AES encryption.
+--- @param data string - The data to be encrypted.
+--- @param key string - The key to use for encryption.
+--- @param iv? string (optional) - The initialization vector to use for encryption. Defaults to 16 null bytes.
+--- @param mode? string (optional) - The mode to use for encryption. Defaults to "CBC".
+--- @param keyLength? number (optional) - The length of the key to use for encryption. Defaults to 128.
+--- @returns table - A table containing the encrypted data in bytes, hex, and string formats.
+public.encrypt = function(data, key, iv, mode, keyLength)
+    local d = Array.fromString(data)
+    local k = Array.fromString(key)
+    local _iv = iv ~= nil and Array.fromString(iv) or Array.fromHex("00000000000000000000000000000000")
+
+    local cipherMode = getMode(mode) or CBCMode
+    local blockCipher = getBlockCipher(keyLength) or AES128Cipher
+
+    local cipher = cipherMode.Cipher()
+        .setKey(k)
+        .setBlockCipher(blockCipher)
+        .setPadding(ZeroPadding);
+
+
+    local cipherOutput = cipher
+        .init()
+        .update(Stream.fromArray(_iv))
+        .update(Stream.fromArray(d))
+        .finish()
+
+    local results = {}
+
+    results.asBytes = function()
+        return cipherOutput.asBytes()
+    end
+
+    results.asHex = function()
+        return cipherOutput.asHex()
+    end
+
+    results.asString = function()
+        return cipherOutput.asString()
+    end
+
+    return results
+end
+
+--- Decrypts the given data using AES decryption.
+--- @param cipher string - The hex encoded cipher to be decrypted.
+--- @param key string - The key to use for decryption.
+--- @param iv? string (optional) - The initialization vector to use for decryption. Defaults to 16 null bytes.
+--- @param mode? string (optional) - The mode to use for decryption. Defaults to "CBC".
+--- @param keyLength? number (optional) - The length of the key to use for decryption. Defaults to 128.
+public.decrypt = function(cipher, key, iv, mode, keyLength)
+    local cipherText = Array.fromHex(cipher)
+    local k = Array.fromString(key)
+    local _iv = iv ~= nil and Array.fromString(iv) or Array.fromHex("00000000000000000000000000000000")
+
+    local cipherMode = getMode(mode) or CBCMode
+    local blockCipher = getBlockCipher(keyLength) or AES128Cipher
+
+
+    local decipher = cipherMode.Decipher()
+            .setKey(k)
+            .setBlockCipher(blockCipher)
+            .setPadding(ZeroPadding);
+
+
+    local plainOutput = decipher
+        .init()
+        .update(Stream.fromArray(_iv))
+        .update(Stream.fromArray(cipherText))
+        .finish()
+
+    local results = {}
+
+    results.asBytes = function()
+        return plainOutput.asBytes()
+    end
+
+    results.asHex = function()
+        return plainOutput.asHex()
+    end
+
+    results.asString = function()
+        return plainOutput.asString()
+    end
+
+    return results
+end
+
+
+return public