Add support for encoding Address to/from new StrKeys

src/address.js

@@ -4,15 +4,15 @@ import xdr from './xdr';
 /**
  * Create a new Address object.
  *
- * `Address` represents a single address in the Stellar network. An address can
- * represent an account or a contract.
+ * `Address` represents a single address in the Stellar network that can be
+ * inputted to or outputted by a smart contract. An address can represent an
+ * account, muxed account, contract, claimable balance, or a liquidity pool
+ * (the latter two can only be present as the *output* of Core in the form
+ * of an event, never an input to a smart contract).
  *
  * @constructor
  *
- * @param {string} address - ID of the account (ex.
- *     `GB3KJPLFUYN5VL6R3GU3EGCGVCKFDSD7BEDX42HWG5BWFKB3KQGJJRMA`). If you
- *     provide a muxed account address, this will throw; use {@link
- *     MuxedAccount} instead.
+ * @param {string} address - a {@link StrKey} of the address value
  */
 export class Address {
   constructor(address) {
@@ -22,6 +22,15 @@ export class Address {
     } else if (StrKey.isValidContract(address)) {
       this._type = 'contract';
       this._key = StrKey.decodeContract(address);
+    } else if (StrKey.isValidMed25519PublicKey(address)) {
+      this._type = 'muxedAccount';
+      this._key = StrKey.decodeMed25519PublicKey(address);
+    } else if (StrKey.isValidClaimableBalance(address)) {
+      this._type = 'claimableBalance';
+      this._key = StrKey.decodeClaimableBalance(address);
+    } else if (StrKey.isValidLiquidityPool(address)) {
+      this._type = 'liquidityPool';
+      this._key = StrKey.decodeLiquidityPool(address);
     } else {
       throw new Error(`Unsupported address type: ${address}`);
     }
@@ -58,7 +67,37 @@ export class Address {
   }
 
   /**
-   * Convert this from an xdr.ScVal type
+   * Creates a new claimable balance Address object from a buffer of raw bytes.
+   *
+   * @param {Buffer} buffer - The bytes of a claimable balance ID to parse.
+   * @returns {Address}
+   */
+  static claimableBalance(buffer) {
+    return new Address(StrKey.encodeClaimableBalance(buffer));
+  }
+
+  /**
+   * Creates a new liquidity pool Address object from a buffer of raw bytes.
+   *
+   * @param {Buffer} buffer - The bytes of an LP ID to parse.
+   * @returns {Address}
+   */
+  static liquidityPool(buffer) {
+    return new Address(StrKey.encodeLiquidityPool(buffer));
+  }
+
+  /**
+   * Creates a new muxed account Address object from a buffer of raw bytes.
+   *
+   * @param {Buffer} buffer - The bytes of an address to parse.
+   * @returns {Address}
+   */
+  static muxedAccount(buffer) {
+    return new Address(StrKey.encodeMed25519PublicKey(buffer));
+  }
+
+  /**
+   * Convert this from an xdr.ScVal type.
    *
    * @param {xdr.ScVal} scVal - The xdr.ScVal type to parse
    * @returns {Address}
@@ -79,8 +118,14 @@ export class Address {
         return Address.account(scAddress.accountId().ed25519());
       case xdr.ScAddressType.scAddressTypeContract().value:
         return Address.contract(scAddress.contractId());
+      case xdr.ScAddressType.scAddressTypeMuxedAccount().value:
+        return Address.muxedAccount(scAddress.muxedAccount());
+      case xdr.ScAddressType.scAddressTypeClaimableBalance().value:
+        return Address.claimableBalance(scAddress.claimableBalanceId());
+      case xdr.ScAddressType.scAddressTypeLiquidityPool().value:
+        return Address.liquidityPool(scAddress.liquidityPoolId());
       default:
-        throw new Error('Unsupported address type');
+        throw new Error(`Unsupported address type: ${scAddress.switch().name}`);
     }
   }
 
@@ -95,6 +140,12 @@ export class Address {
         return StrKey.encodeEd25519PublicKey(this._key);
       case 'contract':
         return StrKey.encodeContract(this._key);
+      case 'claimableBalance':
+        return StrKey.encodeClaimableBalance(this._key);
+      case 'liquidityPool':
+        return StrKey.encodeLiquidityPool(this._key);
+      case 'muxedAccount':
+        return StrKey.encodeMed25519PublicKey(this._key);
       default:
         throw new Error('Unsupported address type');
     }
@@ -122,8 +173,14 @@ export class Address {
         );
       case 'contract':
         return xdr.ScAddress.scAddressTypeContract(this._key);
+      case 'claimableBalance':
+        return xdr.ScAddress.scAddressTypeClaimableBalance(this._key);
+      case 'liquidityPool':
+        return xdr.ScAddress.scAddressTypeLiquidityPool(this._key);
+      case 'muxedAccount':
+        return xdr.ScAddress.scAddressTypeMuxedAccount(this._key);
       default:
-        throw new Error('Unsupported address type');
+        throw new Error(`Unsupported address type: ${this._type}`);
     }
   }
 

src/operations/invoke_host_function.js

@@ -34,6 +34,35 @@ export function invokeHostFunction(opts) {
     );
   }
 
+  if (
+    opts.func.switch().value ===
+    xdr.HostFunctionType.hostFunctionTypeInvokeContract().value
+  ) {
+    // Ensure that there are no claimable balance or liquidity pool IDs in the
+    // invocation because those are not allowed.
+    opts.func
+      .invokeContract()
+      .args()
+      .forEach((arg) => {
+        let scv;
+        try {
+          scv = Address.fromScVal(arg);
+        } catch {
+          // swallow non-Address errors
+          return;
+        }
+
+        switch (scv._type) {
+          case 'claimableBalance':
+          case 'liquidityPool':
+            throw new TypeError(
+              `claimable balances and liquidity pools cannot be arguments to invokeHostFunction`
+            );
+          default:
+        }
+      });
+  }
+
   const invokeHostFunctionOp = new xdr.InvokeHostFunctionOp({
     hostFunction: opts.func,
     auth: opts.auth || []

src/strkey.js

@@ -33,6 +33,8 @@ const strkeyTypes = {
  * string (i.e. "GABCD...", etc.) representations.
  */
 export class StrKey {
+  static types = strkeyTypes;
+
   /**
    * Encodes `data` to strkey ed25519 public key.
    *