<p! does not resolve a promise. It parks the go block till the promise is resolved. Resolving a promise must be done in some different place.

I mean yes the promise is supposed to be resolved by the library whose function I’m calling

but while earlier it was resolving just fine, now it doesn’t resolve

nor does anything else after the go block get executed

With the amount of information you provide, it is impossible to give you any answer more useful than "there's something wrong with your code". Maybe you're doing something that blocks or deadlocks, maybe there's some other bug in your code, maybe there's some bug in that library, maybe some precondition somewhere is not met - and so on, and so forth.

This is the relevant section of the let bindings:

contract-deploy
          (.. contract
              (deploy (clj->js 
                         {:arguments [ipfs 
                                      (.toString
                                        (* (js/parseFloat (:income-to-sell db)) 
                                           1000000000000000000)) 
                                      (:amount-to-raise db)
                                      (nth (:timeframe-raising db) 0) 
                                      (nth (:timeframe-raising db) 1) 
                                      (nth (:timeframe-payments db) 0)
                                      (nth (:timeframe-payments db) 1)
                                      (:payment-interval db)]
                          :data (.-bytecode (js/JSON.parse resp))})))


          
          contract-send 
          (.. contract-deploy
              (send (clj->js {:from ego}) 
                    (fn [err tx-hash] 
                      (prn "err is " err
                           "tx hash is " tx-hash))))
           
          _ (prn "after contract send") 

          contract-instance
          (<p!
            (.. contract-send
                (on "error" (fn [obj] (js/console.log "error " obj)))
                (on "sending" (fn [obj] (prn "sending " obj)))
                (on "receipt" (fn [receipt] 
                                 (prn "contract address is")
                                 (.-contractAddress receipt)))
                (on "confirmation" (fn [confirmation-number receipt]
                                      (dispatch [:stop-loading])    
                                      (prn "confirmation number"
                                           confirmation-number)
                                      (prn "receipt"
                                           receipt)))))

It doesnt compiles when i run it with the error above

*what* doesn't compile? the configuration file is never compiled? like literally which command do you run? some kind of log helps to narrow down what the actual issue is

this error

where I try to read the env variable

i ran shadow-cljs watch frontend

@vladkryvokoniev I'm pretty sure that reader tag is supported only within the configuration. You can't use it in the CLJS files - you have to use goog-define for it: https://shadow-cljs.github.io/docs/UsersGuide.html#closure-defines

i tried it (goog-define TWITCH_AUTHORIZATION_TOKEN "") but it doesn't seem to work

it didn't take variable from my env

How exactly did you try it? Please post the relevant part of your config and the usage in CLJS.

@U2FRKM4TW https://clojurians.slack.com/archives/C03S1L9DN/p1630850120377300

It doesn't show the usage.

https://pastebin.com/RCZwF9eL

LGTM. Now are you sure you don't have any other shadow-cljs process running? Are you sure you have restarted its processes after you set the environment variable? Are you sure the shadow-cljs server itself picks up that variable?

BTW this amount of moving parts is the main reason (IMO) why the documentation recommends using -config-merge instead.

@vladkryvokoniev is the env variable actually set? it must have been set at the time shadow-cljs is started.

otherwise looks fine

shadow-cljs makes no attempt at reading .env so dunno how you get it to be an actual env var?

you can try shadow-cljs clj-repl and (System/getenv) to get all env variables available

or (System/getenv "TWITCH_AUTHORIZATION_TOKEN")

@U05224H0W it returns nil

how can I say the config where to look up env variables?

the environment variable is not set

you should figure out why not

can't look up env variables that aren't set

they are never looked up anywhere except the actual environment

where exactly in the documentation can I see all the way along of setting environment variables? Coz I have no clue what's wrong

That depends on your OS and how you run things - it's not shadow-cljs-specific at all.

yeah environment stuff is OS specific. shadow-cljs never sets any for you

no compiler warnings? would help to see actual code

FWIW this is what it could look like without a macro entirely

(defn with-contract-deploy [contract-json args callback]
  (go (let [web3
            (Web3. (.-givenProvider Web3))

            ego
            (-> (<p! (.. web3 -eth (getAccounts)))
                (nth 0))

            contract
            (new (.. web3 -eth -Contract)
              (.-abi (js/JSON.parse ~contract-json)))

            contract
            (.. contract
                (deploy (clj->js
                          {:arguments ~args
                           :data (.-bytecode (js/JSON.parse ~contract-json))})))]

        (callback contract))))

(with-contract-deploy
  contract-json
  [ipfs
   (.toString
     (* (js/parseFloat (:income-to-sell db))
       1000000000000000000))
   (:amount-to-raise db)
   (nth (:timeframe-raising db) 0)
   (nth (:timeframe-raising db) 1)
   (nth (:timeframe-payments db) 0)
   (nth (:timeframe-payments db) 1)
   (:payment-interval db)]

  (fn [contract-deploy]
    (let [contract-send
          (.. contract-deploy
              (send (clj->js {:from ego})
                (fn [err tx-hash]
                  (prn "err is " err
                    "tx hash is " tx-hash))))

          _ (prn "contract send is " contract-send)
          _ (prn "after contract send")
          _ (prn "after after. contract send ")

          contract-instance
          (.. contract-send
              (on "error" (fn [obj] (js/console.log "error " obj)))
              (on "sending" (fn [obj] (prn "sending " obj)))
              (on "receipt" (fn [receipt]
                              (prn "contract address is")
                              (.-contractAddress receipt)))
              (on "confirmation" (fn [confirmation-number receipt]
                                   (dispatch [:stop-loading])
                                   (prn "confirmation number"
                                     confirmation-number)
                                   (prn "receipt"
                                     receipt)))
              (then (fn [contract-instance]
                      (dispatch [:issue-nfts contract-instance contract-json ego]))))

          _ (prn "contract instance is " contract-instance)])))

@U05224H0W the callback contains the variable “ego” but it would be nil in the way you’ve written this and not have the value that you bound to in the function

then pass a second argument to the callback?

I didn't test this code, just wanted to show that the macro really isn't needed imho

It's documented: https://shadow-cljs.github.io/docs/UsersGuide.html#_javascript_dialects

Ok amazing thanks, sorry I already read the doc but didn't remember this one 🙃

what are you actually doing in the code? I assume thats import React from "react"?

would need some code to reproduce to comment more

ESM code is sometimes a little finicky. might work better if you switch to commonjs require instead of import

(or have babel rewrite it prior, if you doing this for JSX anyways)

Hello @U05224H0W thanks a lot for your answer. 1) Yes 2) I send you a tgz archive of the code in a few dozens of minutes if that's what you ask

3) Ok thanks will try require 4) Good idea, I need to search for a babel plugin that converts all import in require?

Everything works good after rewriting import to commonjs require, I just added the following babel plugin: "@babel/plugin-transform-modules-commonjs"

Thanks a lot @U05224H0W for the help !

I had to use this babel config to make it work in the end,

"babel": {
    "presets": [
      "@babel/preset-react"
    ],
    "plugins": [
      "babel-plugin-transform-scss",
      "@babel/plugin-transform-modules-commonjs"
    ]
  }

@babel.preset-react : transform JSX (and other things as well I think) babel-plugin-transform-css : compile sass to css @babel/plugin-transform-modules-commonjs: transform import to commonjs require