@bitgo-beta/sdk-coin-rune 1.0.0-beta.152 → 1.0.0-beta.1521

package/dist/test/resources/trune.d.ts

@@ -0,0 +1,110 @@
+export declare const TEST_TX_WITH_MEMO: {
+    hash: string;
+    signature: string;
+    pubKey: string;
+    privateKey: string;
+    signedTxBase64: string;
+    sender: string;
+    recipient: string;
+    chainId: string;
+    accountNumber: number;
+    sequence: number;
+    memo: string;
+    sendAmount: string;
+    feeAmount: string;
+    sendMessage: {
+        typeUrl: string;
+        value: {
+            amount: {
+                denom: string;
+                amount: string;
+            }[];
+            fromAddress: string;
+            toAddress: string;
+        };
+    };
+    gasBudget: {
+        amount: {
+            denom: string;
+            amount: string;
+        }[];
+        gasLimit: number;
+    };
+};
+export declare const TEST_SEND_TX: {
+    hash: string;
+    signature: string;
+    pubKey: string;
+    privateKey: string;
+    signedTxBase64: string;
+    sender: string;
+    recipient: string;
+    chainId: string;
+    accountNumber: number;
+    sequence: number;
+    sendAmount: string;
+    feeAmount: string;
+    sendMessage: {
+        typeUrl: string;
+        value: {
+            amount: {
+                denom: string;
+                amount: string;
+            }[];
+            fromAddress: string;
+            toAddress: string;
+        };
+    };
+    gasBudget: {
+        amount: {
+            denom: string;
+            amount: string;
+        }[];
+        gasLimit: number;
+    };
+};
+export declare const testnetAddress: {
+    address1: string;
+    address2: string;
+    address3: string;
+    address4: string;
+    validatorAddress1: string;
+    validatorAddress2: string;
+    validatorAddress3: string;
+    validatorAddress4: string;
+    noMemoIdAddress: string;
+    validMemoIdAddress: string;
+    invalidMemoIdAddress: string;
+    multipleMemoIdAddress: string;
+};
+export declare const testnetCoinAmounts: {
+    amount1: {
+        amount: string;
+        denom: string;
+    };
+    amount2: {
+        amount: string;
+        denom: string;
+    };
+    amount3: {
+        amount: string;
+        denom: string;
+    };
+    amount4: {
+        amount: string;
+        denom: string;
+    };
+    amount5: {
+        amount: string;
+        denom: string;
+    };
+};
+export declare const wrwUser: {
+    senderAddress: string;
+    destinationAddress: string;
+    userPrivateKey: string;
+    backupPrivateKey: string;
+    bitgoPublicKey: string;
+    walletPassphrase: string;
+};
+//# sourceMappingURL=trune.d.ts.map

package/dist/test/resources/trune.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trune.d.ts","sourceRoot":"","sources":["../../../test/resources/trune.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgC7B,CAAC;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCxB,CAAC;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;CAa1B,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;CAM9B,CAAC;AAEF,eAAO,MAAM,OAAO;;;;;;;CAUnB,CAAC"}

package/dist/test/resources/trune.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrwUser = exports.testnetCoinAmounts = exports.testnetAddress = exports.TEST_SEND_TX = exports.TEST_TX_WITH_MEMO = void 0;
+// Get the test data by running the scripts for the particular coin from coin-sandbox repo.
+exports.TEST_TX_WITH_MEMO = {
+    hash: 'B0C1C424ABA63C7401691F7AC777D080A1C4E59594CCBC74DC4B213D747AA1F1',
+    signature: 'E4PZxdeEGQJ8In+cjPiEd979mXuQlDesucLoivVt0wljx9/0bXNeL5+2ecRironf0Fo3pa1vsBpp7wM0UNWM7A==',
+    pubKey: 'AxLtvJO7WCAT1uNYriwGyxu678ck7+0ag5Pd589dtydC',
+    privateKey: 'uz2P7K8xhtoHM1QAbXXWBx83uvyA/ulQTx4tM2qGXAE=',
+    signedTxBase64: 'ClMKTgoOL3R5cGVzLk1zZ1NlbmQSPAoUX+ummTeIOBAZHQ0YsPb1CZ040lQSFID5ph0o2N3lj2qmLDH59qRQag14Gg4KBHJ1bmUSBjEwMDAwMBIBMRJpClAKRgofL2Nvc21vcy5jcnlwdG8uc2VjcDI1NmsxLlB1YktleRIjCiEDEu28k7tYIBPW41iuLAbLG7rvxyTv7RqDk93nz123J0ISBAoCCAEYAxIVCg4KBHJ1bmUSBjEwMDAwMBCA4esXGkATg9nF14QZAnwif5yM+IR33v2Ze5CUN6y5wuiK9W3TCWPH3/Rtc14vn7Z5xGKuid/QWjelrW+wGmnvAzRQ1Yzs',
+    sender: 'sthor1tl46dxfh3qupqxgap5vtpah4pxwn35j5tnjzls',
+    recipient: 'sthor1sru6v8fgmrw7trm25ckrr70k53gx5rtc4xhfgf',
+    chainId: 'thorchain-stagenet-2',
+    accountNumber: 15,
+    sequence: 3,
+    memo: '1',
+    sendAmount: '100000',
+    feeAmount: '100000',
+    sendMessage: {
+        typeUrl: '/types.MsgSend',
+        value: {
+            amount: [
+                {
+                    denom: 'rune',
+                    amount: '100000',
+                },
+            ],
+            fromAddress: 'sthor1tl46dxfh3qupqxgap5vtpah4pxwn35j5tnjzls',
+            toAddress: 'sthor1sru6v8fgmrw7trm25ckrr70k53gx5rtc4xhfgf',
+        },
+    },
+    gasBudget: {
+        amount: [{ denom: 'rune', amount: '100000' }],
+        gasLimit: 50000000,
+    },
+};
+exports.TEST_SEND_TX = {
+    hash: 'FA4635875A1A0E9175126AA6FF5D50B943F74C23B9A1C952808F1274ABC690C8',
+    signature: 'aFAUTspGfdniC1x2Uia9VByLzSjtzzTSZKVZ7s45Otcp9cfx+kMxmjfd0VPIATKjoAOs55koaUPO3USdzVVkaQ==',
+    pubKey: 'AxLtvJO7WCAT1uNYriwGyxu678ck7+0ag5Pd589dtydC',
+    privateKey: 'uz2P7K8xhtoHM1QAbXXWBx83uvyA/ulQTx4tM2qGXAE=',
+    signedTxBase64: 'ClAKTgoOL3R5cGVzLk1zZ1NlbmQSPAoUX+ummTeIOBAZHQ0YsPb1CZ040lQSFID5ph0o2N3lj2qmLDH59qRQag14Gg4KBHJ1bmUSBjEwMDAwMBJpClAKRgofL2Nvc21vcy5jcnlwdG8uc2VjcDI1NmsxLlB1YktleRIjCiEDEu28k7tYIBPW41iuLAbLG7rvxyTv7RqDk93nz123J0ISBAoCCAEYBBIVCg4KBHJ1bmUSBjEwMDAwMBCA4esXGkBoUBROykZ92eILXHZSJr1UHIvNKO3PNNJkpVnuzjk61yn1x/H6QzGaN93RU8gBMqOgA6znmShpQ87dRJ3NVWRp',
+    sender: 'sthor1tl46dxfh3qupqxgap5vtpah4pxwn35j5tnjzls',
+    recipient: 'sthor1sru6v8fgmrw7trm25ckrr70k53gx5rtc4xhfgf',
+    chainId: 'thorchain-stagenet-2',
+    accountNumber: 15,
+    sequence: 4,
+    sendAmount: '100000',
+    feeAmount: '100000',
+    sendMessage: {
+        typeUrl: '/types.MsgSend',
+        value: {
+            amount: [
+                {
+                    denom: 'rune',
+                    amount: '100000',
+                },
+            ],
+            fromAddress: 'sthor1tl46dxfh3qupqxgap5vtpah4pxwn35j5tnjzls',
+            toAddress: 'sthor1sru6v8fgmrw7trm25ckrr70k53gx5rtc4xhfgf',
+        },
+    },
+    gasBudget: {
+        amount: [
+            {
+                denom: 'rune',
+                amount: '100000',
+            },
+        ],
+        gasLimit: 50000000,
+    },
+};
+exports.testnetAddress = {
+    address1: 'sthor19phfqh3ce3nnjhh0cssn433nydq9shx76s8qgg',
+    address2: 'sthor1cghgr0dneyymxx6fjq3e72q83z0qz7c3sjhtmc',
+    address3: 'sthor1cghgr0dneyymxx6fjq3e72q83z0qz7c3sjhtm',
+    address4: 'stho1cghgr0dneyymxx6fjq3e72q83z0qz7c3sjhtmc',
+    validatorAddress1: 'sthor1skucxdq0fkwpx4hjkzn4g303hlzcf30nqduln0',
+    validatorAddress2: 'sthor1z6z5v9xgzwxd9gytdkpve0g63mcfffjdzkpwue',
+    validatorAddress3: 'sthor19k46y3nkra9q9a48wjgwac65ms385pcgpueue',
+    validatorAddress4: 'stho1x9ths2nevz0e002hq93jfdpdt7rtmxwdq07fp5',
+    noMemoIdAddress: 'sthor1tl46dxfh3qupqxgap5vtpah4pxwn35j5tnjzls',
+    validMemoIdAddress: 'sthor1tl46dxfh3qupqxgap5vtpah4pxwn35j5tnjzls?memoId=2',
+    invalidMemoIdAddress: 'sthor1tl46dxfh3qupqxgap5vtpah4pxwn35j5tnjzls?memoId=xyz',
+    multipleMemoIdAddress: 'sthor1tl46dxfh3qupqxgap5vtpah4pxwn35j5tnjzls?memoId=3&memoId=12',
+};
+exports.testnetCoinAmounts = {
+    amount1: { amount: '100000', denom: 'rune' },
+    amount2: { amount: '1000000', denom: 'rune' },
+    amount3: { amount: '10000000', denom: 'rune' },
+    amount4: { amount: '-1', denom: 'rune' },
+    amount5: { amount: '1000000000', denom: 'arune' },
+};
+exports.wrwUser = {
+    senderAddress: 'sthor1gqek8kl5mr9c37rl8yp2mljne67jgaqm96jg2f',
+    destinationAddress: 'sthor1tl46dxfh3qupqxgap5vtpah4pxwn35j5tnjzls',
+    userPrivateKey: '{"iv":"9rcHMytmmnHjG1llBoc49g==","v":1,"iter":10000,"ks":256,"ts":64,"mode" :"ccm","adata":"","cipher":"aes","salt":"8lFAwTrcCzQ=","ct":"1gMRC60nu01IYr jgir9GCuQNLMZC2vt/pFjgL+tV3K7/rviSguDsua133PkNEeuty1mZxNH2S1TKu1KxZJMlB+MAs vo7k9dIyCgQvkX/nbJFFaRrnLL55mcQe0PhCdVNRHx9doXMngRF+UqEMLD8F0HNE1+ZPGzsathH DLFPxLCRMrwA/Ss/LQowGiXo4WnzVK3MQcX6wdmZvfV+S3xswRjHkLvolVY3rVGP5PkU86Wwrmy e1CKM4hSGA8FModa718Svk7C+LHr0yOTuuPftXtH0fAPPo9KH7f+EbBWMJPQgjK8DW/z1xnDgLH dzhveyNPevqUqb3FEyutjow+KBkxl+xHqJ4gKcU9MLsghPMCy0zSq2kBbhlqWJ7XwduhHVGv2nT rlsEfh7Z0fbqZTX1RQ5AKZhSBFEqmq1hKxRlhVcr9KqBw814tIfdFD7nMgV7rz+3X8cJaK2tDXH 0QaY8bJGwxwH38FsfNevs8Qf2bx5VrD/Vw3wo0G5hJ7+TdPCrib8UWyxPGuruH7b8hwCUTZaq97 zkDp7c79BDWyH8ycTxQXjLPwb1CwpUiRDc6NHD2p3iGVaztMdQOMXmPeeMhBNGVI0MPAfSdcDip 2E5Ek0fwnI1mEuFjPMkc+VOlsVhlWfV/9Xpoh3NadPhqg3i9Cr2uNT/PSyHd/jpIqG5DlaaEvVD f7COqNvXX5Qqmlr9dL3R2cf0zP8TPImAlRfef4D8zatHtylKkImMc0JcdcXTzwU/5tf21o/Y701 DLYjwUUgqQ57ObHHNlSvmdIuO1rD5LAn96NAYNRStrENqmbibE5MsYrp9nPAprCNFnZR6UNpXwD hvq9gvxRG+PjmXGj0nuyR7cshxURLy0/p4tq7LkGjk4Gg31Mgk41lcYUW2tLuUbTYmpteu3Cdwe DFuLsfI1qZxKyr6V5Nse3ZAvnJLTZnQXiHOnc2y5/e53+MAVupXR7HZzx7SIJ+fqxpjxvccmgJC sWaPo+Lsx6KaSNkQGFMGuyZ87IEvm7vk2GyIP+FQUn4nmTdEDLzg7nNo+zf5WT4A6Yz3GNAa3Nh 2QHZSFGWcubOXDawh6lAjZ78GNK9yJDp22dJTmfZ+1TsVORpbZw="}',
+    backupPrivateKey: '{"iv":"0EDqGU1yBE2PM4ry6TxARA==","v":1,"iter":10000,"ks":256,"ts":64,"mode" :"ccm","adata":"","cipher":"aes","salt":"a8T0fVVhTz0=","ct":"syCrJ+RD8oHZ4z jltLmyNS/VVmSLXLMAdnVnoPNEfFX9mIMAycYCajMR297l09fPsWWqDcDs0cSI0xNbnMjyW30b/ JOvQ33eaBSiyBr3vbmhaEFduZTUgOCNg/Js0cAkEkeE/KDkfOUB0HzfSEQb6m0eXmWgGSnySUOd TlZZ/thT7j2oPHVpPE52h6Yi3LS1Jkt3S7ySStXvG/4iurhcL32a32Fx3IQxs/bg8JBIGlRG644 aLttCJ+uPihaSISUGn1hh0iEz2ZAaCoCkq7oNPrK+pxHHOmbjxp6XpV67EmQ/JRfSt47eW3jC7A D+xaLLHspjQifp6ClZeHT2pBrkcWrZfr1uL5w3CKrXQeJ0pXUoRmJwGys4hm5Bzu4imANo+jd1+ wg73ByYQ5VwRhV1qhb82vUrQ0i4k5Gt2l6U2LZ/DMQiUbq7FdjYWqfZmk18GIZ6g3IPJtGjnA6x o8RTvkytMMv8btsx/aa6jE6EMeFtGzlhhJJunpcS4QG4IkIuyAjPafwOklEwXklZCLDpKdVYgTR RE0XHC0VXOGQwGUARzMZwQO5OaRyQkxtZ5/CawI5jrwMZP+bpC9dKzsGOXfSvvFsJWnkboXyy09 bFwTuKHx0ZILdA/8Xq5689YEmFljHTeQ0Es/q5y5kU+XzT4sjjgxz1qqhUJVh7wDwQevRDWTwGJ Lfi2AeLsv2f0PKiGTYJzQGSXUerhLMwhg3rXNfXGkrWSmEhJH/RsvF6CdaRKWxVd+k8K5ULLwK+ sdujA5murZ24KI5z0Yr9qW2TSsJRG3PS+ZH1q3VGYaz6k912QVzyvzds8+hfaHNtr6OGBWahGZo JchgnQHSfAZxOUz7K7WNzh934HK5+e11/lF/Fxssumz2OStFWI18oBB7/8YBi6PEp3sFddOQVSA BXRGuStolGna43nly4bavOic7XIoNHs61hynMeR6NcthsSrj5xZ6q36EqLdfkDImQvu+3BXClT7 Q4bdEfXm0t7Bgmid4NeJ1I3grXZMOmVbPgcypfxp2jrkjme/R0/eJL4B38WU2xjxDg+WlBGy8dA xg8ll+n2NkA7lvJz5NBDxbGHRAhtyVTF8YA+Oxps3rumIw=="}',
+    bitgoPublicKey: '02d754ffd645ba3d87fbdeb3578dbc22fc252ebb299416434a7059d9638f52d11e0fd153d9d dfb2a193531ac5b7d3b223188a957de1312d3ede35305ee70b76376',
+    walletPassphrase: 'Ghghjkg!455544llll',
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trune.js","sourceRoot":"","sources":["../../../test/resources/trune.ts"],"names":[],"mappings":"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","sourcesContent":["// Get the test data by running the scripts for the particular coin from coin-sandbox repo.\nexport const TEST_TX_WITH_MEMO = {\n  hash: 'B0C1C424ABA63C7401691F7AC777D080A1C4E59594CCBC74DC4B213D747AA1F1',\n  signature: 'E4PZxdeEGQJ8In+cjPiEd979mXuQlDesucLoivVt0wljx9/0bXNeL5+2ecRironf0Fo3pa1vsBpp7wM0UNWM7A==',\n  pubKey: 'AxLtvJO7WCAT1uNYriwGyxu678ck7+0ag5Pd589dtydC',\n  privateKey: 'uz2P7K8xhtoHM1QAbXXWBx83uvyA/ulQTx4tM2qGXAE=',\n  signedTxBase64:\n    'ClMKTgoOL3R5cGVzLk1zZ1NlbmQSPAoUX+ummTeIOBAZHQ0YsPb1CZ040lQSFID5ph0o2N3lj2qmLDH59qRQag14Gg4KBHJ1bmUSBjEwMDAwMBIBMRJpClAKRgofL2Nvc21vcy5jcnlwdG8uc2VjcDI1NmsxLlB1YktleRIjCiEDEu28k7tYIBPW41iuLAbLG7rvxyTv7RqDk93nz123J0ISBAoCCAEYAxIVCg4KBHJ1bmUSBjEwMDAwMBCA4esXGkATg9nF14QZAnwif5yM+IR33v2Ze5CUN6y5wuiK9W3TCWPH3/Rtc14vn7Z5xGKuid/QWjelrW+wGmnvAzRQ1Yzs',\n  sender: 'sthor1tl46dxfh3qupqxgap5vtpah4pxwn35j5tnjzls',\n  recipient: 'sthor1sru6v8fgmrw7trm25ckrr70k53gx5rtc4xhfgf',\n  chainId: 'thorchain-stagenet-2',\n  accountNumber: 15,\n  sequence: 3,\n  memo: '1',\n  sendAmount: '100000',\n  feeAmount: '100000',\n  sendMessage: {\n    typeUrl: '/types.MsgSend',\n    value: {\n      amount: [\n        {\n          denom: 'rune',\n          amount: '100000',\n        },\n      ],\n      fromAddress: 'sthor1tl46dxfh3qupqxgap5vtpah4pxwn35j5tnjzls',\n      toAddress: 'sthor1sru6v8fgmrw7trm25ckrr70k53gx5rtc4xhfgf',\n    },\n  },\n  gasBudget: {\n    amount: [{ denom: 'rune', amount: '100000' }],\n    gasLimit: 50000000,\n  },\n};\n\nexport const TEST_SEND_TX = {\n  hash: 'FA4635875A1A0E9175126AA6FF5D50B943F74C23B9A1C952808F1274ABC690C8',\n  signature: 'aFAUTspGfdniC1x2Uia9VByLzSjtzzTSZKVZ7s45Otcp9cfx+kMxmjfd0VPIATKjoAOs55koaUPO3USdzVVkaQ==',\n  pubKey: 'AxLtvJO7WCAT1uNYriwGyxu678ck7+0ag5Pd589dtydC',\n  privateKey: 'uz2P7K8xhtoHM1QAbXXWBx83uvyA/ulQTx4tM2qGXAE=',\n  signedTxBase64:\n    'ClAKTgoOL3R5cGVzLk1zZ1NlbmQSPAoUX+ummTeIOBAZHQ0YsPb1CZ040lQSFID5ph0o2N3lj2qmLDH59qRQag14Gg4KBHJ1bmUSBjEwMDAwMBJpClAKRgofL2Nvc21vcy5jcnlwdG8uc2VjcDI1NmsxLlB1YktleRIjCiEDEu28k7tYIBPW41iuLAbLG7rvxyTv7RqDk93nz123J0ISBAoCCAEYBBIVCg4KBHJ1bmUSBjEwMDAwMBCA4esXGkBoUBROykZ92eILXHZSJr1UHIvNKO3PNNJkpVnuzjk61yn1x/H6QzGaN93RU8gBMqOgA6znmShpQ87dRJ3NVWRp',\n  sender: 'sthor1tl46dxfh3qupqxgap5vtpah4pxwn35j5tnjzls',\n  recipient: 'sthor1sru6v8fgmrw7trm25ckrr70k53gx5rtc4xhfgf',\n  chainId: 'thorchain-stagenet-2',\n  accountNumber: 15,\n  sequence: 4,\n  sendAmount: '100000',\n  feeAmount: '100000',\n  sendMessage: {\n    typeUrl: '/types.MsgSend',\n    value: {\n      amount: [\n        {\n          denom: 'rune',\n          amount: '100000',\n        },\n      ],\n      fromAddress: 'sthor1tl46dxfh3qupqxgap5vtpah4pxwn35j5tnjzls',\n      toAddress: 'sthor1sru6v8fgmrw7trm25ckrr70k53gx5rtc4xhfgf',\n    },\n  },\n  gasBudget: {\n    amount: [\n      {\n        denom: 'rune',\n        amount: '100000',\n      },\n    ],\n    gasLimit: 50000000,\n  },\n};\n\nexport const testnetAddress = {\n  address1: 'sthor19phfqh3ce3nnjhh0cssn433nydq9shx76s8qgg',\n  address2: 'sthor1cghgr0dneyymxx6fjq3e72q83z0qz7c3sjhtmc',\n  address3: 'sthor1cghgr0dneyymxx6fjq3e72q83z0qz7c3sjhtm',\n  address4: 'stho1cghgr0dneyymxx6fjq3e72q83z0qz7c3sjhtmc',\n  validatorAddress1: 'sthor1skucxdq0fkwpx4hjkzn4g303hlzcf30nqduln0',\n  validatorAddress2: 'sthor1z6z5v9xgzwxd9gytdkpve0g63mcfffjdzkpwue',\n  validatorAddress3: 'sthor19k46y3nkra9q9a48wjgwac65ms385pcgpueue',\n  validatorAddress4: 'stho1x9ths2nevz0e002hq93jfdpdt7rtmxwdq07fp5',\n  noMemoIdAddress: 'sthor1tl46dxfh3qupqxgap5vtpah4pxwn35j5tnjzls',\n  validMemoIdAddress: 'sthor1tl46dxfh3qupqxgap5vtpah4pxwn35j5tnjzls?memoId=2',\n  invalidMemoIdAddress: 'sthor1tl46dxfh3qupqxgap5vtpah4pxwn35j5tnjzls?memoId=xyz',\n  multipleMemoIdAddress: 'sthor1tl46dxfh3qupqxgap5vtpah4pxwn35j5tnjzls?memoId=3&memoId=12',\n};\n\nexport const testnetCoinAmounts = {\n  amount1: { amount: '100000', denom: 'rune' },\n  amount2: { amount: '1000000', denom: 'rune' },\n  amount3: { amount: '10000000', denom: 'rune' },\n  amount4: { amount: '-1', denom: 'rune' },\n  amount5: { amount: '1000000000', denom: 'arune' },\n};\n\nexport const wrwUser = {\n  senderAddress: 'sthor1gqek8kl5mr9c37rl8yp2mljne67jgaqm96jg2f',\n  destinationAddress: 'sthor1tl46dxfh3qupqxgap5vtpah4pxwn35j5tnjzls',\n  userPrivateKey:\n    '{\"iv\":\"9rcHMytmmnHjG1llBoc49g==\",\"v\":1,\"iter\":10000,\"ks\":256,\"ts\":64,\"mode\" :\"ccm\",\"adata\":\"\",\"cipher\":\"aes\",\"salt\":\"8lFAwTrcCzQ=\",\"ct\":\"1gMRC60nu01IYr jgir9GCuQNLMZC2vt/pFjgL+tV3K7/rviSguDsua133PkNEeuty1mZxNH2S1TKu1KxZJMlB+MAs vo7k9dIyCgQvkX/nbJFFaRrnLL55mcQe0PhCdVNRHx9doXMngRF+UqEMLD8F0HNE1+ZPGzsathH DLFPxLCRMrwA/Ss/LQowGiXo4WnzVK3MQcX6wdmZvfV+S3xswRjHkLvolVY3rVGP5PkU86Wwrmy e1CKM4hSGA8FModa718Svk7C+LHr0yOTuuPftXtH0fAPPo9KH7f+EbBWMJPQgjK8DW/z1xnDgLH dzhveyNPevqUqb3FEyutjow+KBkxl+xHqJ4gKcU9MLsghPMCy0zSq2kBbhlqWJ7XwduhHVGv2nT rlsEfh7Z0fbqZTX1RQ5AKZhSBFEqmq1hKxRlhVcr9KqBw814tIfdFD7nMgV7rz+3X8cJaK2tDXH 0QaY8bJGwxwH38FsfNevs8Qf2bx5VrD/Vw3wo0G5hJ7+TdPCrib8UWyxPGuruH7b8hwCUTZaq97 zkDp7c79BDWyH8ycTxQXjLPwb1CwpUiRDc6NHD2p3iGVaztMdQOMXmPeeMhBNGVI0MPAfSdcDip 2E5Ek0fwnI1mEuFjPMkc+VOlsVhlWfV/9Xpoh3NadPhqg3i9Cr2uNT/PSyHd/jpIqG5DlaaEvVD f7COqNvXX5Qqmlr9dL3R2cf0zP8TPImAlRfef4D8zatHtylKkImMc0JcdcXTzwU/5tf21o/Y701 DLYjwUUgqQ57ObHHNlSvmdIuO1rD5LAn96NAYNRStrENqmbibE5MsYrp9nPAprCNFnZR6UNpXwD hvq9gvxRG+PjmXGj0nuyR7cshxURLy0/p4tq7LkGjk4Gg31Mgk41lcYUW2tLuUbTYmpteu3Cdwe DFuLsfI1qZxKyr6V5Nse3ZAvnJLTZnQXiHOnc2y5/e53+MAVupXR7HZzx7SIJ+fqxpjxvccmgJC sWaPo+Lsx6KaSNkQGFMGuyZ87IEvm7vk2GyIP+FQUn4nmTdEDLzg7nNo+zf5WT4A6Yz3GNAa3Nh 2QHZSFGWcubOXDawh6lAjZ78GNK9yJDp22dJTmfZ+1TsVORpbZw=\"}',\n  backupPrivateKey:\n    '{\"iv\":\"0EDqGU1yBE2PM4ry6TxARA==\",\"v\":1,\"iter\":10000,\"ks\":256,\"ts\":64,\"mode\" :\"ccm\",\"adata\":\"\",\"cipher\":\"aes\",\"salt\":\"a8T0fVVhTz0=\",\"ct\":\"syCrJ+RD8oHZ4z jltLmyNS/VVmSLXLMAdnVnoPNEfFX9mIMAycYCajMR297l09fPsWWqDcDs0cSI0xNbnMjyW30b/ JOvQ33eaBSiyBr3vbmhaEFduZTUgOCNg/Js0cAkEkeE/KDkfOUB0HzfSEQb6m0eXmWgGSnySUOd TlZZ/thT7j2oPHVpPE52h6Yi3LS1Jkt3S7ySStXvG/4iurhcL32a32Fx3IQxs/bg8JBIGlRG644 aLttCJ+uPihaSISUGn1hh0iEz2ZAaCoCkq7oNPrK+pxHHOmbjxp6XpV67EmQ/JRfSt47eW3jC7A D+xaLLHspjQifp6ClZeHT2pBrkcWrZfr1uL5w3CKrXQeJ0pXUoRmJwGys4hm5Bzu4imANo+jd1+ wg73ByYQ5VwRhV1qhb82vUrQ0i4k5Gt2l6U2LZ/DMQiUbq7FdjYWqfZmk18GIZ6g3IPJtGjnA6x o8RTvkytMMv8btsx/aa6jE6EMeFtGzlhhJJunpcS4QG4IkIuyAjPafwOklEwXklZCLDpKdVYgTR RE0XHC0VXOGQwGUARzMZwQO5OaRyQkxtZ5/CawI5jrwMZP+bpC9dKzsGOXfSvvFsJWnkboXyy09 bFwTuKHx0ZILdA/8Xq5689YEmFljHTeQ0Es/q5y5kU+XzT4sjjgxz1qqhUJVh7wDwQevRDWTwGJ Lfi2AeLsv2f0PKiGTYJzQGSXUerhLMwhg3rXNfXGkrWSmEhJH/RsvF6CdaRKWxVd+k8K5ULLwK+ sdujA5murZ24KI5z0Yr9qW2TSsJRG3PS+ZH1q3VGYaz6k912QVzyvzds8+hfaHNtr6OGBWahGZo JchgnQHSfAZxOUz7K7WNzh934HK5+e11/lF/Fxssumz2OStFWI18oBB7/8YBi6PEp3sFddOQVSA BXRGuStolGna43nly4bavOic7XIoNHs61hynMeR6NcthsSrj5xZ6q36EqLdfkDImQvu+3BXClT7 Q4bdEfXm0t7Bgmid4NeJ1I3grXZMOmVbPgcypfxp2jrkjme/R0/eJL4B38WU2xjxDg+WlBGy8dA xg8ll+n2NkA7lvJz5NBDxbGHRAhtyVTF8YA+Oxps3rumIw==\"}',\n  bitgoPublicKey:\n    '02d754ffd645ba3d87fbdeb3578dbc22fc252ebb299416434a7059d9638f52d11e0fd153d9d dfb2a193531ac5b7d3b223188a957de1312d3ede35305ee70b76376',\n  walletPassphrase: 'Ghghjkg!455544llll',\n};\n"]}

package/dist/test/unit/keyPair.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=keyPair.d.ts.map

package/dist/test/unit/keyPair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyPair.d.ts","sourceRoot":"","sources":["../../../test/unit/keyPair.ts"],"names":[],"mappings":""}

package/dist/test/unit/keyPair.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const assert_1 = __importDefault(require("assert"));
+const should_1 = __importDefault(require("should"));
+const src_1 = require("../../src");
+const rune_1 = require("../resources/rune");
+describe('Rune Key Pair', () => {
+    describe('should create a valid KeyPair', () => {
+        it('from an empty value', () => {
+            const keyPairObj = new src_1.KeyPair();
+            const keys = keyPairObj.getKeys();
+            should_1.default.exists(keys.prv);
+            should_1.default.exists(keys.pub);
+            should_1.default.equal(keys.prv?.length, 64);
+            should_1.default.equal(keys.pub.length, 66);
+            const extendedKeys = keyPairObj.getExtendedKeys();
+            should_1.default.exists(extendedKeys.xprv);
+            should_1.default.exists(extendedKeys.xpub);
+        });
+        it('from a private key', () => {
+            const privateKey = rune_1.TEST_ACCOUNT.privateKey;
+            const keyPairObj = new src_1.KeyPair({ prv: privateKey });
+            const keys = keyPairObj.getKeys();
+            should_1.default.exists(keys.prv);
+            should_1.default.exists(keys.pub);
+            should_1.default.equal(keys.prv, rune_1.TEST_ACCOUNT.privateKey);
+            should_1.default.equal(keys.pub, rune_1.TEST_ACCOUNT.compressedPublicKey);
+            should_1.default.equal(keyPairObj.getAddress(), rune_1.TEST_ACCOUNT.pubAddress);
+            should_1.default.equal(keyPairObj.getAddress(sdk_core_1.AddressFormat.testnet), rune_1.TEST_ACCOUNT.testnetPubAddress);
+            assert_1.default.throws(() => keyPairObj.getExtendedKeys());
+        });
+        it('from a compressed public key', () => {
+            const publicKey = rune_1.TEST_ACCOUNT.compressedPublicKey;
+            const keyPairObj = new src_1.KeyPair({ pub: publicKey });
+            const keys = keyPairObj.getKeys();
+            should_1.default.not.exist(keys.prv);
+            should_1.default.exists(keys.pub);
+            should_1.default.equal(keys.pub, rune_1.TEST_ACCOUNT.compressedPublicKey);
+            assert_1.default.throws(() => keyPairObj.getExtendedKeys());
+        });
+        it('from an uncompressed public key', () => {
+            // Input is uncompressed, but we output the compressed key to keep
+            // parity with coreum network expectations.
+            const publicKey = rune_1.TEST_ACCOUNT.uncompressedPublicKey;
+            const keyPairObj = new src_1.KeyPair({ pub: publicKey });
+            const keys = keyPairObj.getKeys();
+            should_1.default.not.exist(keys.prv);
+            should_1.default.exists(keys.pub);
+            should_1.default.notEqual(keys.pub, publicKey);
+            should_1.default.equal(keys.pub, rune_1.TEST_ACCOUNT.compressedPublicKey);
+            assert_1.default.throws(() => keyPairObj.getExtendedKeys());
+        });
+    });
+    describe('should fail to create a KeyPair', () => {
+        it('from an invalid privateKey', () => {
+            assert_1.default.throws(() => new src_1.KeyPair({ prv: '' }), (e) => e.message === 'Unsupported private key');
+        });
+        it('from an invalid publicKey', () => {
+            assert_1.default.throws(() => new src_1.KeyPair({ pub: '' }), (e) => e.message.startsWith('Unsupported public key'));
+        });
+        it('from an undefined seed', () => {
+            const undefinedBuffer = undefined;
+            assert_1.default.throws(() => new src_1.KeyPair({ seed: undefinedBuffer }), (e) => e.message.startsWith('Invalid key pair options'));
+        });
+        it('from an undefined private key', () => {
+            const undefinedStr = undefined;
+            assert_1.default.throws(() => new src_1.KeyPair({ prv: undefinedStr }), (e) => e.message.startsWith('Invalid key pair options'));
+        });
+        it('from an undefined public key', () => {
+            const undefinedStr = undefined;
+            assert_1.default.throws(() => new src_1.KeyPair({ pub: undefinedStr }), (e) => e.message.startsWith('Invalid key pair options'));
+        });
+    });
+    describe('should get unique address', () => {
+        it('from a private key', () => {
+            const keyPair = new src_1.KeyPair({ prv: rune_1.TEST_ACCOUNT.privateKey });
+            should_1.default.equal(keyPair.getAddress(), rune_1.TEST_ACCOUNT.pubAddress);
+        });
+        it('from a compressed public key', () => {
+            const keyPair = new src_1.KeyPair({ pub: rune_1.TEST_ACCOUNT.compressedPublicKey });
+            should_1.default.equal(keyPair.getAddress(), rune_1.TEST_ACCOUNT.pubAddress);
+        });
+        it('should be different for different public keys', () => {
+            const keyPairOne = new src_1.KeyPair({ pub: rune_1.TEST_ACCOUNT.compressedPublicKey });
+            const keyPairTwo = new src_1.KeyPair({ pub: rune_1.TEST_ACCOUNT.compressedPublicKeyTwo });
+            should_1.default.notEqual(keyPairOne.getAddress(), keyPairTwo.getAddress());
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keyPair.js","sourceRoot":"","sources":["../../../test/unit/keyPair.ts"],"names":[],"mappings":"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","sourcesContent":["import { AddressFormat } from '@bitgo-beta/sdk-core';\nimport assert from 'assert';\nimport should from 'should';\nimport { KeyPair } from '../../src';\nimport { TEST_ACCOUNT } from '../resources/rune';\n\ndescribe('Rune Key Pair', () => {\n  describe('should create a valid KeyPair', () => {\n    it('from an empty value', () => {\n      const keyPairObj = new KeyPair();\n      const keys = keyPairObj.getKeys();\n      should.exists(keys.prv);\n      should.exists(keys.pub);\n      should.equal(keys.prv?.length, 64);\n      should.equal(keys.pub.length, 66);\n\n      const extendedKeys = keyPairObj.getExtendedKeys();\n      should.exists(extendedKeys.xprv);\n      should.exists(extendedKeys.xpub);\n    });\n\n    it('from a private key', () => {\n      const privateKey = TEST_ACCOUNT.privateKey;\n      const keyPairObj = new KeyPair({ prv: privateKey });\n      const keys = keyPairObj.getKeys();\n      should.exists(keys.prv);\n      should.exists(keys.pub);\n      should.equal(keys.prv, TEST_ACCOUNT.privateKey);\n      should.equal(keys.pub, TEST_ACCOUNT.compressedPublicKey);\n      should.equal(keyPairObj.getAddress(), TEST_ACCOUNT.pubAddress);\n      should.equal(keyPairObj.getAddress(AddressFormat.testnet), TEST_ACCOUNT.testnetPubAddress);\n\n      assert.throws(() => keyPairObj.getExtendedKeys());\n    });\n\n    it('from a compressed public key', () => {\n      const publicKey = TEST_ACCOUNT.compressedPublicKey;\n      const keyPairObj = new KeyPair({ pub: publicKey });\n      const keys = keyPairObj.getKeys();\n      should.not.exist(keys.prv);\n      should.exists(keys.pub);\n      should.equal(keys.pub, TEST_ACCOUNT.compressedPublicKey);\n\n      assert.throws(() => keyPairObj.getExtendedKeys());\n    });\n\n    it('from an uncompressed public key', () => {\n      // Input is uncompressed, but we output the compressed key to keep\n      // parity with coreum network expectations.\n      const publicKey = TEST_ACCOUNT.uncompressedPublicKey;\n      const keyPairObj = new KeyPair({ pub: publicKey });\n      const keys = keyPairObj.getKeys();\n      should.not.exist(keys.prv);\n      should.exists(keys.pub);\n      should.notEqual(keys.pub, publicKey);\n      should.equal(keys.pub, TEST_ACCOUNT.compressedPublicKey);\n\n      assert.throws(() => keyPairObj.getExtendedKeys());\n    });\n  });\n\n  describe('should fail to create a KeyPair', () => {\n    it('from an invalid privateKey', () => {\n      assert.throws(\n        () => new KeyPair({ prv: '' }),\n        (e: any) => e.message === 'Unsupported private key'\n      );\n    });\n\n    it('from an invalid publicKey', () => {\n      assert.throws(\n        () => new KeyPair({ pub: '' }),\n        (e: any) => e.message.startsWith('Unsupported public key')\n      );\n    });\n\n    it('from an undefined seed', () => {\n      const undefinedBuffer = undefined as unknown as Buffer;\n      assert.throws(\n        () => new KeyPair({ seed: undefinedBuffer }),\n        (e: any) => e.message.startsWith('Invalid key pair options')\n      );\n    });\n\n    it('from an undefined private key', () => {\n      const undefinedStr: string = undefined as unknown as string;\n      assert.throws(\n        () => new KeyPair({ prv: undefinedStr }),\n        (e: any) => e.message.startsWith('Invalid key pair options')\n      );\n    });\n\n    it('from an undefined public key', () => {\n      const undefinedStr: string = undefined as unknown as string;\n      assert.throws(\n        () => new KeyPair({ pub: undefinedStr }),\n        (e: any) => e.message.startsWith('Invalid key pair options')\n      );\n    });\n  });\n\n  describe('should get unique address', () => {\n    it('from a private key', () => {\n      const keyPair = new KeyPair({ prv: TEST_ACCOUNT.privateKey });\n      should.equal(keyPair.getAddress(), TEST_ACCOUNT.pubAddress);\n    });\n\n    it('from a compressed public key', () => {\n      const keyPair = new KeyPair({ pub: TEST_ACCOUNT.compressedPublicKey });\n      should.equal(keyPair.getAddress(), TEST_ACCOUNT.pubAddress);\n    });\n\n    it('should be different for different public keys', () => {\n      const keyPairOne = new KeyPair({ pub: TEST_ACCOUNT.compressedPublicKey });\n      const keyPairTwo = new KeyPair({ pub: TEST_ACCOUNT.compressedPublicKeyTwo });\n      should.notEqual(keyPairOne.getAddress(), keyPairTwo.getAddress());\n    });\n  });\n});\n"]}

package/dist/test/unit/rune.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rune.d.ts.map

package/dist/test/unit/rune.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rune.d.ts","sourceRoot":"","sources":["../../../test/unit/rune.ts"],"names":[],"mappings":""}