3 files changed, 64 insertions, 35 deletions

diff --git a/Base58.hs b/Base58.hs
index 26f1cb2..8adf60d 100644
--- a/Base58.hs
+++ b/Base58.hs
@@ -35,3 +35,18 @@ base58_decode str = do
     guard (hash_result==expected_hash)
     return (network_id,payload)
 
+base58_encode :: S.ByteString -> String
+base58_encode hash = replicate zcount '1' ++ map (base58chars !!) (reverse rdigits)
+  where
+    zcount = S.length . S.takeWhile (==0) $ hash
+    cksum = S.take 4 . SHA256.hash . SHA256.hash $ hash
+    n = foldl' (\a b->a*256+b) 0 . map asInteger $ concatMap S.unpack [hash, cksum]
+    asInteger x = fromIntegral x :: Integer
+    rdigits = unfoldr getdigit n
+     where
+        getdigit d = do
+            guard (d/=0)
+            let (q,b) = d `divMod` 58
+            return (fromIntegral b,q)
+
+
diff --git a/KeyRing.hs b/KeyRing.hs
index 2d92c7e..d95db08 100644
--- a/KeyRing.hs
+++ b/KeyRing.hs
@@ -30,8 +30,8 @@ import Data.ASN1.Encoding ( encodeASN1, encodeASN1', decodeASN1' )
 import Data.ASN1.BinaryEncoding ( DER(..) )
 import Data.Time.Clock.POSIX ( getPOSIXTime )
 import qualified Data.Map as Map
-import qualified Data.ByteString.Lazy as L ( null, readFile, ByteString )
-import qualified Data.ByteString      as S ( unpack )
+import qualified Data.ByteString.Lazy as L ( null, readFile, ByteString, toChunks )
+import qualified Data.ByteString      as S ( unpack, splitAt, concat, cons )
 import qualified Data.ByteString.Lazy.Char8 as Char8 ( span, unpack, break ) 
 import qualified Crypto.Types.PubKey.ECC as ECC
 import qualified Codec.Binary.Base32 as Base32
@@ -40,6 +40,8 @@ import qualified Data.Text as T ( Text, unpack, pack,
         strip, reverse, drop, break, dropAround )
 import System.Posix.Types (EpochTime)
 import System.Posix.Files ( modificationTime, getFileStatus )
+import System.IO (hPutStrLn,withFile,IOMode(..))
+import Data.Binary ( encode )
 
 import qualified CryptoCoins as CryptoCoins
 import Base58
@@ -596,18 +598,53 @@ getCryptoCoinTag p | isSignaturePacket p = do
 getCryptoCoinTag _ = Nothing
 
 
+coinKeysOwnedBy :: KeyDB -> Maybe Packet -> [(CryptoCoins.CoinNetwork,MappedPacket)]
+coinKeysOwnedBy db wk = do
+    wk <- maybeToList wk
+    let kk = keykey wk
+    KeyData top topsigs uids subs <- maybeToList $ Map.lookup kk db
+    (subkk,SubKey mp sigs) <- Map.toList subs
+    let sub = packet mp
+    guard $ isCryptoCoinKey sub
+    tag <- take 1 $ mapMaybe getCryptoCoinTag (map (packet . fst) sigs)
+    return (tag,mp)
+
+walletImportFormat idbyte k = secret_base58_foo
+ where
+    -- isSecret (SecretKeyPacket {}) = True
+    -- isSecret _                    = False
+    secret_base58_foo = base58_encode seckey
+    Just d = lookup 'd' (key k)
+    (_,bigendian) = S.splitAt 2 (S.concat $ L.toChunks $ encode d)
+    seckey = S.cons idbyte bigendian
+
+
 writeWalletKeys :: KeyRingData -> KeyDB -> Maybe Packet -> IO (KikiCondition [(FilePath,KikiReportAction)])
 writeWalletKeys krd db wk = do
-    let all_crypto_keys = do
-            wk <- maybeToList wk
-            let kk = keykey wk
-            KeyData top topsigs uids subs <- maybeToList $ Map.lookup kk db
-            (subkk,SubKey mp sigs) <- Map.toList subs
-            let sub = packet mp
-            guard $ isCryptoCoinKey sub
-            tag <- take 1 $ mapMaybe getCryptoCoinTag (map (packet . fst) sigs)
-            return (tag,mp)
-    return $ KikiSuccess []
+    let cs = db `coinKeysOwnedBy` wk
+    -- export wallet keys
+        isMutableWallet (MutableRef {}) WalletFile = True
+        isMutableWallet _ _ = False
+        files pred = do
+            (f,(rtyp,ftyp)) <- Map.toList (kFiles krd)
+            guard (pred rtyp ftyp)
+            resolveInputFile "" "" f
+    let writeWallet report n = do
+        let cs' = do
+            (nw,mp) <- cs
+            -- let fns = Map.keys (locations mp)
+            -- trace ("COIN KEY: "++show fns) $ return ()
+            guard . not $ Map.member n (locations mp)
+            let wip = walletImportFormat (CryptoCoins.private_byte_id nw) (packet mp)
+            return (CryptoCoins.network_name nw,wip)
+        handleIO_ (return report) $ do
+        withFile n AppendMode $ \fh -> do
+        rs <- forM cs' $ \(net,wip) -> do
+            hPutStrLn fh wip
+            return (n, NewWalletKey net)
+        return (report ++ rs)
+    report <- foldM writeWallet [] (files isMutableWallet)
+    return $ KikiSuccess report
 
 runKeyRing :: KeyRingData -> (KeyRingRuntime -> a) -> IO (KikiResult a)
 runKeyRing keyring op = do
diff --git a/kiki.hs b/kiki.hs
index 9c748e5..4daff67 100644
--- a/kiki.hs
+++ b/kiki.hs
@@ -1109,29 +1109,6 @@ secp256k1_G = ECPa secp256k1_curve
     -}
 -}
 
-walletImportFormat idbyte k = secret_base58_foo
- where
-    -- isSecret (SecretKeyPacket {}) = True
-    -- isSecret _                    = False
-    secret_base58_foo = base58_encode seckey
-    Just d = lookup 'd' (key k)
-    (_,bigendian) = S.splitAt 2 (S.concat $ L.toChunks $ encode d)
-    seckey = S.cons idbyte bigendian
-
-
-base58_encode :: S.ByteString -> String
-base58_encode hash = replicate zcount '1' ++ map (base58chars !!) (reverse rdigits)
-  where
-    zcount = S.length . S.takeWhile (==0) $ hash
-    cksum = S.take 4 . SHA256.hash . SHA256.hash $ hash
-    n = foldl' (\a b->a*256+b) 0 . map asInteger $ concatMap S.unpack [hash, cksum]
-    asInteger x = fromIntegral x :: Integer
-    rdigits = unfoldr getdigit n
-     where
-        getdigit d = do
-            guard (d/=0)
-            let (q,b) = d `divMod` 58
-            return (fromIntegral b,q)
 
 cannonical_eckey x y = 0x4:pad32(numToBytes x) ++ pad32(numToBytes y) :: [Word8]
  where