Feature: Indefinite duration Boombox

packages/boom-nfts/tests/boomnfts_test.ts

@@ -4,8 +4,8 @@ import {
   Chain,
   Account,
   types,
-} from "https://deno.land/x/clarinet@v0.16.0/index.ts";
-import { assertEquals } from "https://deno.land/std@0.109.0/testing/asserts.ts";
+  assertEquals,
+} from "./libs/deps.ts";
 
 function mintSeries(
   account: Account,

packages/boombox-admin/settings/Devnet.toml

@@ -18,7 +18,7 @@ balance = 100_000_000_000_000_000
 
 [accounts.wallet_2]
 mnemonic = "hold excess usual excess ring elephant install account glad dry fragile donkey gaze humble truck breeze nation gasp vacuum limb head keep delay hospital"
-balance = 100_000_000_000_000
+balance = 100_000_000_000_000_000
 # secret_key: 530d9f61984c888536871c6573073bdfc0058896dc1adfe9a6a10dfacadc209101
 # stx_address: ST2CY5V39NHDPWSXMW9QDT3HC3GD6Q6XX4CFRK9AG
 # btc_address: muYdXKmX9bByAueDe6KFfHd5Ff1gdN9ErG

packages/boombox-admin/tests/client/boombox-admin.ts

@@ -1,8 +1,6 @@
-import { Tx, Account, types, Chain } from "../../../common/tests/deps.ts";
+import { Clarinet, Tx, Chain, Account, types, assertEquals } from "../../../common/tests/deps.ts";
 
-
-
-export function poxAllowBoomboxAdminAsContractCaller(boomboxAdminContractId: string, account: Account, ) {
+export function poxAllowBoomboxAdminAsContractCaller(boomboxAdminContractId: string, account: Account) {
   return Tx.contractCall(
     "SP000000000000000000002Q6VF78.pox",
     "allow-contract-caller",
@@ -11,38 +9,75 @@ export function poxAllowBoomboxAdminAsContractCaller(boomboxAdminContractId: str
   );
 }
 
-export function addBoombox(boomboxNftContractName: String, user: Account) {
+export function allowContractCaller(deployer: Account) {
+  return Tx.contractCall(
+    "boombox-admin",
+    "allow-contract-caller",
+    [types.principal(deployer.address)],
+    deployer.address
+  );
+}
+
+export function addBoombox(
+  boombox: string,
+  cycle: number,
+  lockingPeriod: number,
+  minAmount: number,
+  owner: Account,
+  account: Account
+) {
   return Tx.contractCall(
     "boombox-admin",
     "add-boombox",
     [
-      types.principal(
-        `ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM.${boomboxNftContractName}`
-      ),
-      types.uint(1),
-      types.uint(1),
-      types.uint(40000000),
+      types.principal(boombox), // boombox trait
+      types.uint(cycle),
+      types.uint(lockingPeriod),
+      types.uint(minAmount),
       types.tuple({ version: "0x01", hashbytes: "0x1234" }),
-      types.principal(user.address),
+      types.principal(owner.address),
     ],
-    user.address
+    account.address
   );
 }
 
 export function delegateStx(
   boomboxId: number,
-  boomboxContractId: string,
+  boombox: string,
   amount: number,
-  user: Account
+  account: Account
 ) {
   return Tx.contractCall(
     "boombox-admin",
     "delegate-stx",
-    [
-      types.uint(boomboxId),
-      types.principal(boomboxContractId),
-      types.uint(amount),
-    ],
-    user.address
+    [types.uint(boomboxId), types.principal(boombox), types.uint(amount)],
+    account.address
+  );
+}
+
+export function stackAggregationCommit(cycle: number, account: Account) {
+  return Tx.contractCall(
+    "boombox-admin",
+    "stack-aggregation-commit",
+    [types.tuple({ version: "0x01", hashbytes: "0x1234" }), types.uint(cycle)],
+    account.address
+  );
+}
+
+export function extendBoomboxing(stacker: Account, account: Account) {
+  return Tx.contractCall(
+    "boombox-admin",
+    "extend-boomboxing",
+    [types.principal(stacker.address)],
+    account.address
+  );
+}
+
+export function extendBoomboxingMany(stackers: Account[], account: Account) {
+  return Tx.contractCall(
+    "boombox-admin",
+    "extend-boomboxing-many",
+    [types.list(stackers.map((stacker) => types.principal(stacker.address)))],
+    account.address
   );
 }

packages/friedger-pool-boombox/Clarinet.toml

@@ -1,15 +1,32 @@
 [project]
-name = "Boom"
+name = "Friedger Pool Boombox"
 
-[contracts.commission-trait]
-path = "contracts/commission.clar"
+[contracts.boombox-trait]
+path = "../boombox-admin/contracts/boombox-trait.clar"
 depends_on = []
 
-[contracts.nft-trait]
-path = "../common/contracts/nft-trait.clar"
+
+
+[contracts.boombox-admin]
+path = "../boombox-admin/contracts/boombox-admin.clar"
+depends_on = ["boombox-trait"]
+
+
+[contracts.group-stacker]
+path = "contracts/group-stacker.clar"
+depends_on = ["boombox-trait", "iou-stx", "friedger-pool-payout-hints", "fp-boombox"]
+
+
+[contracts.iou-stx]
+path = "contracts/iou-stx.clar"
+depends_on = []
+
+
+[contracts.fp-boombox]
+path = "contracts/fp-boombox.clar"
 depends_on = []
 
 
-[contracts.boom-nfts]
-path = "contracts/boom-nfts-300.clar"
-depends_on = ["commission-trait", "nft-trait"]
+[contracts.friedger-pool-payout-hints]
+path = "contracts/external/friedger-pool-payout-hints.clar"
+depends_on = []

packages/friedger-pool-boombox/contracts/external/friedger-pool-payout-hints.clar

@@ -0,0 +1,10 @@
+;; mapping between stacker and recipient of stacker's rewards
+(define-map payout-map principal principal)
+
+;; set receiver of the stacker's rewards
+(define-public (set-payout-recipient (recipient principal))
+    (ok (map-set payout-map tx-sender recipient)))
+
+;; remove receiver of the stacker's rewards. Rewards will be sent to stacker
+(define-public (delete-payout-recipient (recipient principal))
+    (ok (map-delete payout-map tx-sender)))

packages/friedger-pool-boombox/contracts/fp-boombox.clar

@@ -0,0 +1,20 @@
+(define-data-var last-nft-id uint u0)
+
+(define-public (mint (bb-id uint) (stacker principal) (amount-ustx uint) (pox-addr {version: (buff 1), hashbytes: (buff 20)}) (locking-period uint))
+  (let ((nft-id (+ u1 (var-get last-nft-id))))
+    (var-set last-nft-id nft-id)
+    (print {bb-id: bb-id, stacker: stacker, amount-ustx: amount-ustx, pox-addr: pox-addr, locking-period: locking-period})
+    (ok nft-id)))
+
+(define-read-only (get-owner (id uint))
+  (ok (some 'SP000000000000000000002Q6VF78)))
+
+(define-read-only (get-owner-at-block (id uint) (stacks-tip uint))
+  (match (get-block-info? id-header-hash stacks-tip)
+    ihh (ok (at-block ihh (some 'SP000000000000000000002Q6VF78)))
+    err-invalid-stacks-tip))
+
+(define-public (set-boombox-id (bb-id uint))
+  (ok true))
+
+(define-constant err-invalid-stacks-tip (err u608))

packages/friedger-pool-boombox/contracts/group-stacker.clar

@@ -1,33 +1,41 @@
 (use-trait bb-trait .boombox-trait.boombox-trait)
 
 (define-constant min-balance u120000000000)
-(define-constant boombox-contract .indefinite-boombox-3)
-(define-constant boombox-id u5)
+(define-constant boombox-contract .fp-boombox)
+(define-constant boombox-id u1)
 (define-constant beneficary 'SP4NK85F5Y3KJESRF6S4VXBSTAPE7006V5P7ZNHT)
 
+(define-constant err-low-balance (err u402))
+(define-constant err-invalid-boombox (err u600))
+
 (define-public (lend (amount uint))
     (begin
         (try! (stx-transfer? amount tx-sender (as-contract tx-sender)))
-        (try! (mint-iou amount tx-sender))
+        (try! (contract-call? .iou-stx mint amount tx-sender))
         (ok true)))
 
+
 (define-public (repay (amount uint) (user principal))
-    (begin        
+    (begin
         (try! (as-contract (stx-transfer? amount tx-sender user)))
-        (burn-iou amount user)
+        (try! (contract-call? .iou-stx burn amount user))
         (ok true)))
 
-(define-public (repay-many (list details {amount: uint, user: principal}))
-    (ok true))
+(define-public (repay-many (amounts (list 200 uint)) (users (list 200 principal)))
+    (ok (map repay amounts users)))
 
 (define-public (delegate-stx (fq-contract <bb-trait>))
     (let ((balance (stx-get-balance (as-contract tx-sender))))
-        (asserts! (> balance min-balance) err-low-balance)     
-        (asserts! (is-eq (contract-of fq-contract) boombox-contract) err-invalid-boombox)   
-        (try! (as-contract (contract-call? .pox allow-contract-caller .boombox-admin none)))
-        (try! (as-contract (contract-call? .boombox-admin delegate-stx )
+        (asserts! (> balance min-balance) err-low-balance)
+        (asserts! (is-eq (contract-of fq-contract) boombox-contract) err-invalid-boombox)
+        (try! (err-to-uint (as-contract (contract-call? 'SP000000000000000000002Q6VF78.pox allow-contract-caller .boombox-admin none))))
+        (try! (as-contract (contract-call? .boombox-admin delegate-stx
                 boombox-id fq-contract balance)))
-        (as-contract (revoke-delegation))
-        (as-contract (set-payout-hint beneficary))
-        (ok true))
+        (try! (err-to-uint (as-contract (contract-call? 'SP000000000000000000002Q6VF78.pox revoke-delegate-stx))))
+        (unwrap-panic (as-contract (contract-call? .friedger-pool-payout-hints set-payout-recipient beneficary)))
+        (ok true)))
 
+(define-private (err-to-uint (resp (response bool int)))
+    (match resp
+        success (ok success)
+        error (err (to-uint error))))

packages/friedger-pool-boombox/contracts/iou.clar → packages/friedger-pool-boombox/contracts/iou-stx.clar

@@ -1,5 +1,3 @@
-
-;; prepaid-stx
 ;; iou stacks
 
 ;; constants
@@ -13,9 +11,6 @@
 (define-map approvals-all {owner: principal, operator: principal} bool)
 
 
-;; private functions
-;;
-
 ;; public functions
 ;;
 
@@ -30,6 +25,16 @@
     (print memo)
     (ok true)))
 
+(define-public (mint (amount uint) (user principal))
+  (begin 
+    (asserts! (is-eq contract-caller .group-stacker) err-not-authorized)
+    (ft-mint? iou-stx amount user)))
+
+
+(define-public (burn (amount uint) (user principal))
+  (begin 
+    (asserts! (is-eq contract-caller .group-stacker) err-not-authorized)
+    (ft-burn? iou-stx amount user)))    
 ;;
 ;; operable functions
 ;;
@@ -66,15 +71,15 @@
 
 ;; returns the token name
 (define-read-only (get-name)
-  (ok "Prepaid STX"))
+  (ok "IOU STX"))
 
 ;; the symbol or "ticker" for this token
 (define-read-only (get-symbol)
-  (ok "iou-stx"))
+  (ok "IOUX"))
 
 ;; the number of decimals used
 (define-read-only (get-decimals)
-  (ok u0))
+  (ok u6))
 
 (define-public (get-token-uri)
   (ok (some u"ipfs://Qm")))

packages/friedger-pool-boombox/tests/client/group-stacker.ts

@@ -0,0 +1,40 @@
+import { Tx, Account, types, Chain } from "./../../../common/tests/deps.ts";
+
+export function lend(amount: number, user: Account) {
+  return Tx.contractCall(
+    "group-stacker",
+    "lend",
+    [types.uint(amount)],
+    user.address
+  );
+}
+
+export function repay(amount: number, recipient: string, user: Account) {
+  return Tx.contractCall(
+    "group-stacker",
+    "repay",
+    [types.uint(amount), types.principal(recipient)],
+    user.address
+  );
+}
+
+export function repayMany(amounts: number[], users: string[], user: Account) {
+  return Tx.contractCall(
+    "group-stacker",
+    "repay-many",
+    [
+      types.list(amounts.map((amount) => types.uint(amount))),
+      types.list(users.map((user) => types.principal(user))),
+    ],
+    user.address
+  );
+}
+
+export function delegateStx(boomboxContractId: string, user: Account) {
+  return Tx.contractCall(
+    "group-stacker",
+    "delegate-stx",
+    [types.principal(boomboxContractId)],
+    user.address
+  );
+}