[RELEASE] 0.6.0

backend/app/modules/common/synchronized.py

@@ -0,0 +1,14 @@
+from threading import Lock
+from functools import wraps
+from typing import Callable
+
+
+def synchronized(wrapped: Callable):
+ lock = Lock()
+
+ @wraps(wrapped)
+ def _wrap(*args, **kwargs):
+ with lock:
+ return wrapped(*args, **kwargs)
+
+ return _wrap

backend/app/modules/facades/confirm_multisig.py

@@ -7,8 +7,10 @@
 )
 from app.modules.user.allocations import controller as allocations_controller
 from app.modules.user.tos import controller as tos_controller
+from app.modules.common.synchronized import synchronized
 
 
+@synchronized
 def confirm_multisig():
  """
  This is a facade function that is used to confirm (i.e approve and apply) multisig approvals.

backend/app/modules/multisig_signatures/service/offchain.py

@@ -1,13 +1,13 @@
-from typing import List
+from typing import List, Dict
 
 from app.context.manager import Context
 from app.exceptions import InvalidMultisigSignatureRequest, InvalidMultisigAddress
 from app.extensions import db
 from app.infrastructure import database
 from app.infrastructure.database.models import MultisigSignatures
 from app.infrastructure.database.multisig_signature import SigStatus, MultisigFilters
-
 from app.infrastructure.external_api.common import retry_request
+from app.infrastructure.external_api.safe.message_details import get_message_details
 from app.modules.common.allocations.deserializer import deserialize_payload
 from app.modules.common.crypto.eip1271 import get_message_hash
 from app.modules.common.crypto.signature import (
@@ -23,16 +23,13 @@
 )
 from app.modules.multisig_signatures.dto import Signature
 from app.pydantic import Model
-from app.infrastructure.external_api.safe.message_details import get_message_details
 
 
 class OffchainMultisigSignatures(Model):
  is_mainnet: bool = False
- verifiers: dict[SignatureOpType, Verifier]
+ verifiers: Dict[SignatureOpType, Verifier]
 
- staged_signatures: list[
- MultisigSignatures
- ] = [] # TODO make it invulnerable for data race & race conditions
+ staged_signatures: List[MultisigSignatures] = []
 
  def get_last_pending_signature(
  self, _: Context, user_address: str, op_type: SignatureOpType

epoch-verifier/src/_deprecated/epoch3/data/context.ts

@@ -0,0 +1,63 @@
+import {
+ Address,
+ Allocation,
+ AllocationRecord,
+ EpochInfo,
+ Reward,
+ UserBudget,
+ UserDonation
+} from "./models"
+
+export interface Context {
+ allocations: Allocation[]
+ budgets: Map<Address, bigint>
+ epochInfo: EpochInfo
+ rewards: Reward[]
+}
+
+function transformToAllocations(allocationRecords: AllocationRecord[]): Allocation[] {
+ const allocations: Map<Address, Allocation> = new Map()
+
+ for (const record of allocationRecords) {
+ const prev = allocations.get(record.user) ?? { donations: [], user: record.user }
+ prev.donations.push({ amount: record.amount, proposal: record.proposal })
+ allocations.set(record.user, prev)
+ }
+
+ return Array.from(allocations.values())
+}
+
+export function buildContext(userBudgets: UserBudget[], allocations: AllocationRecord[], rewards: Reward[], epochInfo: EpochInfo): Context {
+
+ const positiveUserBudgets = userBudgets.filter(positiveUserBudget => positiveUserBudget.amount !== BigInt(0));
+
+ return {
+ allocations: transformToAllocations(allocations),
+ budgets: new Map(positiveUserBudgets.map(value => [value.user, value.amount] as const)),
+ epochInfo,
+ rewards
+ }
+}
+
+export function allocationsByUser(context: Context): Map<Address, UserDonation[]> {
+ return new Map(context.allocations.map((alloc) => [alloc.user, alloc.donations] as const))
+}
+
+export function individualDonationsByProjects(context: Context): Map<Address, bigint> {
+ const individualDonations: Map<Address, bigint> = new Map()
+ const donations: UserDonation[] = context.allocations.flatMap((alloc) => alloc.donations)
+
+ for (const donation of donations) {
+ const prev = individualDonations.get(donation.proposal) ?? BigInt(0)
+ individualDonations.set(donation.proposal, prev + donation.amount)
+ }
+
+ return individualDonations
+}
+
+export function rewardsByProject(context: Context): Map<Address, Reward> {
+ return new Map(context.rewards
+ .filter(r => r.matched !== BigInt(0))
+ .map((r) => [r.proposal, r] as const)
+ );
+}

epoch-verifier/src/_deprecated/epoch3/data/fetcher.ts

@@ -0,0 +1,70 @@
+/* eslint-disable no-console */
+import { Axios } from "axios"
+
+import {
+ AllocationImpl,
+ Deserializable,
+ EpochInfo,
+ EpochInfoImpl,
+ RewardImpl,
+ Reward,
+ UserBudgetImpl,
+ UserBudget,
+ AllocationRecord,
+ ApiRewardsBudgets, ApiAllocations, ApiRewards,
+} from "./models";
+
+const REQUEST_TIMEOUT = 150_000;
+
+export class HttpFetcher {
+ readonly axios: Axios
+
+ constructor(baseUrl: string) {
+ this.axios = new Axios({ baseURL: baseUrl, timeout: REQUEST_TIMEOUT })
+ }
+
+ async _get<T>(url: string, resource: string, Factory: { new(): Deserializable<T> }): Promise<T | null> {
+ const mapper = (data: any): T => new Factory().from(JSON.parse(data))
+ return this._do_get(url, resource, mapper)
+ }
+
+ async _get_array<T>(url: string, resource: string, Factory: { new(): Deserializable<T> }, unwrapper?: (data: any) => any): Promise<Array<T> | null> {
+
+ const dataUnwrapper = unwrapper ?? ((data: any) => data)
+
+ const mapper = (data: any): Array<T> => dataUnwrapper(JSON.parse(data)).map((elem: any): T => new Factory().from(elem))
+ return this._do_get(url, resource, mapper)
+ }
+
+ async _do_get<T>(url: string, resource: string, mapper: (data: any) => T): Promise<T | null> {
+
+ return this.axios.get(url).then(response => {
+ if (response.status !== 200) {
+ throw new Error(response.data)
+ }
+ console.log(`✅ Fetched ${resource} ${response.data}`)
+ return mapper(response.data)
+
+ }).catch(reason => {
+ console.error(`❗ Failed to fetch ${resource} due to: ${reason}`)
+ return null
+ })
+ }
+
+
+ async apiGetUserBudgets(epoch: number): Promise<UserBudget[] | null> {
+ return this._get_array(`/rewards/budgets/epoch/${epoch}`, "users' budgets", UserBudgetImpl, (data: ApiRewardsBudgets) => data.budgets)
+ }
+
+ async apiGetAllocations(epoch: number): Promise<AllocationRecord[] | null> {
+ return this._get_array(`/allocations/epoch/${epoch}?includeZeroAllocations=true`, "users' allocations", AllocationImpl, (data: ApiAllocations) => data.allocations)
+ }
+
+ async apiGetRewards(epoch: number): Promise<Reward[] | null> {
+ return this._get_array(`/rewards/projects/epoch/${epoch}`, "projects rewards", RewardImpl, (data: ApiRewards) => data.rewards)
+ }
+
+ async apiGetEpochInfo(epoch: number): Promise<EpochInfo | null> {
+ return this._get(`/epochs/info/${epoch}`, "epoch info", EpochInfoImpl)
+ }
+}

epoch-verifier/src/_deprecated/epoch3/data/models.ts

@@ -0,0 +1,158 @@
+/* eslint-disable max-classes-per-file */
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+export type Address = string;
+
+export interface Deserializable<T> {
+ from(input: any): T;
+}
+
+export interface ApiRewardsBudgets {
+ budgets: {
+ address: string;
+ amount: string; // wei;
+ }[];
+}
+
+export interface ApiAllocations {
+ allocations: {
+ amount: string; // wei
+ donor: string;
+ proposal: string;
+ }[];
+}
+
+export interface ApiRewards {
+ rewards: {
+ address: string;
+ value: string; // wei;
+ }[];
+}
+
+
+export interface UserBudget {
+ amount: bigint;
+ user: Address;
+}
+
+export interface UserDonation {
+ amount: bigint;
+ proposal: Address;
+}
+
+export interface AllocationRecord {
+ amount: bigint;
+ proposal: Address;
+ user: Address;
+}
+
+export interface Allocation {
+ donations: UserDonation[];
+ user: Address;
+}
+
+export interface Reward {
+ allocated: bigint;
+ matched: bigint;
+ proposal: Address;
+}
+
+export interface EpochInfo {
+ communityFund: bigint;
+ individualRewards: bigint;
+ leftover: bigint;
+ matchedRewards: bigint;
+ operationalCost: bigint;
+ patronsRewards: bigint;
+ ppf: bigint;
+ stakingProceeds: bigint;
+ totalEffectiveDeposit: bigint;
+ totalRewards: bigint;
+ totalWithdrawals: bigint;
+}
+
+export class UserBudgetImpl implements Deserializable<UserBudget> {
+ user: Address;
+
+ amount: bigint;
+
+ from(input: any) {
+ this.user = input.address;
+ this.amount = BigInt(input.amount)
+
+ return this
+ }
+}
+
+export class AllocationImpl implements Deserializable<AllocationRecord> {
+ user: Address;
+
+ proposal: Address;
+
+ amount: bigint;
+
+ from(input: any) {
+ this.user = input.donor
+ this.proposal = input.proposal;
+ this.amount = BigInt(input.amount ?? 0)
+
+ return this
+ }
+}
+
+export class RewardImpl implements Deserializable<Reward> {
+ allocated: bigint;
+
+ matched: bigint;
+
+ proposal: Address;
+
+ from(input: any) {
+ this.proposal = input.address
+ this.allocated = BigInt(input.allocated)
+ this.matched = BigInt(input.matched)
+
+ return this
+ }
+}
+
+export class EpochInfoImpl implements Deserializable<EpochInfo> {
+ individualRewards: bigint;
+
+ matchedRewards: bigint;
+
+ patronsRewards: bigint;
+
+ stakingProceeds: bigint;
+
+ totalEffectiveDeposit: bigint;
+
+ totalRewards: bigint;
+
+ totalWithdrawals: bigint;
+
+ operationalCost: bigint;
+
+ leftover: bigint;
+
+ ppf: bigint;
+
+ communityFund: bigint;
+
+
+ from(input: any) {
+ this.individualRewards = BigInt(input.vanillaIndividualRewards)
+ this.matchedRewards = BigInt(input.matchedRewards)
+ this.patronsRewards = BigInt(input.patronsRewards)
+ this.stakingProceeds = BigInt(input.stakingProceeds)
+ this.totalEffectiveDeposit = BigInt(input.totalEffectiveDeposit)
+ this.totalRewards = BigInt(input.totalRewards)
+ this.totalWithdrawals = BigInt(input.totalWithdrawals)
+ this.operationalCost = BigInt(input.operationalCost)
+ this.leftover = BigInt(input.leftover)
+ this.ppf = BigInt(input.ppf)
+ this.communityFund = BigInt(input.communityFund)
+
+ return this
+ }
+}
+