hello ser ,many protocols (including starknet id or likely name service protocol)are deploying on the starknet ,so please consult in their community you can refer this web   https://www.starknet-ecosystem.com/

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

Newton

Hello. Does starknet have name service? what is the difference between starknet id and starknet name service? Are they same projects?

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

Does starknet have name service? 

How do I connect my DAPP to Starknet testnet using starknetjs?

Why am I having trouble deploying my Cairo contract?

Hello! This is day 14 of the 17 days of the Cairo Challenge. And I have no idea how to solve the [playground](https://www.cairo-lang.org/playground/) exercise “Hints”.  Perhaps you can help me?

```
// The following function uses hints to efficiently compute the square root `res`
// of the argument `n`.
// The idea is that the verifier only needs to be convinced that res * res = n,
// it doesn't really care how res was computed.
// In such cases, we don't have to compute res in pure Cairo - we can write a
// piece of Python code inside the Cairo program, which is called a "hint".
// A hint is a piece of code that the prover runs to initialize
// some memory cells. Note that it is completely transparent from the verifier's
// point of view, so the result of the hint *must* be verified using pure Cairo
// instructions (e.g., the "assert n = res * res" instruction below).
//
// 1. Comment out the line "assert n = res * res;" and run the code. Does it still output
//    the expected value? Can you explain why the assert is nonetheless essential?
//    Hint: Recall that from the verifier's point of view, the hint does not exist.
// 2. Uncomment the assert line and change the function to compute the fourth
//    root.

%builtins output

from starkware.cairo.common.serialize import serialize_word

// Computes the square root (over the integers) of `n`.
// Prover assumption: The square root exists.
func sqrt(n) -> (res: felt) {
    alloc_locals;
    local res;

    // Set the value of res using a Python hint.
    %{
        import math

        # Use the ids variable to access the value of a Cairo variable.
        ids.res = int(math.sqrt(ids.n))
    %}

    // From the verifier's point of view, the hint is completely transparent.
    // The following line guarantees that `res` is the square root
    // (either the positive or negative) of `n`.
    assert n = res * res;
    return (res=res);
}

func main{output_ptr: felt*}() {
    let (res) = sqrt(256);
    serialize_word(res);
    return ();
}
```

---

> Answers to this question are a part of the ✨ 17 days of Cairo Lang with Playground & Newton. ✨
> 

*Vote for your favorite answer - the best answer will win a $10 award. A new day – a new reward! During the next 17 days, our goal is to attract more developers to the Cairo language and to systematize the knowledge of Cairo lang. [Read rules](https://www.notion.so/17-days-of-Cairo-Lang-with-Newton-550dfcda6a2d449ca468be293c776578)*

How to use Hints in Cairo Lang?

I have the following code:


`from starkware.cairo.common.uint256 import Uint256`


`﻿`


`func main():`


 `test()`


 `return()`


`end`


`﻿`


`func test() -> (res : felt):`


 `alloc_locals`



 `local a : Uint256 = Uint256(low=1, high=0)`


 `if 1 == 1:`


 `local a : Uint256 = Uint256(low=2, high=0)`


 `end`



 `return (res = a)`


`end`


`﻿`


But I keep getting Error: code:20:19: Reference 'a' was revoked.


 return (res = a)


 ^


What is a good pattern for solving this issue?


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

Cairo: How to reassign Uint256 in a conditional

I am currently running this code

```
func main() {

    let x = [ap];
    [ap] = 1, ap++;

    [ap] = 2, ap++;

    [ap] = x, ap++;
    jmp rel -1;  // Jump to the previous instruction.
}

And what is happening is that "x" is alternating between 1 and 2 and I couldn't figure out why.

Also, it wasn't very clear to me what a "Revoked Reference" means. Is it when you cannot access a certain [ap] when running a specific function?

This is the link to the exercise:
https://www.cairo-lang.org/docs/how_cairo_works/consts.html#revoked-references

Revoked References exercise from Cairo-lang

How does warp handles the contract solidity version?


I'm very curious: does Cairo have any logic operators? I found bitwise_or bitwise_and etc. but it is not wokring if I want to do something like

if (x == y) OR (x == -y) { ... }

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

Popular tags

Does starknet have name service?

1 answers

Your answer

Related

You may find useful