yes, it's not possible to store a pointer, since, by definition, it is pointing to a memory segment

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

Newton

Hi, is there no way for me to have a struct as a `@storage_var` if it contains an array fo felts inside ?

For e.g. if I have a struct User:
```
struct User{
  values_len: felt ,
  VALUES: felt*,
}
```

Then I need to store a mapping from User Id to Users, is it not possible ?

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

Is there no way for me to have a struct as a `@storage_var` if it contains an array fo felts inside ?

I'm trying to use Nile (StarkNet).
I send this function call : 

```cairo
func setBaseURI{pedersen_ptr: HashBuiltin*, syscall_ptr: felt*, range_check_ptr}(
    baseUri_len: felt, baseUri: felt*
)
```

The only thing that would get processed is 

```
nile send account mycontract setBaseURI 3 1 1 1
```

but I don't think that's the right way. How do you pass an array of felt to call with Nile?

How can I pass an array of felt to call with Nile in StarkNet?

I'm implementing the new version and had a couple Q's:

- Is `useStarknetExecute` now the only transaction method (for multi and single calls).
- Do we update the transaction manager on our end? I seem to remember `useStarknetInvoke` also update this automatically

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

Questions about useStarknetExecute. Do we update the transaction manager on our end? [StarkNet/Cairo]

How do I connect my DAPP to a private Starknet network using starknetjs?

I'm looking for a StarkNet guide. I'm an experienced CTO and I want to know more about it, check out, and learn more. Also want to get hyped. What can you recommend to read to learn more about StarkNet?

What's the best advanced StarkNet guide?

Some questions that could be answered separately.

1. The only way to invoke a contract is using migrations (this applies for both devnet and testnet?)
2. When doing a migration file I receive the “Hint is not whitelisted. This may indicate that this library function cannot be used in StarkNet contracts.” error. For example for this code:

```
%lang starknet

@external
func up() {
    %{
        contract_address = deploy_contract(
             "./build/main.json",
             config={"wait_for_acceptance": True}
        ).contract_address

        invoke(
            contract_address,
            "initialize",
            {"new_authority": 123},
            config={
                "auto_estimate_fee": True,
                "wait_for_acceptance": True,
            }
        )
    %}

    return ();
}
```

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

The only way to invoke a contract is using migrations (this applies for both devnet and testnet?)

Hey there, is there an existing Math64x61_pow implementation to compute power of a floating point elevated to an integer power?

edit: looks like there is 🙂
https://github.com/influenceth/cairo-math-64x61/blob/master/contracts/cairo_math_64x61/math64x61.cairo#L278

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

Is there a Cairo Lang implementation to compute power of a floating point?

### *From Newton AI*
*"Assembly" is a low-level language that is used to write smart contracts for the Ethereum Virtual Machine (EVM). It is similar to machine code, which is the code that is run directly on a computer's central processing unit (CPU). Assembly is often used in Solidity contracts to perform complex tasks or to optimize the performance of the contract.*

*If a Solidity contract contains assembly code, it is important to be careful when working with it, as it can be difficult to read and understand. Additionally, certain assembly instructions, known as "special EVM calls," can have unintended consequences if not used correctly. For example, some special EVM calls can cause a contract to consume an excessive amount of gas, which can make it more expensive for users to interact with the contract.*

*It is generally recommended to avoid using assembly in Solidity contracts if possible, as it can make the contract more difficult to understand and maintain. If you do need to use assembly, it is important to thoroughly test and debug the contract to ensure that it functions as intended.*

Popular tags

Is there no way for me to have a struct as a `@storage_var` if it contains an array fo felts inside ?

1 answers

Your answer

Related

You may find useful