Charcoal, 30 29 bytes

ＮθＮηＩＥＸθηＥ﹪÷ιＸθ⮌…⁰η⊗θ⌊⟦⁻⊖⊗θλλ

Try it online! Link is to verbose version of code. Outputs each digit of the gray code as a base 10 number on its own line, with each gray code double-spaced from the next. Explanation:

Ｎθ                              Input `N` as a number
  Ｎη                            Input `k` as a number
       θ                        Input `N`
      Ｘ                         To the power of
        η                       Input `k`
     Ｅ                          Map over implicit range
            ι                   Current value
           ÷                    Vectorised integer divide
              θ                 Input `N`
             Ｘ                  Vectorised to power
                …               Range from
                 ⁰              Literal integer `0`
                  η             To input `k`
               ⮌                Reversed
          ﹪                     Vectorised modulo
                    θ           Input `N`
                   ⊗            Doubled
         Ｅ                      Map over list
                          θ     Input `N`
                         ⊗      Doubled
                        ⊖       Decremented
                       ⁻        Subtract
                           λ    Current value
                     ⌊⟦         Minimum of that and
                            λ   Current value
    Ｉ                           Cast to string
                                Implicitly print

If omission of leading zeros is allowed then for 28 bytes:

ＮθＮηＩＥＥＸθη↨ιθＥι⎇﹪↨…ιμθ²⁻⊖θλλ

Try it online! Link is to verbose version of code. Explanation:

Ｎθ                              Input `N` as a number
  Ｎη                            Input `k` as a number
        θ                       Input `N`
       Ｘ                        To the power of
         η                      Input `k`
      Ｅ                         Map over implicit range
           ι                    Current value
          ↨                     Converted to base
            θ                   Input `N`
     Ｅ                          Map over base `N` values
              ι                 Current base `N` value
             Ｅ                  Map over base `N` digits
                  …ιμ           Current prefix
                 ↨              Convert from base
                     θ          Input `N`
                ﹪               Modulo
                      ²         Literal integer `2`
               ⎇                If odd then
                         θ      Input `N`
                        ⊖       Decremented
                       ⁻        Subtract
                          λ     Current digit
                           λ    Else current digit
    Ｉ                           Cast to string
                                Implicitly print

(Note that all leading zeros are omitted, so the first gray code is empty.)

Charcoal, 30 29 28 bytes

ＮθＮηＩＥＸθηＥ÷ιＸθ⮌…⁰η⌊﹪⟦⊖±λλ⟧⊗θ

Try it online! Link is to verbose version of code. Outputs each digit of the gray code as a base 10 number on its own line, with each gray code double-spaced from the next. Explanation:

Ｎθ                              Input `N` as a number
  Ｎη                            Input `k` as a number
       θ                        Input `N`
      Ｘ                         To the power of
        η                       Input `k`
     Ｅ                          Map over implicit range
           ι                    Current value
          ÷                     Vectorised integer divide
             θ                  Input `N`
            Ｘ                   Vectorised to power
               …                Range from
                ⁰               Literal integer `0`
                 η              To input `k`
              ⮌                 Reversed
         Ｅ                      Map over list
                       λ        Current value
                      ±         Negated
                     ⊖          Decremented
                    ⟦    ⟧      List of that and
                        λ       Current value
                   ﹪            Vectorised modulo
                           θ    Input `N`
                          ⊗     Doubled
                  ⌊             Take the minimum
    Ｉ                           Cast to string
                                Implicitly print

Ｎθ                              Input `N` as a number
  Ｎη                            Input `k` as a number
       θ                        Input `N`
      Ｘ                         To the power of
        η                       Input `k`
     Ｅ                          Map over implicit range
            ι                   Current value
           ÷                    Vectorised integer divide
              θ                 Input `N`
             Ｘ                  Vectorised to power
                …               Range from
                 ⁰              Literal integer `0`
                  η             To input `k`
               ⮌                Reversed
          ﹪                     Vectorised modulo
                    θ           Input `N`
                   ⊗            Doubled
         Ｅ                      Map over list
                          θ     Input `N`
                         ⊗      Doubled
                        ⊖       Decremented
                       ⁻        Subtract
                           λ    Current value
                     ⌊⟦         Minimum of that and
                            λ   Current value
          ⮌                     Reversed
    Ｉ                           Cast to string
                                Implicitly print

Ｎθ                              Input `N` as a number
  Ｎη                            Input `k` as a number
       θ                        Input `N`
      Ｘ                         To the power of
        η                       Input `k`
     Ｅ                          Map over implicit range
            ι                   Current value
           ÷                    Vectorised integer divide
              θ                 Input `N`
             Ｘ                  Vectorised to power
                …               Range from
                 ⁰              Literal integer `0`
                  η             To input `k`
               ⮌                Reversed
          ﹪                     Vectorised modulo
                    θ           Input `N`
                   ⊗            Doubled
         Ｅ                      Map over list
                          θ     Input `N`
                         ⊗      Doubled
                        ⊖       Decremented
                       ⁻        Subtract
                           λ    Current value
                     ⌊⟦         Minimum of that and
                            λ   Current value
    Ｉ                           Cast to string
                                Implicitly print

Try it online! Link is to verbose version of code. Outputs each digit of the gray code as a base 10 number on its own line, with each gray code double-spaced from the next. Explanation:

Try it online! Link is to verbose version of code. Outputs each digit of the gray code as a base 10 number on its own line, with each gray code double-spaced from the next. Explanation: