Hey! I don't think it is connected with StarkNet.py :/ 

However, we already had the same issue on the discord channel. Check the [thread](https://discord.com/channels/793094838509764618/1044112623974752286/1044220161386893343)!

tl;dr Your account could not have enough tokens to pay the fee!

war-in

Hey, I'm using StartkNet.py to make a transaction and it gets rejected. 
How to solve it?

What does this error means? (AssertionError: assert_not_zero failed: 0 = 0.)

What is the proxy pattern and how it can help make my smart contracts upgradable in Cairo Language? Is there any standard lib for that?

What is the proxy pattern and how it can help make my smart contracts upgradable in Cairo Language?

I have a struct with : 

```struct Binary:
felt a:
felt* b:
```

How to return this in a view function?
I see this error:
```
Can't identify return variable
```


how to return struct

I try to execute a code with `get_balance_sync` method:
![get_balance_sync Cairo StarknetPy code sample](https://res.cloudinary.com/varga/image/upload/c_pad,b_auto:predominant,fl_preserve_transparency/v1670921600/code_image_spbt0g.jpg)

However, I got this error:

```
starknet_py.net.client_errors.ClientError: Client failed with code 500: {"code": "StarknetErrorCode.ENTRY_POINT_NOT_FOUND_IN_CONTRACT", "message": "Error at pc=0:10:\nGot an exception while executing a hint.\nCairo traceback (most recent call last):\nUnknown location (pc=0:228)\nUnknown location (pc=0:214)\n\nError in the called contract (0x7f81ea93daf9c49494e3131b95646c3a8df5d97d151cc6484d49eaebe3e3d0a):\nEntry point 0x2e4263afad30923c891518314c3c95dbe830a16874e8abc5777a9a20b54c76e not found in contract with class hash 0x3ae692aaf1ded26a0b58cf42490f757563850acea887ed57b4894fee8279063."}
```

Can you help me to resolve this?

StarknetPy Error in get_balance_sync (StarknetErrorCode.ENTRY_POINT_NOT_FOUND_IN_CONTRACT)

Is there a way to search a block for events without using `get_transaction_receipt` for each transaction? 

For example, ETH has the `logsBloom` that helps you determine if an event was in the block.
And web3py and many providers have `filter` functions to help you find events.

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

Is there a way to search a block for events without using `get_transaction_receipt` for each transaction? 

In the medium article about 1.0.0 this is shown as the syntax for the for loop

```let sum = 0
for x in iter {
  sum = sum + x;
}```

That doesn't compile for me and loops are not mentioned on github release note.

Will recursion still be necessary if they work as they do in other languages? 

Will it be possible to invoke functions from within the loops?

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

Will it be possible to invoke functions from within the loops in Cairo 1.0?

I'm trying to make a FixedPoint cairo lib, but I'm having some trouble making a pow function. 

It's inspired by this function

```solidity

    function pow(
        uint256 x,
        uint256 y,
        uint256 base
    ) internal pure returns (uint256 z) {
        assembly {
            switch x
            case 0 {
                switch y
                case 0 {
                    // 0 ** 0 = 1
                    z := base
                }
                default {
                    // 0 ** y = 0
                    z := 0
                }
            }
            default {
                switch mod(y, 2)
                case 0 {
                    // If y is even, store base in z for now.
                    z := base
                }
                default {
                    // If y is odd, store x in z for now.
                    z := x
                }

                // Shifting right by 1 is like dividing by 2.
                let half := shr(1, base)

                for {
                    // Shift y right by 1 before looping to halve it.
                    y := shr(1, y)
                } y {
                    // Shift y right by 1 each iteration to halve it.
                    y := shr(1, y)
                } {
                    // Revert immediately if x ** 2 would overflow.
                    // Equivalent to iszero(eq(div(xSquared, x), x)) here.
                    if shr(128, x) {
                        revert(0, 0)
                    }

                    // Store x squared.
                    let xSquared := mul(x, x)

                    // Round to the nearest number.
                    let xSquaredRound := add(xSquared, half)

                    // Revert if xSquared + half overflowed.
                    if lt(xSquaredRound, xSquared) {
                        revert(0, 0)
                    }

                    // Set x to scaled xSquaredRound.
                    x := div(xSquaredRound, base)

                    // If n is even:
                    if mod(y, 2) {
                        // Compute z * x.
                        let zx := mul(z, x)

                        // If z * x overflowed:
                        if iszero(eq(div(zx, x), z)) {
                            // Revert if x is non-zero.
                            if iszero(iszero(x)) {
                                revert(0, 0)
                            }
                        }

                        // Round to the nearest number.
                        let zxRound := add(zx, half)

                        // Revert if zx + half overflowed.
                        if lt(zxRound, zx) {
                            revert(0, 0)
                        }

                        // Return properly scaled zxRound.
                        z := div(zxRound, base)
                    }
                }
            }
        }
    }
```

and I wrote this one in Cairo

```cairo
    func pow{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr: felt}(
        x: Uint256,
        n: Uint256,
        baseUnit: Uint256
    ) -> (res: Uint256) {
        alloc_locals;

        let (xIsZero) = uint256_eq(x, Uint256(low=0, high=0));

        if(xIsZero == TRUE) {
            let (nIsZero) = uint256_eq(n, Uint256(low=0, high=0));
            if(nIsZero == TRUE) {
                // 0**0 = 1
                return (res=Uint256(low=1, high=0));
            } 
            // 0**n = 0
            return (res=Uint256(low=0, high=0));            
        }

        let (nHalf, nHalfRem) = uint256_unsigned_div_rem(n, Uint256(low=2, high=0));
        let (nIsEven) = uint256_eq(nHalfRem, Uint256(low=0, high=0));
        let (z) = _assignZIf(nIsEven, baseUnit, x);

        let (baseUnitHalf, baseUnitHalfRem) = uint256_unsigned_div_rem(baseUnit, Uint256(low=2, high=0));

        let (res) = pow_loop(x, nHalf, z, baseUnit, baseUnitHalf);

        return (res=res);
    }

    func pow_loop{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr: felt}(
        x: Uint256, 
        n: Uint256, 
        z: Uint256,
        baseUnit: Uint256,
        baseUnitHalf: Uint256
    ) -> (res: Uint256) {
        alloc_locals;
    
        let (n_LteOne) = uint256_le(n, Uint256(low=1, high=0));
        
        if(n_LteOne == TRUE) {
            return (res=z);
        }

        let (xx, xxOverflow) = uint256_mul(x, x);
        assert xxOverflow.low = 0;
        assert xxOverflow.high = 0;

        let (xxRound, xSquaredRoundCarry) = uint256_add(xx, baseUnitHalf);
        let (roundingOverflowed) = uint256_lt(xxRound, xx);
        assert roundingOverflowed = FALSE;

        let (temp_x, temp_x_rem) = uint256_unsigned_div_rem(xxRound, baseUnit);

        let (nHalf, nHalfRem) = uint256_unsigned_div_rem(n, Uint256(low=2, high=0));
        let (nHalfIsEven) = uint256_eq(nHalfRem, Uint256(low=0, high=0));
        if(nHalfIsEven ==  TRUE) {
            let (zx, zxOverflow) = uint256_mul(z, x);
            assert zxOverflow.low = 0;
            assert zxOverflow.high = 0;

            let (shouldBeZ, shouldBeZRem) = uint256_unsigned_div_rem(zx, x);
            let (zxNotOverflowed) = uint256_eq(shouldBeZ, z);
            assert zxNotOverflowed = TRUE;

            let (zxRound, zxRoundCarry) = uint256_add(zx, baseUnitHalf);
            let (zxRoundOverflowed) = uint256_lt(zxRound, zx);
            assert zxRoundOverflowed = FALSE;

            let (temp_z, temp_zRem) = uint256_unsigned_div_rem(zxRound, baseUnit);
            return pow_loop(x=temp_x, n=nHalf, z=temp_z, baseUnit=baseUnit, baseUnitHalf=baseUnitHalf);
        } else {
            return pow_loop(x=temp_x, n=nHalf, z=z, baseUnit=baseUnit, baseUnitHalf=baseUnitHalf);
        }
    }

    func _assignZIf{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr: felt}(
        nIsEven: felt,
        baseUnit: Uint256,
        x: Uint256
    ) -> (res: Uint256) {
        if(nIsEven == TRUE) {
            return (res=baseUnit);
        }
        return (res=x);
    }
```

The thing is that I don't get the same results.

Here are some example of my results compared to the solidity function

- pow(1, 3, 10^18): Cairo = 1 / Solidity = 0

- pow(10^18, 5, 10^18): Cairo = 4000000000000000000 (4x10^18) / Solidity = 32000000000000000000 (32x10^18)

- pow(10^19, 5, 10^18): Cairo = 100000000000000000000 (10^20) / Solidity = 100000000000000000000000 (10^23)

I can't see what I'm doing wrong in my code

Fixed Point pow operation error

I’m just getting started and having problems installing the [Cairo](https://github.com/ApeWorX/ape-cairo) and [Starknet](https://github.com/ApeWorX/ape-starknet) plugins using the ape console. Why are the plugins not installed properly?

Popular tags

What does this error means? (AssertionError: assert_not_zero failed: 0 = 0.)

1 answers

Your answer

Related

You may find useful