Hmm. I see we didn't add it to the write api.. that was an oversight I think. So the idea was to have some deviations with v0.1 as well; but we probably only did that for the normal RPC API, and missed the write API.

I'll see that we add it in the next version. Created an issue for it: https://github.com/eqlabs/pathfinder/issues/632

_This answer was originally posted on [StarkNet Discord](https://www.newton.so/view?tags=discord)_

Newton

Hello, Do I understand this correctly: Pathfinder JSON-RPC V0.1.0 does not support InvokeTXNV1 yet, right? At least, I do not `nonce` in `add_invoke_transaction`.

Do you plan to add it in JSON-RPC V0.1.0 like devnet (not being compliant to the spec) or will you introduce it with JSON-RPC V0.2.0?

_This question was originally posted on [StarkNet Discord](https://www.newton.so/view?tags=discord)_

Can anyone explain Pathfinder JSON-RPC InvokeTXNV1?

Hello! I was wondering whether it was possible to check if a certain address has code in Cairo.
In Solidity, we do something like:

```
assembly {
  codeSize := extcodesize(contractAddress)
}
or just:
uint256 codeSize = contractAddress.code;
```
I was wondering if there was a way to check something like this in cairo? I checked the syscalls file but didn't find anything promising there.

Thank you in advance!

How to check if a contract has been deployed at a certain address in cairo?

hey! Any idea on why I get this error : `HttpError: Bad Gateway ` from `node_modules/starknet/dist/provider/default.js:217`? I may be rate limited because I am using it inside checkpoint indexer but I doubt because I dont even spam it.

Also got this : `Error: Could not POST from endpoint https://alpha4.starknet.io/feeder_gateway/call_contract?blockNumber=pending: request to https://alpha4.starknet.io/feeder_gateway/call_contract?blockNumber=pending failed, reason: socket hang up`

_This question was originally posted on [StarkNet Discord](https://www.newton.so/view?tags=discord)_

`HttpError: Bad Gateway ` from `node_modules/starknet/dist/ error in StarkNet

Another vanilla Cairo question, what are the sorts of references, i.e. ids that can be modified by hints? relatively important to work against an evil prover

presumably not locals or tempvars, but say, implicit references, or the two(?) kinds of let statements (expressions and references)

maybe if there's some documentation i don't know about re: all the id types, relocatable values and so on,

also maybe, is there a pattern that can be used for function pointers?

Another vanilla Cairo question, what are the sorts of references

Hi all! I wanted to know if anyone knows by chance if the Starknet Name Service is working or not?

_This question was originally posted on [StarkNet Discord](https://www.newton.so/view?tags=discord)_

Is the Starknet Name Service working or not?

Looking to call the approve and transfer functions for an erc-20 in the same transaction. Thoughts on how to do this?


ㅤ
_This question was originally posted on [Triality](https://triality.org/question/1218)_

Cairo: How can i approve erc20 and transfer in the same transaction?

﻿  



ㅤ
_This question was originally posted on [Triality](https://triality.org/question/882)_

How can i learn Cairo with Python base?


I can often make a terminal recursive version of my functions with a little less elegant code. Should I do it because it could reduce the fees or should I keep the unoptimised version?


For example, here is an "unoptimised" function which sums elements of an array:



```
@view
func get_convoy_strength{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
    convoy_id : felt
) -> (strength : felt):
    alloc_locals
    let (convoyables_len : felt, convoyables : felt*) = get_convoyables(convoy_id)
    return _get_convoyables_strength(convoyables_len, convoyables)
end

```

and here is the tail call optimization:



```
func _get_convoyables_strength_tc{
    syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr
}(convoyables_len : felt, convoyables : felt*, sum : felt) -> (strength : felt):
    if convoyables_len == 0:
        return (sum)
    else:
        let convoyable_id = [convoyables]
        alloc_locals
        let (convoyable_strength) = _get_strength(convoyable_id)
        return _get_convoyables_strength_tc(
            convoyables_len - 1, convoyables + 1, sum + convoyable_strength
        )
    end
end

```

As you can see it's a little less friendly because it requires an additional argument (which will always be 0). On a normal computer this could be optimized to not fill the call stack but as FeedTheFed pointed out, the memory is immutable here so it doesn't seem to be useful. He did say, however, that it could be interesting for "not wasting memory cells for the intermediate return values". It would be very helpful to me to have a more detailed explanation as I'm not sure to understand.


Here is the cairo doc related to this: <https://www.cairo-lang.org/docs/how_cairo_works/functions.html?highlight=tail#tail-recursion>



ㅤ
_This question was originally posted on [Stack Overflow](https://stackoverflow.com/questions/72321871/when-to-use-tail-call-optimization-in-a-cairo-smartcontract)_

Popular tags

Can anyone explain Pathfinder JSON-RPC InvokeTXNV1?

1 answers

Your answer

Related

You may find useful