What impact has uniqueness constraint jsonb on postgres db performance

risk of json uniqueness when it comes to dicts (order of keys is not guaranteed)

JSONB does guarantee the order of keys. It also ignores insignificant whitespace and deduplicates the keys it's sorting internally. What you plan to do will work just fine.

I'd be worried if you wanted to use plain json which works pretty much like pre-validated text and does hold on to everything you save into it, making {"a":1} and { "a" : 1 } unequal. Also, for that reason, there's no built-in json=json operator, so you wouldn't be able to define a unique column of type json.

Because the json type stores an exact copy of the input text, it will preserve semantically-insignificant white space between tokens, as well as the order of keys within JSON objects. Also, if a JSON object within the value contains the same key more than once, all the key/value pairs are kept. (The processing functions consider the last value as the operative one.) By contrast, jsonb does not preserve white space, does not preserve the order of object keys, and does not keep duplicate object keys. If duplicate keys are specified in the input, only the last value is kept.

("does not preserve the order" refers to the input order - it'll reorder that in a stable, deterministic manner, to guarantee the uniform order of keys)

In terms of performance, you have to test it yourself and see if you find it acceptable. Enforcing the constraint will always incur some costs, it's not free by any means - unique is backed by an index, so all operations on the table require maintaining both the table as well as the index.

_{demo at db<>fiddle}

select '{"a":1}'::jsonb = E' {\n\t "a" : 1 \n} '::jsonb

select '{"a":1}'::json = E' {\n\t "a" : 1 \n} '::json;

ERROR:  operator does not exist: json = json
LINE 1: select '{"a":1}'::json = E' {\n\t "a" : 1 \n} '::json;
                               ^
HINT:  No operator matches the given name and argument types. You might need to add explicit type casts.

create table test_no_unique(a jsonb);
select setseed(.42);

explain analyze verbose
insert into test_no_unique 
select jsonb_build_object(n::text,n)
from generate_Series(1,1e5)n;

create table test_unique_no_onconflict(a jsonb unique);
select setseed(.42);

explain analyze verbose
insert into test_unique_no_onconflict 
select jsonb_build_object(n::text,n)
from generate_Series(1,1e5)n;

create table test_unique_on_conflict_do_nothing_without_dupes(a jsonb unique);
select setseed(.42);

explain analyze verbose
insert into test_unique_on_conflict_do_nothing_without_dupes 
select jsonb_build_object(n::text,n)
from generate_Series(1,1e5)n
on conflict do nothing;

Here, note that it cost a bit to call random() and do the casts compared to previous examples, it cost some to handle the conflicts, but it also saved some simply by effectively writing 36% less rows into the table.

create table test_unique_on_conflict_do_nothing_with_dupes(a jsonb unique);
select setseed(.42);

explain analyze verbose
insert into test_unique_on_conflict_do_nothing_with_dupes 
select jsonb_build_object((random()*1e3)::int::text,(random()*1e2)::int::text)
from generate_Series(1,1e5)n
on conflict do nothing;