@shapeshiftoss/caip 1.0.0

package/README.md

@@ -0,0 +1,81 @@
+# CAIPs
+
+This package is ShapeShift's partial implementation of [CAIPs](https://github.com/ChainAgnostic/CAIPs) - Chain Agnostic Improvement Protocols.
+
+It is not exhaustive and is currently only used internally.
+
+## CAIP-2 - Blockchain ID Specification
+
+https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-2.md
+
+Usage
+
+### `toCAIP2`
+
+```ts
+const chain = ChainTypes.Ethereum
+const network = NetworkTypes.MAINNET
+const result = toCAIP2({ chain, network })
+expect(result).toEqual('eip155:1')
+```
+
+### `fromCAIP2`
+
+```ts
+const ethCaip2 = 'eip155:1'
+const { chain, network } = fromCAIP2(ethCaip2)
+expect(chain).toEqual(ChainTypes.Ethereum)
+expect(network).toEqual(NetworkTypes.MAINNET)
+```
+
+## CAIP-19 - Asset Type and Asset ID Specification
+
+https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-19.md
+
+Usage
+
+### `toCAIP19`
+
+Ether
+
+```ts
+const chain = ChainTypes.Ethereum
+const network = NetworkTypes.MAINNET
+const result = toCAIP19({ chain, network })
+expect(result).toEqual('eip155:1/slip44:60')
+```
+
+ERC20 token
+
+```ts
+const chain = ChainTypes.Ethereum
+const network = NetworkTypes.MAINNET
+const contractType = ContractTypes.ERC20
+const tokenId = '0xc770eefad204b5180df6a14ee197d99d808ee52d'
+const result = toCAIP19({ chain, network, contractType, tokenId })
+expect(result).toEqual('eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d')
+```
+
+### `fromCAIP19`
+
+Ether
+
+```ts
+const caip19 = 'eip155:1/slip44:60'
+const { chain, network, contractType, tokenId } = fromCAIP19(caip19)
+expect(chain).toEqual(ChainTypes.Ethereum)
+expect(network).toEqual(NetworkTypes.MAINNET)
+expect(contractType).toBeUndefined()
+expect(tokenId).toBeUndefined()
+```
+
+ERC20 token
+
+```ts
+const caip19 = 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d'
+const { chain, network, contractType, tokenId } = fromCAIP19(caip19)
+expect(chain).toEqual(ChainTypes.Ethereum)
+expect(network).toEqual(NetworkTypes.MAINNET)
+expect(contractType).toEqual(ContractTypes.ERC20)
+expect(tokenId).toEqual('0xc770eefad204b5180df6a14ee197d99d808ee52d')
+```

package/dist/caip19/caip19.d.ts

@@ -0,0 +1,27 @@
+import { ChainTypes, ContractTypes, NetworkTypes } from '@shapeshiftoss/types';
+export declare enum AssetNamespace {
+    ERC20 = "erc20",
+    ERC721 = "erc721",
+    Slip44 = "slip44"
+}
+export declare enum AssetReference {
+    Bitcoin = 0,
+    Ethereum = 60
+}
+declare type ToCAIP19Args = {
+    chain: ChainTypes;
+    network: NetworkTypes;
+    contractType?: ContractTypes;
+    tokenId?: string;
+};
+declare type ToCAIP19 = (args: ToCAIP19Args) => string;
+export declare const toCAIP19: ToCAIP19;
+declare type FromCAIP19Return = {
+    chain: ChainTypes;
+    network: NetworkTypes;
+    contractType?: ContractTypes;
+    tokenId?: string;
+};
+declare type FromCAIP19 = (caip19: string) => FromCAIP19Return;
+export declare const fromCAIP19: FromCAIP19;
+export {};

package/dist/caip19/caip19.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromCAIP19 = exports.toCAIP19 = exports.AssetReference = exports.AssetNamespace = void 0;
+const caip2_1 = require("./../caip2/caip2");
+// https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-19.md
+const types_1 = require("@shapeshiftoss/types");
+var AssetNamespace;
+(function (AssetNamespace) {
+    AssetNamespace["ERC20"] = "erc20";
+    AssetNamespace["ERC721"] = "erc721";
+    AssetNamespace["Slip44"] = "slip44";
+})(AssetNamespace = exports.AssetNamespace || (exports.AssetNamespace = {}));
+var AssetReference;
+(function (AssetReference) {
+    AssetReference[AssetReference["Bitcoin"] = 0] = "Bitcoin";
+    AssetReference[AssetReference["Ethereum"] = 60] = "Ethereum";
+})(AssetReference = exports.AssetReference || (exports.AssetReference = {}));
+const toCAIP19 = ({ chain, network, contractType, tokenId }) => {
+    const caip2 = (0, caip2_1.toCAIP2)({ chain, network });
+    switch (chain) {
+        case types_1.ChainTypes.Ethereum: {
+            if (contractType) {
+                if (!tokenId) {
+                    throw new Error(`toCAIP19: no tokenId provided with contract type ${contractType}`);
+                }
+                const shapeShiftToCAIP19Namespace = {
+                    [types_1.ChainTypes.Ethereum]: {
+                        [types_1.ContractTypes.ERC20]: AssetNamespace.ERC20,
+                        [types_1.ContractTypes.ERC721]: AssetNamespace.ERC721
+                    }
+                };
+                switch (contractType) {
+                    case types_1.ContractTypes.ERC20:
+                    case types_1.ContractTypes.ERC721: {
+                        const namespace = shapeShiftToCAIP19Namespace[chain][contractType];
+                        if (!tokenId.startsWith('0x')) {
+                            throw new Error(`toCAIP19: tokenId must start with 0x: ${tokenId}`);
+                        }
+                        if (tokenId.length !== 42) {
+                            throw new Error(`toCAIP19: tokenId length must be 42, length: ${tokenId.length}`);
+                        }
+                        return `${caip2}/${namespace}:${tokenId}`;
+                    }
+                    default: {
+                        throw new Error(`toCAIP19: unsupported contractType ${contractType} on chain ${chain}`);
+                    }
+                }
+            }
+            else {
+                if (tokenId) {
+                    throw new Error(`toCAIP19: tokenId provided without contract type`);
+                }
+                return `${caip2}/${AssetNamespace.Slip44}:${AssetReference.Ethereum}`;
+            }
+        }
+        case types_1.ChainTypes.Bitcoin: {
+            return `${caip2}/${AssetNamespace.Slip44}:${AssetReference.Bitcoin}`;
+        }
+    }
+};
+exports.toCAIP19 = toCAIP19;
+const fromCAIP19 = (caip19) => {
+    const [caip2, namespaceAndReference] = caip19.split('/');
+    if (!(caip2 && namespaceAndReference)) {
+        throw new Error(`fromCAIP19: error parsing caip19, caip2: ${caip2}, namespaceAndReference: ${namespaceAndReference}`);
+    }
+    const [namespace, referenceString] = namespaceAndReference.split(':');
+    if (!(namespace && referenceString)) {
+        throw new Error(`fromCAIP19: error parsing namespace and reference, namespace: ${namespace}, reference: ${referenceString}`);
+    }
+    const reference = Number(referenceString);
+    const { chain, network } = (0, caip2_1.fromCAIP2)(caip2);
+    switch (chain) {
+        case types_1.ChainTypes.Bitcoin: {
+            switch (namespace) {
+                case AssetNamespace.Slip44: {
+                    switch (reference) {
+                        case AssetReference.Bitcoin: {
+                            return { chain, network };
+                        }
+                        case AssetReference.Ethereum:
+                        default: {
+                            throw new Error(`fromCAIP19: invalid asset reference ${reference} on chain ${chain}`);
+                        }
+                    }
+                }
+                case AssetNamespace.ERC20:
+                case AssetNamespace.ERC721:
+                default: {
+                    throw new Error(`fromCAIP19: invalid asset reference ${reference} on chain ${chain}`);
+                }
+            }
+        }
+        case types_1.ChainTypes.Ethereum: {
+            switch (namespace) {
+                case AssetNamespace.Slip44: {
+                    switch (reference) {
+                        case AssetReference.Ethereum: {
+                            return { chain, network };
+                        }
+                        case AssetReference.Bitcoin:
+                        default: {
+                            throw new Error(`fromCAIP19: invalid asset reference ${reference} on chain ${chain}`);
+                        }
+                    }
+                }
+                case AssetNamespace.ERC20: {
+                    const contractType = types_1.ContractTypes.ERC20;
+                    const tokenId = referenceString;
+                    return { chain, network, contractType, tokenId };
+                }
+                case AssetNamespace.ERC721: {
+                    const contractType = types_1.ContractTypes.ERC721;
+                    const tokenId = referenceString;
+                    return { chain, network, contractType, tokenId };
+                }
+            }
+        }
+    }
+    throw new Error(`fromCAIP19: error parsing caip19: ${caip19}`);
+};
+exports.fromCAIP19 = fromCAIP19;

package/dist/caip2/caip2.d.ts

@@ -0,0 +1,25 @@
+import { ChainTypes, NetworkTypes } from '@shapeshiftoss/types';
+export declare enum ChainNamespace {
+    Ethereum = "eip155",
+    Bitcoin = "bip122"
+}
+export declare enum ChainReference {
+    EthereumMainnet = "1",
+    EthereumRopsten = "3",
+    EthereumRinkeby = "4",
+    BitcoinMainnet = "000000000019d6689c085ae165831e93",
+    BitcoinTestnet = "000000000933ea01ad0ee984209779ba"
+}
+declare type ToCAIP2Args = {
+    chain: ChainTypes;
+    network: NetworkTypes;
+};
+declare type ToCAIP2 = (args: ToCAIP2Args) => string;
+export declare const toCAIP2: ToCAIP2;
+declare type FromCAIP2Return = {
+    chain: ChainTypes;
+    network: NetworkTypes;
+};
+declare type FromCAIP2 = (caip2: string) => FromCAIP2Return;
+export declare const fromCAIP2: FromCAIP2;
+export {};

package/dist/caip2/caip2.js

@@ -0,0 +1,115 @@
+"use strict";
+// https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-2.md
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromCAIP2 = exports.toCAIP2 = exports.ChainReference = exports.ChainNamespace = void 0;
+const types_1 = require("@shapeshiftoss/types");
+var ChainNamespace;
+(function (ChainNamespace) {
+    ChainNamespace["Ethereum"] = "eip155";
+    ChainNamespace["Bitcoin"] = "bip122";
+})(ChainNamespace = exports.ChainNamespace || (exports.ChainNamespace = {}));
+var ChainReference;
+(function (ChainReference) {
+    ChainReference["EthereumMainnet"] = "1";
+    ChainReference["EthereumRopsten"] = "3";
+    ChainReference["EthereumRinkeby"] = "4";
+    // EthereumKovan = '42', // currently unsupported by shapeshift
+    // https://github.com/bitcoin/bips/blob/master/bip-0122.mediawiki#definition-of-chain-id
+    // caip2 uses max length of 32 chars of the genesis block
+    ChainReference["BitcoinMainnet"] = "000000000019d6689c085ae165831e93";
+    ChainReference["BitcoinTestnet"] = "000000000933ea01ad0ee984209779ba";
+})(ChainReference = exports.ChainReference || (exports.ChainReference = {}));
+const toCAIP2 = ({ chain, network }) => {
+    const shapeShiftToCAIP2 = {
+        [types_1.ChainTypes.Ethereum]: {
+            namespace: ChainNamespace.Ethereum,
+            reference: {
+                [types_1.NetworkTypes.MAINNET]: ChainReference.EthereumMainnet,
+                [types_1.NetworkTypes.ETH_ROPSTEN]: ChainReference.EthereumRopsten,
+                [types_1.NetworkTypes.ETH_RINKEBY]: ChainReference.EthereumRinkeby
+            }
+        },
+        [types_1.ChainTypes.Bitcoin]: {
+            namespace: ChainNamespace.Bitcoin,
+            reference: {
+                [types_1.NetworkTypes.MAINNET]: ChainReference.BitcoinMainnet,
+                [types_1.NetworkTypes.TESTNET]: ChainReference.BitcoinTestnet
+            }
+        }
+    };
+    const namespace = shapeShiftToCAIP2[chain].namespace;
+    switch (chain) {
+        case types_1.ChainTypes.Ethereum: {
+            const referenceMap = shapeShiftToCAIP2[chain].reference;
+            switch (network) {
+                case types_1.NetworkTypes.MAINNET:
+                case types_1.NetworkTypes.ETH_ROPSTEN:
+                case types_1.NetworkTypes.ETH_RINKEBY: {
+                    const reference = referenceMap[network];
+                    const caip2 = `${namespace}:${reference}`;
+                    return caip2;
+                }
+            }
+            break;
+        }
+        case types_1.ChainTypes.Bitcoin: {
+            const referenceMap = shapeShiftToCAIP2[chain].reference;
+            switch (network) {
+                case types_1.NetworkTypes.MAINNET:
+                case types_1.NetworkTypes.TESTNET: {
+                    const reference = referenceMap[network];
+                    const caip2 = `${namespace}:${reference}`;
+                    return caip2;
+                }
+            }
+        }
+    }
+    throw new Error(`toCAIP2: unsupported ${chain} network: ${network}`);
+};
+exports.toCAIP2 = toCAIP2;
+const fromCAIP2 = (caip2) => {
+    const [c, n] = caip2.split(':');
+    if (!(c && n)) {
+        throw new Error(`fromCAIP19: error parsing caip19, chain: ${c}, network: ${n}`);
+    }
+    switch (c) {
+        case 'eip155': {
+            const chain = types_1.ChainTypes.Ethereum;
+            switch (n) {
+                case ChainReference.EthereumMainnet: {
+                    const network = types_1.NetworkTypes.MAINNET;
+                    return { chain, network };
+                }
+                case ChainReference.EthereumRopsten: {
+                    const network = types_1.NetworkTypes.ETH_ROPSTEN;
+                    return { chain, network };
+                }
+                case ChainReference.EthereumRinkeby: {
+                    const network = types_1.NetworkTypes.ETH_RINKEBY;
+                    return { chain, network };
+                }
+                default: {
+                    throw new Error(`fromCAIP19: unsupported ${c} network: ${n}`);
+                }
+            }
+        }
+        case 'bip122': {
+            const chain = types_1.ChainTypes.Bitcoin;
+            switch (n) {
+                case ChainReference.BitcoinMainnet: {
+                    const network = types_1.NetworkTypes.MAINNET;
+                    return { chain, network };
+                }
+                case ChainReference.BitcoinTestnet: {
+                    const network = types_1.NetworkTypes.TESTNET;
+                    return { chain, network };
+                }
+                default: {
+                    throw new Error(`fromCAIP19: unsupported ${c} network: ${n}`);
+                }
+            }
+        }
+    }
+    throw new Error(`fromCAIP19: unsupported chain: ${c}`);
+};
+exports.fromCAIP2 = fromCAIP2;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import * as caip2 from './caip2/caip2';
+import * as caip19 from './caip19/caip19';
+export { caip2, caip19 };

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.caip19 = exports.caip2 = void 0;
+const caip2 = __importStar(require("./caip2/caip2"));
+exports.caip2 = caip2;
+const caip19 = __importStar(require("./caip19/caip19"));
+exports.caip19 = caip19;

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@shapeshiftoss/caip",
+  "version": "1.0.0",
+  "description": "CAIP Implementation",
+  "homepage": "",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/shapeshift/lib"
+  },
+  "scripts": {
+    "build": "yarn clean && tsc --project tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "dev": "tsc --watch",
+    "test": "jest test",
+    "type-check": "tsc --project ./tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@shapeshiftoss/types": "^1.4.0"
+  }
+}