@massalabs/multisig-contract 0.0.2-dev.20260414091108

package/assembly/libraries/PersistentMap.ts

@@ -0,0 +1,307 @@
+import {
+  bytesToF64,
+  bytesToU64,
+  bytesToString,
+  byteToBool,
+  stringToBytes,
+  u64ToBytes,
+  f64ToBytes,
+  u256ToBytes,
+  boolToByte,
+  Args,
+} from '@massalabs/as-types';
+import { Storage } from '@massalabs/massa-as-sdk';
+import { Serializable } from '@massalabs/as-types';
+import { u256 } from 'as-bignum/assembly/integer/u256';
+
+export const _KEY_ELEMENT_SUFFIX = '::';
+
+/**
+ * This class is one of several convenience collections built on top of the `Storage` class
+ * It implements a map -- a persistent unordered map.
+ *
+ * To create a map
+ *
+ * ```ts
+ * let map = new PersistentMap<string, string>("m")  // choose a unique prefix per account
+ * ```
+ *
+ * To use the map
+ *
+ * ```ts
+ * map.set(key, value)
+ * map.get(key)
+ * ```
+ *
+ * IMPORTANT NOTES:
+ *
+ * (1) The Map doesn't store keys, so if you need to retrieve them, include keys in the values.
+ *
+ * (2) Since all data stored on the blockchain is kept in a single key-value store under the contract account,
+ * you must always use a *unique storage prefix* for different collections to avoid data collision.
+ *
+ * @typeParam K - The generic type parameter `K` can be any valid AssemblyScript type.
+ * @typeParam V - The generic type parameter `V` can be any valid AssemblyScript type.
+ *
+ * MISC:
+ *
+ * Original from Near (https://github.com/near/near-sdk-as/blob/master/sdk-core/assembly/collections/persistentMap.ts)
+ */
+export class PersistentMap<K, V> {
+  private _elementPrefix: string;
+
+  /**
+   * Creates or restores a persistent map with a given storage prefix.
+   * Always use a unique storage prefix for different collections.
+   *
+   * Example
+   *
+   * ```ts
+   * let map = new PersistentMap<string, string>("m") // note the prefix must be unique (per MASSA account)
+   * ```
+   * @param prefix - A prefix to use for every key of this map.
+   */
+  constructor(prefix: string) {
+    this._elementPrefix = prefix + _KEY_ELEMENT_SUFFIX;
+  }
+
+  /**
+   * @param key - Search key.
+   * @returns An internal string key for a given key of type K.
+   */
+  private _key(key: K): StaticArray<u8> {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return stringToBytes(this._elementPrefix + key.toString());
+  }
+
+  private _keySize(): StaticArray<u8> {
+    return stringToBytes('size::' + this._elementPrefix);
+  }
+
+  /**
+   * Checks whether the map contains a given key
+   *
+   * ```ts
+   * let map = new PersistentMap<string, string>("m")
+   *
+   * map.contains("hello")      // false
+   * map.set("hello", "world")
+   * map.contains("hello")      // true
+   * ```
+   *
+   * @param key - Key to check.
+   * @returns True if the given key present in the map.
+   */
+  contains(key: K): bool {
+    return Storage.has(this._key(key));
+  }
+
+  /**
+   * Returns the map size
+   *
+   * @example
+   * ```ts
+   * let map = new PersistentMap<string, string> ("m")
+   *
+   * map.size()
+   * ```
+   * @returns the map size
+   */
+  size(): u64 {
+    return Storage.has(this._keySize())
+      ? bytesToU64(Storage.get(this._keySize()))
+      : u64(0);
+  }
+
+  /**
+   * Removes the given key and related value from the map
+   *
+   * ```ts
+   * let map = new PersistentMap<string, string>("m")
+   *
+   * map.set("hello", "world")
+   * map.delete("hello")
+   * ```
+   *
+   * Removes value and the key from the map.
+   * @param key - Key to remove.
+   */
+  delete(key: K): void {
+    Storage.del(this._key(key));
+    this._decreaseSize();
+  }
+
+  /**
+   * Increases the internal map size counter
+   * @param key - Key to remove.
+   */
+  _increaseSize(key: K): void {
+    if (!this.contains(key)) {
+      Storage.set(this._keySize(), u64ToBytes(this.size() + 1));
+    }
+  }
+
+  /**
+   * Decreases the internal map size counter
+   */
+  _decreaseSize(): void {
+    if (this.size() > 0) {
+      Storage.set(this._keySize(), u64ToBytes(this.size() - 1));
+    }
+  }
+
+  /**
+   * Retrieves the related value for a given key, or uses the `defaultValue` if not key is found
+   *
+   * ```ts
+   * let map = new PersistentMap<string, string>("m")
+   *
+   * map.set("hello", "world")
+   * let found = map.get("hello")
+   * let notFound = map.get("goodbye", "cruel world")
+   *
+   * assert(found == "world")
+   * assert(notFound == "cruel world")
+   * ```
+   *
+   * @param key - Key of the element.
+   * @param defaultValue - The default value if the key is not present.
+   * @returns Value for the given key or the default value.
+   */
+  get(key: K, defaultValue: V): V {
+    if (!this.contains(key)) {
+      return defaultValue;
+    }
+    if (isString<V>()) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      return bytesToString(Storage.get(this._key(key)));
+    } else if (isBoolean<V>()) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      return byteToBool(Storage.get(this._key(key)));
+    } else if (isInteger<V>()) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      return bytesToU64(Storage.get(this._key(key)));
+    } else if (isFloat<V>()) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      return bytesToF64(Storage.get(this._key(key)));
+    } else if (idof<V>() == idof<StaticArray<u8>>()) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      return Storage.get(this._key(key));
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+    } else if (defaultValue instanceof Serializable) {
+      return (
+        new Args(Storage.get(this._key(key)))
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          .nextSerializable<V>()
+          .unwrap()
+      );
+    } else if (defaultValue instanceof u256) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      return new Args(Storage.get(this._key(key))).nextU256().unwrap();
+    } else {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      return null;
+    }
+  }
+
+  /**
+   * Retrieves a related value for a given key or fails assertion with "key not found"
+   *
+   * ```ts
+   * let map = new PersistentMap<string, string>("m")
+   *
+   * map.set("hello", "world")
+   * let result = map.getSome("hello")
+   * // map.getSome("goodbye")  // will throw with failed assertion
+   *
+   * assert(result == "world")
+   * ```
+   *
+   * @param key - Key of the element.
+   * @returns Value for the given key or the default value.
+   */
+  // eslint-disable-next-line
+  getSome(key: K, msg: string = 'key not found'): V {
+    assert(this.contains(key), msg);
+
+    if (isBoolean<V>()) {
+      const res = this.get(key, false as V);
+      return <V>res;
+    }
+
+    if (isInteger<V>()) {
+      const res = this.get(key, 1 as V);
+      return <V>res;
+    }
+    if (idof<V>() == idof<StaticArray<u8>>()) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      const res = this.get(key, [] as V);
+      assert(res, 'bad result');
+      return <V>res;
+    }
+
+    const isSerializable = !isNullable<V>();
+    const res = this.get(key, isSerializable ? instantiate<V>() : (null as V));
+    assert(res, 'bad result');
+    return <V>res;
+
+    // if (!this.contains(key)) {
+    //     return new Result(<V>null, "key not found");
+    // }
+    // const res = this.get(key, null);
+    // return new Result(<V>res);
+  }
+
+  /**
+   * ```ts
+   * let map = new PersistentMap<string, string>("m")
+   *
+   * map.set("hello", "world")
+   * ```
+   *
+   * Sets the new value for the given key.
+   * @param key - Key of the element.
+   * @param value - The new value of the element.
+   */
+  set(key: K, value: V): void {
+    // assert map size wont overflow
+    assert(this.size() < u64.MAX_VALUE, 'map size overflow');
+
+    this._increaseSize(key);
+
+    if (isString<V>()) {
+      Storage.set(this._key(key), stringToBytes(value as string));
+    } else if (isInteger<V>()) {
+      Storage.set(this._key(key), u64ToBytes(value as u64));
+    } else if (isFloat<V>()) {
+      Storage.set(this._key(key), f64ToBytes(value as f64));
+    } else if (isBoolean<V>()) {
+      Storage.set(this._key(key), boolToByte(value as bool));
+    } else if (idof<V>() == idof<StaticArray<u8>>()) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      Storage.set(this._key(key), value);
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+    } else if (value instanceof Serializable) {
+      Storage.set(this._key(key), (value as Serializable).serialize());
+    } else if (value instanceof u256) {
+      Storage.set(this._key(key), u256ToBytes(value as u256));
+    } else {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      Storage.set(this._key(key), value.toString());
+    }
+  }
+}

package/assembly/libraries/SafeMath.ts

@@ -0,0 +1,73 @@
+export class SafeMath {
+  /**
+   *
+   * @param a
+   * @param b
+   * @returns Returns the addition of two unsigned integers,
+   * reverting on overflow.
+   */
+  static add(a: u64, b: u64): u64 {
+    const c: u64 = a + b;
+    assert(c >= a, 'SafeMath: addition overflow');
+
+    return c;
+  }
+
+  /**
+   *
+   * @param a
+   * @param b
+   * @returns Returns the integer division of two unsigned integers. Reverts with custom message on
+   * division by zero. The result is rounded towards zero.
+   */
+  static sub(a: u64, b: u64): u64 {
+    assert(b <= a, 'SafeMath: substraction overflow');
+    const c: u64 = a - b;
+
+    return c;
+  }
+
+  /**
+   *
+   * @param a
+   * @param b
+   * @returns Returns the multiplication of two unsigned integers, reverting on
+   * overflow.
+   */
+  static mul(a: u64, b: u64): u64 {
+    if (a == 0) {
+      return 0;
+    }
+
+    const c = a * b;
+    assert(c / a == b, 'SafeMath: multiplication overflow');
+
+    return c;
+  }
+
+  /**
+   *
+   * @param a
+   * @param b
+   * @returns Returns the integer division of two unsigned integers. Reverts on
+   * division by zero. The result is rounded towards zero.
+   */
+  static div(a: u64, b: u64): u64 {
+    assert(b > 0, 'SafeMath: division by zero');
+    const c = a / b;
+
+    return c;
+  }
+
+  /**
+   *
+   * @param a
+   * @param b
+   * @returns Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
+   * Reverts with custom message when dividing by zero.
+   */
+  static mod(a: u64, b: u64): u64 {
+    assert(b != 0, 'SafeMath: modulo by zero');
+    return a % b;
+  }
+}

package/assembly/libraries/Upgradeable.ts

@@ -0,0 +1,81 @@
+import {
+  Context,
+  Storage,
+  caller,
+  createEvent,
+  generateEvent,
+  setBytecode,
+} from '@massalabs/massa-as-sdk';
+import { u64ToBytes, stringToBytes, bytesToU64 } from '@massalabs/as-types';
+import { SafeMath } from './SafeMath';
+
+/**
+ * @dev Make sure no other modules are using the same storage keys
+ */
+const PERIOD: StaticArray<u8> = stringToBytes('upgradeable_period');
+const TIMELOCK: StaticArray<u8> = stringToBytes('upgradeable_timelock');
+const UPGRADE: StaticArray<u8> = stringToBytes('upgradeable_upgrade');
+
+/**
+ * @dev Contract that allows to propose and execute upgrades
+ * The contract can be upgraded only after the locked period has passed
+ * Thoses function should only be callable by the owner
+ */
+export class Upgradeable {
+  /**
+   * @dev Initializes the contract with the timelock period
+   */
+  static __Upgradeable_init(timelock: u64): void {
+    assert(!Storage.has(PERIOD), 'Upgradeable__AlreadyInitialized');
+
+    this.__Upgradeable_setUpgradeDelay(timelock);
+  }
+
+  /**
+   * @dev Update the upgrade delay
+   */
+  static __Upgradeable_setUpgradeDelay(timelock: u64): void {
+    Storage.set(PERIOD, u64ToBytes(timelock));
+  }
+
+  /**
+   * @dev Returns true if the contract is locked
+   */
+  static islocked(): bool {
+    return (
+      SafeMath.add(this.timelock(), bytesToU64(Storage.get(PERIOD))) <
+      Context.timestamp()
+    );
+  }
+
+  /**
+   * @dev Returns the timelock timestamp
+   */
+  static timelock(): u64 {
+    return bytesToU64(Storage.get(TIMELOCK));
+  }
+
+  /**
+   * @dev Proposes an upgrade, should be only callable by the owner
+   * @param newCode - The new contract code
+   */
+  static proposeUpgrade(newCode: StaticArray<u8>): void {
+    Storage.set(TIMELOCK, u64ToBytes(Context.timestamp()));
+    Storage.set(UPGRADE, newCode);
+    generateEvent(createEvent('UpgradeProposed', [caller().toString()]));
+  }
+
+  /**
+   * @dev Upgrades the contract, should be only callable by the owner
+   *
+   * reverts if the locked period has not passed
+   */
+  static upgrade(): void {
+    assert(!this.islocked(), 'Upgradeable__Timelock');
+    assert(Storage.has(UPGRADE), 'Upgradeable__NoUpgreadeProposed');
+    const newCode = Storage.get(UPGRADE);
+    Storage.del(UPGRADE);
+    setBytecode(newCode);
+    generateEvent(createEvent('Upgraded', [caller().toString()]));
+  }
+}

package/assembly/storage/Multisig.ts

@@ -0,0 +1,11 @@
+import { stringToBytes } from '@massalabs/as-types';
+import { PersistentMap } from '../libraries/PersistentMap';
+import { Transaction } from '../structs/Transaction';
+
+export const OWNERS = stringToBytes('owners');
+export const DELAY = stringToBytes('delay');
+export const REQUIRED = stringToBytes('required');
+export const IS_OWNER = new PersistentMap<string, bool>('is_owner');
+export const TRANSACTIONS = new PersistentMap<u64, Transaction>('transactions');
+export const APPROVED = new PersistentMap<string, bool>('approved');
+// @dev key is a combination of transaction id and owner address as string

package/assembly/structs/Transaction.ts

@@ -0,0 +1,37 @@
+import { Serializable, Args, Result } from '@massalabs/as-types';
+import { Address } from '@massalabs/massa-as-sdk';
+
+export class Transaction implements Serializable {
+  constructor(
+    public to: Address = new Address(''),
+    public method: string = '',
+    public value: u64 = 0,
+    public data: StaticArray<u8> = [],
+    public timestamp: u64 = 0,
+    public executed: bool = false,
+  ) {}
+
+  serialize(): StaticArray<u8> {
+    return new Args()
+      .add(this.to)
+      .add(this.method)
+      .add(this.value)
+      .add(this.data)
+      .add(this.timestamp)
+      .add(this.executed)
+      .serialize();
+  }
+
+  deserialize(data: StaticArray<u8>, offset: i32): Result<i32> {
+    const args = new Args(data, offset);
+    this.to = new Address(args.nextString().expect('Error deserializing to'));
+    this.method = args.nextString().expect('Error deserializing method');
+    this.value = args.nextU64().expect('Error deserializing value');
+    this.data = args.nextBytes().expect('Error deserializing data');
+    const timestamp = args.nextU64();
+    this.timestamp = timestamp.isOk() ? timestamp.unwrap() : 0;
+    const executed = args.nextBool();
+    this.executed = executed.isOk() ? executed.unwrap() : false;
+    return new Result(args.offset);
+  }
+}

package/assembly/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../node_modules/assemblyscript/std/assembly.json",
+  "include": [
+    "**/*.ts"
+  ],
+  "typedocOptions": {
+    "exclude": "assembly/**/__tests__",
+    "excludePrivate": true,
+    "excludeProtected": true,
+    "excludeExternals": true,
+    "includeVersion": true,
+    "skipErrorChecking": true
+  }
+}

package/index.ts

@@ -0,0 +1 @@
+export * from './assembly/interfaces/IMultisig';

package/package.json

@@ -0,0 +1,57 @@
+{
+    "name": "@massalabs/multisig-contract",
+    "version": "0.0.2-dev.20260414091108",
+    "description": "",
+    "scripts": {
+        "test": "asp --summary",
+        "build": "npx massa-as-compile",
+        "deploy": "tsx src/deploy.ts",
+        "approve:proposal": "tsx src/approve-proposal.ts",
+        "execute:proposal": "tsx src/execute-proposal.ts",
+        "get:multisig-parameters": "tsx src/get-multisig-parameters.ts",
+        "list:proposals": "tsx src/list-proposals.ts",
+        "propose:add-member": "tsx src/propose-add-member.ts",
+        "prettier": "prettier assembly//**/*.ts --check",
+        "prettier:fix": "prettier assembly//**/*.ts --write",
+        "lint": "eslint .",
+        "lint:fix": "eslint . --fix",
+        "fmt:check": "npm run prettier && npm run lint",
+        "fmt": "npm run prettier:fix && npm run lint:fix",
+        "publish:dev": "bash ./scripts/publish-dev.sh",
+        "publish:latest": "npm publish --access public",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [],
+    "author": "",
+    "license": "ISC",
+    "devDependencies": {
+        "@as-pect/cli": "^8.0.1",
+        "@assemblyscript/loader": "^0.27.22",
+        "@massalabs/as-transformer": "^0.3.2",
+        "@massalabs/as-types": "^2.1.0",
+        "@massalabs/eslint-config": "^0.0.10",
+        "@massalabs/massa-as-sdk": "^3.0.2",
+        "@massalabs/massa-sc-compiler": "^0.1.0",
+        "@massalabs/massa-web3": "^5.3.0",
+        "@massalabs/prettier-config-as": "^0.0.2",
+        "@massalabs/sc-standards": "^0.1.1",
+        "@types/node": "^20.10.3",
+        "as-bignum": "github:massalabs/as-bignum#0105eb596b2fa707c00712e811a2efdfcb8a9848",
+        "assemblyscript": "^0.27.22",
+        "assemblyscript-prettier": "^3.0.4",
+        "dotenv": "^16.3.1",
+        "prettier": "^3.1.0",
+        "tslib": "^2.6.2",
+        "tsx": "^4.11.0",
+        "typescript": "^5.3.2"
+    },
+    "type": "module",
+    "prettier": "@massalabs/prettier-config-as",
+    "files": [
+        "index.ts",
+        "assembly"
+    ],
+    "engines": {
+        "node": ">=16"
+    }
+}