SDK Cheat Sheet

import { LedgerSdk } from '@minka/ledger-sdk'
const sdk = new LedgerSdk({
	// Handle of the ledger to use
	ledger: 'my-ledger',
 
	// Server to connect, without trailing slash
	server: 'http://localhost:3000/v2',
 
	// Optional, timeout in milliseconds. Defaults to 15000
	timeout?: 15000,
 
	// Optional, automatically verify server responses
	verifyResponseProofs: true, 
 
	// Optional, Public key used to check responses coming from the server
	signer: { 
			format: 'ed25519-raw', // Only format supported for now
			public: '<ledger public key>'
	},
 
	// Optional, default values for auth composition
	secure: {
		iss: '<issuer of jwt>', // signer handle or public key
		sub: '<subject for the generated jwt>', // signer:<handle>, bridge:<handle>, ...
		aud: '<target audience of the jwt>', // ledger handle or public key
		exp: 60, // Expiration time of tokens, in seconds
		keyPair: { // Public-secret key pair used to sign tokens
			format: 'ed25519-raw',
			public: '<public key>',
			secret: '<secret key>'
		}
	},
})

const getOwnerAccessRules = (publicKey) => {
	return [
		{
			action: 'any',
			signer: {
				public: publicKey
			}
		},
		{
			action: 'read',
			bearer: {
				$signer: {
					public: publicKey
				}
			}
		}
	]
}

// Make sure this code is inside an async function so you can use await
const signer = sdk.signer
    .init()
    .data({ handle: 'local_signer' })
    .keys({ format: 'ed25519-raw' })
const { data } = await signer.read()
 
// Extract only the data we need for signing
const keyPair = {
	format: data.format,
	public: data.public,
	secret: data.secret
}

const signerData = {
	handle: 'remote_signer',
	format: keyPair.format,
	public: keyPair.public,
	secret: keyPair.secret,
	access: getOwnerAccessRules( keyPair.public )
}
const remoteSigner = sdk.signer
	.init()
	.data(signerData)
	.code('password') // Optional, this will encrypt secret key
	.hash()
	.lock() // Will sign the record using the own key pair
 
// Send the request to the server, this operation is always asynchronous
await remoteSigner.send()

// Note that 'remote_signer' is the handle previously set
const { signer } = await sdk.signer.read('remote_signer')
 
const plainSigner = await sdk.signer
	.init()
	.data(signer)
	.code('password') // If we used a password to encrypt the server
	.read({plain: true}) // use plain:true to decrypt secret using password
 
// Just as we did when creating our local signer, we can extract the data
// that we need to use for signing
const remoteKeyPair = {
	format: plainSigner.data.format,
	public: plainSigner.data.public,
	secret: plainSigner.data.secret
}

/**
 * Factor is used to represent the decimal currency
 * amounts as integers. Decimal amounts are multiplied
 * with this factor when storing to ledger.
 */
const symbolData = {
	handle: 'usd', // Unique identifier
	factor: 100 // 100 stands for 2 decimal places
	access: getOwnerAccessRules( keyPair.public )
}
 
await sdk.symbol
	.init()
	.data(symbolData)
	.hash()
	.sign([{keyPair}])
	.send()

await sdk.wallet
	.init()
	.data({
		handle: 'tesla',
		access: getOwnerAccessRules( keyPair.public )
	})
	.hash()
	.sign([{keyPair}])
	.send()
 
await sdk.wallet
	.init()
	.data({
		handle: 'minka',
		access: getOwnerAccessRules( keyPair.public )
	})
	.hash()
	.sign([{keyPair}])
	.send()

const { wallet } = await sdk.wallet.read('tesla')
// Output: Wallet data for `tesla`
 
const { balances } = await sdk.wallet.getBalances('tesla')
// Output: Empty array, no balances for now

await sdk.bridge
	.init()
	.data({
		handle: 'teslabank',
		config: {
			server: 'http://tesla.com/bank/v2' // URL of the bridge
		},
		secure: [
			// Security rules to define auth mechanism between bridge and server
		]
		access: getOwnerAccessRules( keyPair.public )
	})
	.hash()
	.sign([{keyPair}])
	.send()

// Retrieve the current wallet from the server
const { wallet, response } = await sdk.wallet.read('tesla')
 
// Update the wallet by passing the new field
await sdk.wallet
	.from(response.data)
	.data({
		bridge: 'teslabank'
	})
	.hash()
	.sign([{keyPair}])
	.send()
 
// We can also update the wallet by passing the entire wallet on our `data` method
await sdk.wallet
	.from(response.data)
	.data({
		...wallet, // Spread the old wallet data
		bridge: 'teslabank'
	}, true) // Pass true as second argument (replace)
	.hash()
	.sign([{keyPair}])
	.send()

const claim = {
	action: 'issue',
	target: 'tesla',
	symbol: 'usd',
	amount: 10000 // This stands for 100.00$, because usd has a factor of 100
}
 
await sdk.intent
	.init()
	.data({
		handle: sdk.handle.unique(), // will return a random unique handle
		claims: [ claim ],
		access: getOwnerAccessRules(keyPair.public)
	})
	.hash()
	.sign([{keyPair}])
	.send()
 
const { balances } = await sdk.wallet.getBalances('tesla')
// Output: [ { wallet: 'tesla', symbol: 'usd', amount: 10000 } ]

const { response } = await sdk.intent.read('<intent-handle>')
	await sdk.intent
	.from(response.data)
	.hash()
	.sign([
		{
			keyPair,
			custom: { // Optional custom data for the signature
				status: 'prepared'
			}
		}
	])
	.send()

const { response } = await sdk.intent.read('<intent-handle>')
const record = response.data
 
const verifier = sdk.proofs
 
// We can add assertions to our verification client
verifier.length(1) // At least 1 proofs present, all clients have this by default
        .length(2, 3) // At least 2 proofs, but less than 3
// Expect at least one proof made with the ledger signer specified on sdk initialization
        .ledger() 
// Expect at least one proof that partially matches the given object
        .expect({ custom:{ status: 'prepared' } })
 
// The verify method checks all assertions on the given record.
// It alsos verifies that all proofs are valid.
await verifier.verify(record)
await verifier.verify(record) // Assertions are reusable with other records
 
// Get a new, clean verification client with only `length(1)` assertion.
const otherVerifier = sdk.proofs
await otherVerifier.verify(record)

const { response: { data: record } } = await sdk.intent.read('<intent-handle>')
const error = sdk.proofs.error(record)
// Output: Found LedgerSdkError in the last proof, if any.

// Get the client
const client = sdk.wallet // Can be wallet, signer, symbol, intent...
 
// Initialize the record
const record = client.init()
 
// Set the data
record.data({
	handle: 'my-wallet'
})
 
// Create a hash for that data
record.hash()
 
// Sign the record using provided array of parameters
record.sign([
	{
		keyPair,
	},
	{
		keyPair,
		/**
		 * Custom data can be assigned to signatures. This
		 * will be included in the calculation of the result
     * for this specific signature, and should be used in
     * the future to validate it.
		 */
		custom: {
			identifier: 123456
		}
	}
])
 
// Send that record to the backend
await record.send()
 
/**
 * You could also add the entire record data directly into the .init
 * method of the record. This mean you can pass the hash and proofs by
 * yourself instead of using `hash` and `sign` methods respectively, or
 * just pass the data instead of using the .data method
 */
await client
	.init({
		data: {
			handle: 'my-wallet'
		},
		hash: '<valid-hash>',
		meta: {
			proofs: [
				{'Valid signature'},
				// More proofs
			]
		}
	})
	.send()

// Get the client
const client = sdk.symbol
 
// Get data for symbol with handle `usd`
const symbolResponse = await client.read('usd')
 
const record = {
	hash: symbolResponse.hash // Hash of the record
	meta: symbolResponse.meta // Metadata of the record, including proofs
	data: symbolResponse.symbol // Data of the record
}
 
/**
 * When updating, reading or creating records using the SDK the returned value
 * will include the property `response`, which is an instance of axios response.
 * That means you can also get the entire record from the body of that response.
 */
const record = symbolResponse.response.data; // Includes hash, meta and data properties

// Get the client
const client = sdk.symbol
 
// Get the current record
const record = (await client.read('usd')).response.data
 
// Update an specific field of the record
await client
	.from(record)
	.data(
		{
			factor: 10
		}
	)
	.hash() // The hash of the record will change with new data
	.sign([{keyPair}]) // The new hash needs to be signed
	.send()
 
// Update the entire record
await client
	.from(record)
	.data(
		{
			...record.data, // Spread the entire data of the old record
			factor: 10
		},
		true // Pass true (replace) as second argument
	)
	.hash()
	.sign([{keyPair}])
	.send()

// Get the client
const client = sdk.wallet
 
// Get the first 20 wallets (Default)
const { wallets } = await client.list()
 
// Get first 10 wallets
const { wallets } = await client
	.list({
		page: {
			index: 0,
			limit: 10,
		},
	})
 
// Get next 10 wallets
const { wallets } = await client
	.list({
		page: {
			index: 1,
			limit: 10,
		},
	})
 
/**
 * Please note that the result of `wallets` will contain only data of the record.
 * If you want the entire record (Including both hash and meta properties), you
 * may need to get the list directly from the `response` property.
 */
const listResponse = await client.list()
const walletRecords = listResponse.response.data;

// Get first 10 bank wallets
const { wallets } = await client
	.list({
		page: {
			index: 0,
			limit: 10,
	    },
	    'data.schema.$eq': 'bank'
	})

const { schema } = await sdk
	.schema
	.init()
	.data(...)
	.hash()
	.sign([{keyPair}])
	.send()

const { wallet } = await sdk
	.wallet
	.init()
	.data({
		handle: 'my_wallet',
		schema: '<schema_handle>',
	})
	.hash()
	.sign([{keyPair}])
	.send()

// Create a signer generating a random key pair
await sdk.signer
	.init()
  .keys({    // Use the .keys method to randomly generate key pair
		format: 'ed25519-raw'
	})
	.code(...) // Optional
	.hash()
	.lock()    // Sign using the record's key pair
	.send()
 
// Create a signer providing an specific keypair
await sdk.signer
	.init()
	.data(...) // Use .data to pass the desired key pair
	.code(...) // Optional
	.hash()
	.sign(...) // Sign with the provided key pairs
	.send()
 
/**
 * Note that .lock is similar to .sign, but you don't
 * need to pass any parameter because .lock uses the
 * key pair of the record itself.
 */
 
// Update a signer
await sdk.signer
	.from(...)
	.data(...)
	.hash()
	.sign(...) // Sign using any provided key pair
	.lock()    // Sign using it's own key pair
	.send()
 
/**
 * When using lock, you may need to previously call the
 * .code method with the proper password to decrypt the
 * secret key if it was previously encrypted.
 */
 
// Get data from an specific signer
await sdk.signer.read('<handle>')
 
// Get list of signers
await sdk.signer.list(...)
 
// Retrieve keys from a signer
await sdk.signer
	.init()
	.data({
		handle: 'any-handle'
		// If not public and secret is provided, they will be generated
		// when calling the .keys method
	})
	.keys({ format: 'ed25519-raw' })
	.code(...) // Optional
	.read({plain:true})

// Create a symbol
await sdk.symbol
	.init()
	.data(...)
	.hash()
	.sign(...)
	.send()
 
// Update a symbol
await sdk.symbol
	.from(...)
	.data(...)
	.hash()
	.sign(...)
	.send()
 
// Get data from an specific symbol
await sdk.symbol.read('<handle>')
 
// Get list of symbols
await sdk.symbol.list(...)

// Create a wallet
await sdk.wallet
	.init()
	.data(...)
	.hash()
	.sign(...)
	.send()
 
// Update a wallet
await sdk.wallet
	.from(...)
	.data(...)
	.hash()
	.sign(...)
	.send()
 
// Get data from an specific wallet
await sdk.wallet.read('<handle>')
 
// Get list of wallets
await sdk.wallet.list(...)
 
// Get balances from an specific wallet
await sdk.wallet.getBalances('<handle>')
 
// Get domains from an specific wallet
await sdk.wallet.getDomains('<handle>')
 
// Get anchors from an specific wallet
await sdk.wallet.getAnchors('<handle>')
 
// Get anchors from an specific wallet via lookup. It enables to pass 
// additional arguments
await sdk
	.wallet
	.with('<handle>')
	.lookup()
	.data(...)
  .hash()
  .sign(...)
  .send()

// Create a bridge
await sdk.bridge
	.init()
	.data(...)
	.hash()
	.sign(...)
	.send()
 
// Update a bridge
await sdk.bridge
	.from(...)
	.data(...)
	.hash()
	.sign(...)
	.send()
 
// Get data from an specific bridge
await sdk.bridge.read('<handle>')
 
// Get list of bridges
await sdk.bridge.list(...)

// Create an intent
await sdk.intent
	.init()
	.data(...)
	.hash()
	.sign(...)
	.send()
 
// Sign an intent
await sdk.intent
	.from(...)
	.hash()
	.sign(...)
	.send()
 
// Get data from an specific intent
await sdk.intent.read('<handle>')
 
// Get list of intents
await sdk.intent.list(...)

// Create an effect
await sdk.effect
	.init()
	.data(...)
	.hash()
	.sign(...)
	.send()
 
// Update an effect
await sdk.effect
	.from(...)
	.data(...)
	.hash()
	.sign(...)
	.send()
 
// Get data from an specific effect
await sdk.effect.read('<handle>')
 
// Get list of effects
await sdk.effect.list(...)

// Create a circle
await sdk.circle
	.init()
	.data(...)
	.hash()
	.sign(...)
	.send()
 
// Update a circle
await sdk.circle
	.from(...)
	.data(...)
	.hash()
	.sign(...)
	.send()
 
// Get data from an specific circle
await sdk.circle.read('<handle>')
 
// Get list of circles
await sdk.circle.list(...)
 
// Assign a signer to a circle
await sdk.circle
	.with('<circle handle>')
  .signers
  .init()
  .data(...)
  .hash()
	.sign(...)
	.send()
 
// List signers of a circle
await sdk.circle
	.with('<circle handle>')
  .signers
  .list(...)
 
// Removing signers from a circle
await sdk.circle
	.with('<circle handle>')
  .signers
  .with('<signer handle>')
  .drop()
  .hash()
  .sign(...)
  .send()

// Create a schema
await sdk.schema
	.init()
	.data(...)
	.hash()
	.sign(...)
	.send()
 
// Update a schema
await sdk.schema
	.from(...)
	.data(...)
	.hash()
	.sign(...)
	.send()
 
// Get data from an specific schema
await sdk.schema.read('<handle>')
 
// Get list of schemas
await sdk.schema.list(...)

// Create an anchor
await sdk.anchor
	.init()
	.data(...)
	.hash()
	.sign(...)
	.send()
 
// Update an anchor
await sdk.anchor
	.from(...)
	.data(...)
	.hash()
	.sign(...)
	.send()
 
// Get data from an specific anchor
await sdk.anchor.read('<handle>')
 
// Get list of anchors
await sdk.anchor.list(...)

// Create a policy
await sdk.policy
	.init()
	.data(...)
	.hash()
	.sign(...)
	.send()
 
// Update a policy
await sdk.policy
	.from(...)
	.data(...)
	.hash()
	.sign(...)
	.send()
 
// Get data from an specific policy
await sdk.policy.read('<handle>')
 
// Get list of policies
await sdk.policy.list(...)