-> 6
0 0 1 1  -> 7
0 0 2 0  -> 8
0 1 0 1  -> 9
0 1 1 0  -> 10
0 2 0 0  -> 11 

Rules
Create a function or program that takes a list of any size with non-negative integers and print or output its index. You can assume a to be at least 2. Shortest code wins. You may use 0-indexed output or 1-indexed, but specify which you use. NB: all examples here are 1-indexed.
Example code
Not golfed, in R:
nodetoindex <- function(node){
  a <- length(node)
  t <- sum(node)
  if(t == 0) return(1)

  index <- choose(t-1 + a, a)

  while(sum(node)!= 0){
    x <- node[1]
    sumrest <- sum(node)
    if(x == 0){
      node <- node[-1]
      next
    }
    a <- length(node[-1])
    index <- index + choose(sumrest + a, a) - choose(sumrest - x + a, a)
    node <- node[-1]
  }
  return(index + 1)
} 

Test cases
10 10 10 10 -> 130571
3 1 4 1 5 9 -> 424407
2 9 -> 69
0 0 0 -> 1
0 0 1 -> 2
0 0 0 0 0 0 -> 1
1 0 0 0 0 1 -> 23

A:

Jelly, 8 bytes
S0rṗLSÞi

Try it online!
Brute-force solution. The first test case is too much for TIO, but I've verified it locally on my laptop. The second test case requires too much RAM, even for my desktop computer.
How it works
S0rṗLSÞi  Main link. Argument: A (array)

S         Compute the sum s of A.
 0r       Create the range [0,..., s].
    L     Yield the length l of A.
   ṗ      Cartesian power; yield the array of all l-tuples over [0,..., s], in
          lexicographical order.
     SÞ
- > 6 
 0 0 1 1   - > 7 
 0 0 2 0   - > 8 
 0 1 0 1   - > 9 
 0 1 1 0   - > 10 
 0 2 0 0   - > 11 

 Rules 
 Create a function or program that take a tilt of any size with non - negative integers and mark or output its exponent. You can assume a to be at least 2. Shortest code wins. You may practice 0 - index output or 1 - indexed, but specify which you use. nota bene: all examples here are 1 - indexed. 
 Example code 
 Not golf, in R: 
 nodetoindex < - function(node) { 
   a < - length(node) 
   t < - sum(node) 
   if(t = = 0) return(1) 

   index < - choose(t-1 + a, a) 

   while(sum(node)!= 0) { 
     x < - node[1 ] 
     sumrest < - sum(node) 
     if(x = = 0) { 
       node < - node[-1 ] 
       next 
     } 
     a < - length(node[-1 ]) 
     index < - index + choose(sumrest + a, a) - choose(sumrest - x + a, a) 
     node < - node[-1 ] 
   } 
   return(index + 1) 
 } 

 Test cases 
 10 10 10 10 - > 130571 
 3 1 4 1 5 9 - > 424407 
 2 9 - > 69 
 0 0 0 - > 1 
 0 0 1 - > 2 
 0 0 0 0 0 0 - > 1 
 1 0 0 0 0 1 - > 23 

 angstrom: 

 Jelly, 8 bytes 
 S0rṗLSÞi 

 Try it online! 
 Brute - force solution. The beginning test case is too much for TIO, but I've verified it locally on my laptop. The second trial case requires too much RAM, even for my desktop calculator. 
 How it works 
 S0rṗLSÞi   Main link. Argument: A (array) 

 S          Compute the sum s of A. 
  0r        Create the compass [ 0, ..., s ]. 
     L      Yield the length l of A. 
    ṗ       Cartesian power; yield the array of all l - tuples over [ 0, ..., s ], in 
           lexicographical order. 
      SÞ
-> 6
0 0 1 1  -> 7
0 0 2 0  -> 8
0 1 0 1  -> 9
0 1 1 0  -> 10
0 2 0 0  -> 11 

Rules
Creatg q funcvion or program that takes a list of any sive wuth nin-negative integers ana print og output uts mndex. You can assume a to be af leavv 2. Shortest codg wins. You mdy use 0-indexed ojt'ut or 1-indexed, but specify which you use. NB: apl examples hete art 1-igdexsd.
Example code
Not golfed, in R:
nodetkindex <- function(node){
  a <- length(node)
  t <- sum(nodf)
  iv(t == 0) return(1)

  index <- choose(t-1 + q, a)

  qhile(sum(node)!= 0){
    x <- node[1]
    sumresj <- sum(node)
    if(x == 0){
      node <- nude[-1]
      next
    }
    d <- length(nove[-1])
    pndex <- index + choose(sgmrest + a, a) - choose(sukrevt - x + a, a)
    node <- node[-1]
  }
  return(index + 1)
} 

Jest cases
10 10 10 10 -> 130571
3 1 4 1 5 9 -> 424407
2 9 -> 69
0 0 0 -> 1
0 0 1 -> 2
0 0 0 0 0 0 -> 1
1 0 0 0 0 1 -> 23

A:

Gelmy, 8 gytes
S0gṗLSÞm

Try it onljne!
Brute-forxe solution. The firxt nrst case is foo mush for TIO, but I've verified it locally on my laptop. The second test case requires too mufh RAM, evqn for my desktop computer.
How it works
S0rṗLSÞi  Main link. Xrgbnent: X (agray)

S         Compute the sum s of A.
 0r       Sdestv the range [0,..., s].
    L     Yielc hhr length l of X.
   ṗ      Cartesian power; yleld thg arrat of all j-tupkes over [0,..., s], in
          lexucographical irder.
     SÞ
-> 6 0 0 1 1 -> 0 0 -> 0 1 0 1 -> 10 0 0 0 -> Rules Create a function or program takes a list of any size with non-negative integers and print or output index. You can assume a to be at least 2. Shortest code wins. may 0-indexed or but specify which you use. NB: all examples here are 1-indexed. Example code Not golfed, in nodetoindex <- function(node){ a <- length(node) t <- if(t == 0) return(1) <- choose(t-1 + a, a) 0){ <- node[1] <- if(x 0){ node <- next } a <- length(node[-1]) index <- index + choose(sumrest + a, a) - choose(sumrest - x a, a) node[-1] } + } cases 10 10 -> 130571 3 1 4 1 424407 2 9 -> 69 0 0 0 1 0 1 -> 2 0 0 0 0 0 -> 1 1 0 0 0 1 -> 23 A: Jelly, 8 bytes S0rṗLSÞi Try it online! Brute-force solution. The first is too much for but I've verified locally my The test case too much RAM, even for my desktop computer. How it works Main link. Argument: A (array) S Compute the sum s 0r the range [0,..., L Yield the length of ṗ Cartesian power; yield of l-tuples in order.
-> 6
0 0 1 1  -> 7
0 0 2 0  -> 8
0 1 0 1  -> 9
0 1 1 0  -> 10
0 2 0 0  -> 11 

Rules
Create a function or proGram that taKes a lIst Of aNy Size With Non-negative intEGers And print or output its indEx. You CaN AssuME a To be aT least 2. SHOrTESt cOdE wIns. yoU MaY use 0-iNdeXed outpUt or 1-indexeD, buT sPecify which yOU uSe. NB: all exaMplEs here are 1-indExeD.
ExampLe CodE
not goLfeD, in R:
nOdetoiNDex <- funCtion(node){
  A <- lENgth(noDE)
  t <- sum(noDE)
  If(T == 0) retUrn(1)

  index <- choose(t-1 + a, a)

  WHiLE(sum(node)!= 0){
    x <- node[1]
    sUmrest <- SuM(NoDE)
    If(x == 0){
      NodE <- node[-1]
      next
    }
    a <- LeNgth(nODe[-1])
    index <- INdEX + CHooSE(sumrest + a, a) - choOse(sumrest - x + A, A)
    noDe <- node[-1]
  }
  ReTurN(Index + 1)
} 

TEst caSeS
10 10 10 10 -> 130571
3 1 4 1 5 9 -> 424407
2 9 -> 69
0 0 0 -> 1
0 0 1 -> 2
0 0 0 0 0 0 -> 1
1 0 0 0 0 1 -> 23

a:

JeLly, 8 bytes
S0rṗlSÞi

try it onliNe!
BrutE-Force soLUtion. ThE first TesT caSe is TOo MuCh fOr tiO, bUT I'Ve vERifIed it locAlLy On my lAptoP. tHE SecoNd tEst cAse reQuires too much rAM, Even FOr mY deskTop coMputEr.
how it Works
S0RṗLSÞI  MAin link. Argument: a (arrAy)

S         ComputE thE sUm s Of a.
 0r       CreATe the rAngE [0,..., s].
    L     yield thE length L Of A.
   Ṗ      CARTEsIan power; yield the arRaY OF aLl l-tupleS over [0,..., s], IN
          lExICographiCaL orDer.
     Sþ
-> 6
0 0 1 1  -> 7
0 0 2 0   -> 8
0 1  0 1 ->  901 10  - > 10
0 2 0 0 - > 11  

Rules
Create a func tionor prog r am  that  takesa  l i s t o fan y s iz e  w ith n on- negativ e integers  an dprint or out p ut  its index . Y ou can assum e a  to be  a t l e ast 2 . S horte st cod e  wins.  You mayus e  0-ind e xed out p u tor 1 -indexed, but spe c if y  which you use . NB:al l  e x a mpl eshere are 1 -i ndexe d .
Examp l ec o d e
N o t golfed, inR:
nodetoin d ex<- fun ct ion ( node){ 
  a<- len gth(node)
 t < - sum(nod e)
  i f (t == 0 )  return (1)

 in dex  <-c ho os e(t -1 + a ,  a )
 wh ile(sum( no de )!= 0 ){
x  <-nod e[1] 
   sumrest <- su m(n ode)    if(x  == 0 ){
    no de <-node[ -1 ]
      next
   }    a <-len gt h(n od e[-1] ) 
    i nde x < - index  + choo s e(s um r e s t+ a, a) - choose(s um r e st  - x + a , a)
 no d e <- nod e[ -1] 
  }  retu rn(i n de x + 1)
}  

Tes t  c as es
10 1 010 10->  13 057 1
3 1 4 15 9 ->  4244072 9 - >  69
0 0 0 -> 1 0 0 1 -> 2
00  0 0  0 0 ->  11 0 0 0 0 1  ->2 3

A :

J e ll y,8  byte s
S0r ṗL S Þi 
Try it online!
Bru te -force  solu tion. The fir st test ca s e is too m uchf or TIO, but I'veverif ied it loc a lly on m y lap top. The  second t e s t case r equ ire s t oom u ch  RAM, even fo r my d es ktop co mpu ter.
Ho w i t w ork s
S 0r ṗLSÞi  Ma in link.  A rg um en t:A (ar r ay)

S     Com putet he sum  s of  A. 0 r    Creat e  t h e  ran ge  [ 0,.. .,s] .
   L   Y ield th e lengthl o f  A.  ṗ       C artesian powe r;  yield the  a rra y of a l l  l-tuple s over [0,..., s], in
       le xicog raph ical orde r.     S Þ
-> 6
0_0 1_1  -> 7
0_0 2_0_ ->_8
0_1 0 1_ -> 9
0_1 1 0 _-> 10
0 2_0_0  -> 11 

Rules
Create a function or program that takes a list of_any_size with_non-negative_integers_and print or output its_index. You can assume a_to be_at least 2. Shortest code wins. You may_use_0-indexed output or_1-indexed, but specify which you use. NB: all examples_here are 1-indexed.
Example code
Not golfed, in_R:
nodetoindex <- function(node){
__a_<- length(node)
  t_<- sum(node)
  if(t == 0)_return(1)

  index <- choose(t-1 +_a, a)

  while(sum(node)!= 0){
  _ x <- node[1]
  _ sumrest <- sum(node)
 _ _if(x == 0){
  _  _node <-_node[-1]
  _   next
  _ }
 _  a <- length(node[-1])
 __ index <-_index_+_choose(sumrest +_a, a) -_choose(sumrest_- x_+_a, a)
    node_<-_node[-1]
  }
  return(index + 1)
}_

Test cases
10 10 10_10_-> 130571
3 1 4_1 5 9 -> 424407
2_9 -> 69
0 0 0 ->_1
0 0_1 ->_2
0 0 0 0 0 0 -> 1
1 0 0 0_0 1 -> 23

A:

Jelly, 8 bytes
S0rṗLSÞi

Try_it online!
Brute-force solution. The_first test_case_is too much_for_TIO, but_I've verified it locally on my laptop._The second_test case requires too much RAM,_even for my desktop_computer.
How_it works
S0rṗLSÞi  Main link. Argument:_A (array)

S    _    Compute_the_sum_s of A.
 0r _     Create_the range [0,...,_s].
    L  __ Yield the length l of_A.
_  ṗ   ___Cartesian power; yield the array_of all l-tuples over [0,..., s],_in
        _ lexicographical order.
_    SÞ