@@ -31,6 +31,76 @@ pub fn decode(input: &str) -> Result<Vec<u8>> {
3131 base_decode ( ALPHABET , input. as_bytes ( ) )
3232}
3333
34+ fn base_encode ( alphabet_s : & str , input : & [ u8 ] ) -> Vec < u8 > {
35+ let alphabet = alphabet_s. as_bytes ( ) ;
36+ let base = alphabet. len ( ) as u32 ;
37+
38+ let mut digits = vec ! [ 0u8 ] ;
39+ for input in input. iter ( ) {
40+ let mut carry = * input as u32 ;
41+ for digit in digits. iter_mut ( ) {
42+ carry += ( * digit as u32 ) << 8 ;
43+ * digit = ( carry % base) as u8 ;
44+ carry /= base;
45+ }
46+
47+ while carry > 0 {
48+ digits. push ( ( carry % base) as u8 ) ;
49+ carry /= base;
50+ }
51+ }
52+
53+ let mut string = vec ! [ ] ;
54+
55+ let mut k = 0 ;
56+ while ( k < input. len ( ) ) && ( input[ k] == 0 ) {
57+ string. push ( alphabet[ 0 ] ) ;
58+ k += 1 ;
59+ }
60+ for digit in digits. iter ( ) . rev ( ) {
61+ string. push ( alphabet[ * digit as usize ] ) ;
62+ }
63+
64+ string
65+ }
66+
67+ fn base_decode ( alphabet_s : & str , input : & [ u8 ] ) -> Result < Vec < u8 > > {
68+ let alphabet = alphabet_s. as_bytes ( ) ;
69+ let base = alphabet. len ( ) as u32 ;
70+
71+ let mut bytes: Vec < u8 > = vec ! [ 0 ] ;
72+ let zcount = input. iter ( ) . take_while ( |x| * * x == alphabet[ 0 ] ) . count ( ) ;
73+
74+ for ( i, input) in input[ zcount..] . iter ( ) . enumerate ( ) {
75+ let value = match alphabet. iter ( ) . position ( |& x| x == * input) {
76+ Some ( idx) => idx,
77+ None => return Err ( Error :: UnknownSymbol ( i) ) ,
78+ } ;
79+ let mut carry = value as u32 ;
80+ for byte in bytes. iter_mut ( ) {
81+ carry += ( * byte as u32 ) * base;
82+ * byte = carry as u8 ;
83+ carry >>= 8 ;
84+ }
85+
86+ while carry > 0 {
87+ bytes. push ( carry as u8 ) ;
88+ carry >>= 8 ;
89+ }
90+ }
91+ let leading_zeros = bytes. iter ( ) . rev ( ) . take_while ( |x| * * x == 0 ) . count ( ) ;
92+ if zcount > leading_zeros {
93+ let unpad = if leading_zeros > 0 {
94+ leading_zeros + 1
95+ } else {
96+ 0
97+ } ;
98+ bytes. resize ( bytes. len ( ) + zcount - unpad, 0 ) ;
99+ }
100+ bytes. reverse ( ) ;
101+ Ok ( bytes)
102+ }
103+
34104/// decode from base58 the given input
35105//pub fn decode_bytes(input: &[u8]) -> Result<Vec<u8>> {
36106// base_decode(ALPHABET, input)
@@ -101,73 +171,3 @@ mod tests {
101171 ) ;
102172 }
103173}
104-
105- fn base_encode ( alphabet_s : & str , input : & [ u8 ] ) -> Vec < u8 > {
106- let alphabet = alphabet_s. as_bytes ( ) ;
107- let base = alphabet. len ( ) as u32 ;
108-
109- let mut digits = vec ! [ 0u8 ] ;
110- for input in input. iter ( ) {
111- let mut carry = * input as u32 ;
112- for digit in digits. iter_mut ( ) {
113- carry += ( * digit as u32 ) << 8 ;
114- * digit = ( carry % base) as u8 ;
115- carry /= base;
116- }
117-
118- while carry > 0 {
119- digits. push ( ( carry % base) as u8 ) ;
120- carry /= base;
121- }
122- }
123-
124- let mut string = vec ! [ ] ;
125-
126- let mut k = 0 ;
127- while ( k < input. len ( ) ) && ( input[ k] == 0 ) {
128- string. push ( alphabet[ 0 ] ) ;
129- k += 1 ;
130- }
131- for digit in digits. iter ( ) . rev ( ) {
132- string. push ( alphabet[ * digit as usize ] ) ;
133- }
134-
135- string
136- }
137-
138- fn base_decode ( alphabet_s : & str , input : & [ u8 ] ) -> Result < Vec < u8 > > {
139- let alphabet = alphabet_s. as_bytes ( ) ;
140- let base = alphabet. len ( ) as u32 ;
141-
142- let mut bytes: Vec < u8 > = vec ! [ 0 ] ;
143- let zcount = input. iter ( ) . take_while ( |x| * * x == alphabet[ 0 ] ) . count ( ) ;
144-
145- for ( i, input) in input[ zcount..] . iter ( ) . enumerate ( ) {
146- let value = match alphabet. iter ( ) . position ( |& x| x == * input) {
147- Some ( idx) => idx,
148- None => return Err ( Error :: UnknownSymbol ( i) ) ,
149- } ;
150- let mut carry = value as u32 ;
151- for byte in bytes. iter_mut ( ) {
152- carry += ( * byte as u32 ) * base;
153- * byte = carry as u8 ;
154- carry >>= 8 ;
155- }
156-
157- while carry > 0 {
158- bytes. push ( carry as u8 ) ;
159- carry >>= 8 ;
160- }
161- }
162- let leading_zeros = bytes. iter ( ) . rev ( ) . take_while ( |x| * * x == 0 ) . count ( ) ;
163- if zcount > leading_zeros {
164- let unpad = if leading_zeros > 0 {
165- leading_zeros + 1
166- } else {
167- 0
168- } ;
169- bytes. resize ( bytes. len ( ) + zcount - unpad, 0 ) ;
170- }
171- bytes. reverse ( ) ;
172- Ok ( bytes)
173- }
0 commit comments