refactor(contracts)!: StreamManager upgrades

README.md

@@ -34,27 +34,33 @@ Second, make sure to install the plugins:
 $ ape plugins install . --upgrade
 ```
 
-Next, prior to installing the SDK package, you have to compile the project:
+Next, prior to installing the SDK package, you need to compile the project:
 
 ```sh
 $ ape compile
 ```
 
-```note
+```{note}
 The SDK package relies on a soft link in [`./sdk/py/apepay/manifest.json`](./sdk/py/apepay/manifest.json)
 ```
 
 Lastly, install the SDK package via:
 
 ```sh
-$ poetry install
+$ pip install .
+```
+
+or for interactive installation do:
+
+```sh
+$ pip install -e .
 ```
 
 Then you are ready to contribute!
 
 ### Setup (JS)
 
-In order to contribute to the JS SDK and React component library, or to build the demo app, you need to first follow the [Python Setup instructions](#setup-python) to compile the smart contract package.
+In order to contribute to the JS packages, you need to first follow the [Python Setup instructions](#setup-python) to compile the smart contract package.
 
 Next, you need install the node packages for development:
 
@@ -108,7 +114,7 @@ To deploy a StreamManager (for testing purposes), run:
 
 ```sh
 $ ape run deploy manager [TOKEN_ADDRESS [...]]
-# Or if `ape tokens` is installed with a valid tokenlist
+# Or if `ape tokens` is installed (with a valid tokenlist)
 $ ape run deploy manager [TOKEN_SYMBOL [...]]
 ```
 
@@ -124,26 +130,30 @@ To deploy a Token (for testing use only), run:
 $ ape run deploy token
 ```
 
-```note
+```{warning}
 This test token has an unauthenticated mint, please do not use in production!
 ```
 
 To run the demo ApePay cluster daemon, first run a node like `anvil`:
 
 ```sh
-$ anvil --derivation-path "m/44'/60'/0'/" --block-time 1 --prune-history
+$ anvil --block-time 1 --prune-history
 ```
 
-**NOTE**: the `--derivation-path` flag makes ape's test accounts match anvil's
-
-Then run the daemon:
+Then run the example Silverback app:
 
 ```sh
-$ silverback run scripts.daemon:app --network ::foundry --account TEST::0
+$ silverback run bots.example:app
 ```
 
 After that, it's suggested to start `ape console` and create a stream to watch the daemon react.
 
+We also provide a simulation you can run instead using:
+
+```sh
+$ ape run demo
+```
+
 ### Publishing
 
 Given the monorepo structure, it's a bit more challenging to distribute all the packages in this repo.
@@ -154,23 +164,19 @@ TBD
 
 #### Python SDK
 
-To publish the Python package, there are 5 steps.
+To publish the Python package, there are 4 steps.
 
 ```sh
 # 1. Install everything
-$ poetry install`
+$ pip install .[dev]
 # 2. Compile the package manifest
-$ ape compile
-# 3. Copy the package manifest to the Python SDK folder
-$ cp .build/__local__.json sdk/py/apepay/manifest.json
-# 4. Build the Python SDK with Poetry
-$ poetry build
-# 5. Publish the package
-$ poetry publish
+$ ape compile -f
+# 3. Build the Python SDK with twine
+$ twine build
+# 4. Publish the package
+$ twine publish
 ```
 
-**NOTE**: make sure to revision the package before publishing, or it will fail.
-
 #### JavaScript SDK and React component library
 
 To publish the JS SDK, do the following:

bots/example.py

@@ -1,7 +1,5 @@
 import os
-from collections import defaultdict
 
-from ape.types import AddressType
 from silverback import SilverbackApp
 
 from apepay import Stream, StreamManager
@@ -12,37 +10,33 @@
 
 # NOTE: You would probably want to index your db by network and deployment address,
 #       if you were operating on multiple networks and/or deployments (for easy lookup)
-db: defaultdict[AddressType, list[Stream]] = defaultdict(list)
+db: dict[int, Stream] = dict()
 # TODO: Migrate to `app.state.db` when feature becomes available
 
 
 @app.on_startup()
 async def load_db(_):
     for stream in sm.active_streams():
-        while len(db[stream.creator]) < stream.stream_id:
-            db[stream.creator].append(None)  # Fill with empty values
-        assert stream.stream_id == len(db[stream.creator])
-        db[stream.creator].append(stream)
+        db[stream.id] = stream
 
 
 @sm.on_stream_created(app)
 async def grant_product(stream):
-    assert stream.stream_id == len(db[stream.creator])
-    db[stream.creator].append(stream)
-    print(f"provisioning product for {stream.creator}")
+    db[stream.id] = stream
+    print(f"provisioning products: {stream.products}")
     return stream.time_left
 
 
 @sm.on_stream_funded(app)
 async def update_product_funding(stream):
     # NOTE: properties of stream have changed, you may not need to handle this, but typically you
     #       would want to update `stream.time_left` in db for use in user Stream life notifications
-    db[stream.creator][stream.stream_id] = stream
+    db[stream.id] = stream
     return stream.time_left
 
 
 @sm.on_stream_cancelled(app)
 async def revoke_product(stream):
     print(f"unprovisioning product for {stream.creator}")
-    db[stream.creator][stream.stream_id] = None
+    db[stream.id] = None
     return stream.time_left

contracts/StreamFactory.vy

@@ -16,24 +16,35 @@ BLUEPRINT: public(immutable(address))
 deployments: public(HashMap[address, address])
 
 
+event ManagerCreated:
+    owner: indexed(address)
+    manager: address
+    accepted_tokens: DynArray[address, 20]
+    validators: DynArray[address, 10]
+
+
 @deploy
 def __init__(blueprint: address):
     BLUEPRINT = blueprint
 
 
 @external
-def create(validators: DynArray[address, 10], accepted_tokens: DynArray[address, 20]) -> address:
-    #assert self.deployments[msg.sender] == empty(address)  # dev: only one deployment allowed
-
-    deployment: address = create_from_blueprint(
+def create(
+    accepted_tokens: DynArray[address, 20] = [],
+    validators: DynArray[address, 10] = [],
+    min_stream_time: uint256 = ONE_HOUR,
+) -> address:
+    deployment: address = create_from_blueprint(  # dev: only one deployment allowed
         BLUEPRINT,
         msg.sender,  # Only caller can create
-        ONE_HOUR,  # Safety parameter (not configurable)
+        min_stream_time,  # Safety parameter for new streams
         validators,
         accepted_tokens,  # whatever caller wants to accept
         salt=convert(msg.sender, bytes32),  # Ensures unique deployment per caller
         code_offset=3,
     )
     self.deployments[msg.sender] = deployment
 
+    log ManagerCreated(msg.sender, deployment, accepted_tokens, validators)
+
     return deployment