i usually subscribe this weekly newsletters https://swagtimus.substack.com/p/starknet-roundup-32

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

Newton

does anyone know of newsletters that focus on StarkNet or the zk ecosystem in general?

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

Does anyone know of newsletters that focus on StarkNet or the zk ecosystem in general?

Hello everyone. Does anyone happen to know if there's a way to get the block hash in cario? I found out about `get_block_number` and `get_block_timestamp`, but is there something similar for block hash?

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

How to get the block hash in Cairo lang?

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

Howdy.


I am trying to dev against the starknet devnet to build my frontend and am experiencing some issues. With argent, it seems that the version in the chromestore isn't up to date with the devnet's fee token, so I can create an account and fund it, but still not be able to do any transactions.


When I try to build from source, I get an error about something involving a react server or something.


Trying braavos, I am able to transact against dev net (invoke method calls) but calling views seems to be going against a wrongly set provider. So when I connect with the wallet, all my calls get an error that 'the contract isn't deployed' because it is checking against a goerli-testnet provider rather than my devnet. I can set a default provider manually, but it gets overwritten when I access the wallet.


I am hoping that there is maybe a third wallet or something that can help me sidestep the concern. But perhaps my understanding of the situation is misguided. I am using starknet-react, if that maybe is contributing to the issue.


﻿  



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

How do I develop against cairo devnet with browser wallets?

Hello, anyone able to advise what the etherscan equivalent for starknet is ?

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

What the etherscan equivalent for starknet is ?

hi guys! is it possible to import local python files into hints?

Like so:
```python
# Cairo here

%{
	import my_python_file.py
	# Python here
%}
```

Is it possible to import local python files into hints?

Can tempvar be of a different type, say U256?

let's say

`tempvar foo: U256 = bar;` and bar being a U256?

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

Can tempvar be of a different type, say U256?

Hello, is there a javascript version of StarkEx playground?

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

Popular tags

Does anyone know of newsletters that focus on StarkNet or the zk ecosystem in general?

1 answers

Your answer

Related

You may find useful