Error with edef and inner def,

Another possibility to avoid the problems explained by David Carlisle is to completely avoid the edef. The trick is to put the saving inside of the "called function". This is a bit similar to C, where a pointer to the allocated memory is given as the first argument to a function and is normally an input-output-parameter. This pattern can probably save a lot of trouble with LaTeX.

documentclass{article}
usepackage{etoolbox}
defmymacro#1#2{%
    defdo##1{##1}%
    csdef{#1}{#2}%
}

begin{document}
    mymacro{savedValue}{argument}%
    savedValue: savedValue
end{document}

Your code is:

documentclass{article}
defmymacro#1{%
    defdo##1{##1}%
    #1%
}

begin{document}
    edefsavedValue{mymacro{argument}}%
    savedValue: savedValue
end{document}

Two facts are relevant for the explanation:

1. When a macro is expanded whose ⟨definition text⟩ contains sequences of hashes, then the amount of hashes in these sequences will be halved in the result of expanding the macro.
   With the code of your example mymacro{⟨argument⟩} yields defdo#1{#1}⟨argument⟩. The amount of hashes in all sequences ## of the ⟨definition text⟩ of mymacro is halved to # in the result of expanding mymacro.

2. def is not expandable, therefore will not be removed from the token stream but will be left untouched during edef-expansion. (Unless an expandable control sequence is expanded during edef-expansion whose expansion yields removal of the def-token as is the case with gobble in the following: defgobble#1{} ... edeffoo{gobbledef whatsoever}.)

With edefsavedValue{mymacro{argument}} expandable tokens of the sequence mymacro{argument} are expanded until no expandable tokens are left before the assignment takes place.

def is not expandable. Therefore just expanding all expandable tokens in/coming from mymacro{argument} yields:

def⟨total expansion of all expandable tokens in the sequence "do#1{#1}argument" ⟩

If do is defined as something unexpandable, then just expanding all expandable tokens in/coming from mymacro{argument} yields the token-sequence:
defdo#1{#1}argument.

The likelihood is very high that the token-sequence that comes into being during edef-expansion as the expanded ⟨definition text⟩ contains #1 although the ⟨parameter text⟩ of the edef-definition of savedValue is empty/does not introduce an argument #1.

That's why you get the error Illegal parameter number in definition of savedValue.

In case do is undefined, you will get the error

! Undefined control sequence.
mymacro #1->def do

prior to the error Illegal parameter number in definition of savedValue.

---

---

The following example might provide better understanding of how edef works:

documentclass{article}
defmymacro#1{%
  defdo{#1}%
}
begin{document}
letdo=relax 
edefmacro{mymacro{bar}}
showmacro
letfoo=relax
defdo{foo}%
edefmacro{mymacro{bar}}
showmacro
deffoo{hoo}%
lethoo=relax
edefmacro{mymacro{bar}}
showmacro
end{document}    

Console output:

[...]
> macro=macro:
->def do {bar}.
l.8 showmacro
               
? 
> macro=macro:
->def foo {bar}.
l.12 showmacro
                
? 
> macro=macro:
->def hoo {bar}.
l.16 showmacro
                
? 
[...]

The following example might provide better understanding of the treatment of sequences of hashes during expansion:

documentclass{article}

makeatletter
newcommandstringifytillrelax[1]{%
  ifxrelax#1expandafter@firstoftwoelseexpandafter@secondoftwofi
  {}{string#1stringifytillrelax}
}%
makeatother

begin{document}
defmymacro{##}%
message{^^JSee the amount of hashes that comes from expanding stringmymacro: expandafterstringifytillrelaxmymacrorelax}%
defmymacro{####}%
message{^^JSee the amount of hashes that comes from expanding stringmymacro: expandafterstringifytillrelaxmymacrorelax}%
defmymacro{######}%
message{^^JSee the amount of hashes that comes from expanding stringmymacro: expandafterstringifytillrelaxmymacrorelax}%
defmymacro{########}%
message{^^JSee the amount of hashes that comes from expanding stringmymacro: expandafterstringifytillrelaxmymacrorelax}%
edefmymacrob{mymacro}
message{^^JSee the amount of hashes that comes from expanding stringmymacrob: expandafterstringifytillrelaxmymacrobrelax}%
edefmymacroc{mymacrob}
message{^^JSee the amount of hashes that comes from expanding stringmymacroc: expandafterstringifytillrelaxmymacrocrelax}%
end{document}    

Console output:

[...]
See the amount of hashes that comes from expanding mymacro: # 

See the amount of hashes that comes from expanding mymacro: ## 

See the amount of hashes that comes from expanding mymacro: ### 

See the amount of hashes that comes from expanding mymacro: #### 

See the amount of hashes that comes from expanding mymacrob: ## 

See the amount of hashes that comes from expanding mymacroc: #
[...]